dlls/mshtml/editor.c

   1 /*
   2  * Copyright 2006-2007 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "winnls.h"
  30 #include "ole2.h"
  31 #include "mshtmcid.h"
  32
  33 #include "wine/debug.h"
  34 #include "wine/unicode.h"
  35
  36 #include "mshtml_private.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  39
  40 #define NSCMD_ALIGN        "cmd_align"
  41 #define NSCMD_BOLD         "cmd_bold"
  42 #define NSCMD_CHARNEXT     "cmd_charNext"
  43 #define NSCMD_CHARPREVIOUS "cmd_charPrevious"
  44 #define NSCMD_COPY         "cmd_copy"
  45 #define NSCMD_CUT          "cmd_cut"
  46 #define NSCMD_FONTCOLOR    "cmd_fontColor"
  47 #define NSCMD_FONTFACE     "cmd_fontFace"
  48 #define NSCMD_INDENT       "cmd_indent"
  49 #define NSCMD_INSERTHR     "cmd_insertHR"
  50 #define NSCMD_ITALIC       "cmd_italic"
  51 #define NSCMD_LINENEXT     "cmd_lineNext"
  52 #define NSCMD_LINEPREVIOUS "cmd_linePrevious"
  53 #define NSCMD_MOVEPAGEDOWN "cmd_movePageDown"
  54 #define NSCMD_MOVEPAGEUP   "cmd_movePageUp"
  55 #define NSCMD_OL           "cmd_ol"
  56 #define NSCMD_OUTDENT      "cmd_outdent"
  57 #define NSCMD_PASTE        "cmd_paste"
  58 #define NSCMD_SELECTCHARNEXT      "cmd_selectCharNext"
  59 #define NSCMD_SELECTCHARPREVIOUS  "cmd_selectCharPrevious"
  60 #define NSCMD_SELECTLINENEXT      "cmd_selectLineNext"
  61 #define NSCMD_SELECTLINEPREVIOUS  "cmd_selectLinePrevious"
  62 #define NSCMD_SELECTPAGEDOWN      "cmd_selectPageDown"
  63 #define NSCMD_SELECTPAGEUP        "cmd_selectPageUp"
  64 #define NSCMD_SELECTWORDNEXT      "cmd_selectWordNext"
  65 #define NSCMD_SELECTWORDPREVIOUS  "cmd_selectWordPrevious"
  66 #define NSCMD_UL           "cmd_ul"
  67 #define NSCMD_UNDERLINE    "cmd_underline"
  68 #define NSCMD_WORDNEXT     "cmd_wordNext"
  69 #define NSCMD_WORDPREVIOUS "cmd_wordPrevious"
  70
  71 #define NSSTATE_ATTRIBUTE "state_attribute"
  72 #define NSSTATE_ALL       "state_all"
  73
  74 #define NSALIGN_CENTER "center"
  75 #define NSALIGN_LEFT   "left"
  76 #define NSALIGN_RIGHT  "right"
  77
  78 #define DOM_VK_LEFT  VK_LEFT
  79 #define DOM_VK_UP    VK_UP
  80 #define DOM_VK_RIGHT VK_RIGHT
  81 #define DOM_VK_DOWN  VK_DOWN
  82
  83 static const WCHAR wszFont[] = {'f','o','n','t',0};
  84 static const WCHAR wszSize[] = {'s','i','z','e',0};
  85
  86 static void do_ns_command(NSContainer *This, const char *cmd, nsICommandParams *nsparam)
  87 {
  88     nsICommandManager *cmdmgr;
  89     nsIInterfaceRequestor *iface_req;
  90     nsresult nsres;
  91
  92     TRACE("(%p)\n", This);
  93
  94     nsres = nsIWebBrowser_QueryInterface(This->webbrowser,
  95             &IID_nsIInterfaceRequestor, (void**)&iface_req);
  96     if(NS_FAILED(nsres)) {
  97         ERR("Could not get nsIInterfaceRequestor: %08x\n", nsres);
  98         return;
  99     }
 100
 101     nsres = nsIInterfaceRequestor_GetInterface(iface_req, &IID_nsICommandManager,
 102                                                (void**)&cmdmgr);
 103     nsIInterfaceRequestor_Release(iface_req);
 104     if(NS_FAILED(nsres)) {
 105         ERR("Could not get nsICommandManager: %08x\n", nsres);
 106         return;
 107     }
 108
 109     nsres = nsICommandManager_DoCommand(cmdmgr, cmd, nsparam, NULL);
 110     if(NS_FAILED(nsres))
 111         ERR("DoCommand(%s) failed: %08x\n", debugstr_a(cmd), nsres);
 112
 113     nsICommandManager_Release(cmdmgr);
 114 }
 115
 116 static void do_ns_editor_command(NSContainer *This, const char *cmd)
 117 {
 118     nsresult nsres;
 119
 120     if(!This->editor_controller)
 121         return;
 122
 123     nsres = nsIController_DoCommand(This->editor_controller, cmd);
 124     if(NS_FAILED(nsres))
 125         ERR("DoCommand(%s) failed: %08x\n", debugstr_a(cmd), nsres);
 126 }
 127
 128 static nsresult get_ns_command_state(NSContainer *This, const char *cmd, nsICommandParams *nsparam)
 129 {
 130     nsICommandManager *cmdmgr;
 131     nsIInterfaceRequestor *iface_req;
 132     nsresult nsres;
 133
 134     nsres = nsIWebBrowser_QueryInterface(This->webbrowser,
 135             &IID_nsIInterfaceRequestor, (void**)&iface_req);
 136     if(NS_FAILED(nsres)) {
 137         ERR("Could not get nsIInterfaceRequestor: %08x\n", nsres);
 138         return nsres;
 139     }
 140
 141     nsres = nsIInterfaceRequestor_GetInterface(iface_req, &IID_nsICommandManager,
 142                                                (void**)&cmdmgr);
 143     nsIInterfaceRequestor_Release(iface_req);
 144     if(NS_FAILED(nsres)) {
 145         ERR("Could not get nsICommandManager: %08x\n", nsres);
 146         return nsres;
 147     }
 148
 149     nsres = nsICommandManager_GetCommandState(cmdmgr, cmd, NULL, nsparam);
 150     if(NS_FAILED(nsres))
 151         ERR("GetCommandState(%s) failed: %08x\n", debugstr_a(cmd), nsres);
 152
 153     nsICommandManager_Release(cmdmgr);
 154     return nsres;
 155 }
 156
 157 static DWORD query_ns_edit_status(HTMLDocument *This, const char *nscmd)
 158 {
 159     nsICommandParams *nsparam;
 160     PRBool b = FALSE;
 161
 162     if(This->usermode != EDITMODE || This->readystate < READYSTATE_INTERACTIVE)
 163         return OLECMDF_SUPPORTED;
 164
 165     if(This->nscontainer && nscmd) {
 166         nsparam = create_nscommand_params();
 167         get_ns_command_state(This->nscontainer, nscmd, nsparam);
 168
 169         nsICommandParams_GetBooleanValue(nsparam, NSSTATE_ALL, &b);
 170
 171         nsICommandParams_Release(nsparam);
 172     }
 173
 174     return OLECMDF_SUPPORTED | OLECMDF_ENABLED | (b ? OLECMDF_LATCHED : 0);
 175 }
 176
 177 static void set_ns_align(HTMLDocument *This, const char *align_str)
 178 {
 179     nsICommandParams *nsparam;
 180
 181     if(!This->nscontainer)
 182         return;
 183
 184     nsparam = create_nscommand_params();
 185     nsICommandParams_SetCStringValue(nsparam, NSSTATE_ATTRIBUTE, align_str);
 186
 187     do_ns_command(This->nscontainer, NSCMD_ALIGN, nsparam);
 188
 189     nsICommandParams_Release(nsparam);
 190 }
 191
 192 static DWORD query_align_status(HTMLDocument *This, const char *align_str)
 193 {
 194     nsICommandParams *nsparam;
 195     char *align = NULL;
 196
 197     if(This->usermode != EDITMODE || This->readystate < READYSTATE_INTERACTIVE)
 198         return OLECMDF_SUPPORTED;
 199
 200     if(This->nscontainer) {
 201         nsparam = create_nscommand_params();
 202         get_ns_command_state(This->nscontainer, NSCMD_ALIGN, nsparam);
 203
 204         nsICommandParams_GetCStringValue(nsparam, NSSTATE_ATTRIBUTE, &align);
 205
 206         nsICommandParams_Release(nsparam);
 207     }
 208
 209     return OLECMDF_SUPPORTED | OLECMDF_ENABLED
 210         | (align && !strcmp(align_str, align) ? OLECMDF_LATCHED : 0);
 211 }
 212
 213
 214 static nsISelection *get_ns_selection(HTMLDocument *This)
 215 {
 216     nsIDOMWindow *dom_window;
 217     nsISelection *nsselection = NULL;
 218     nsresult nsres;
 219
 220     if(!This->nscontainer)
 221         return NULL;
 222
 223     nsres = nsIWebBrowser_GetContentDOMWindow(This->nscontainer->webbrowser, &dom_window);
 224     if(NS_FAILED(nsres))
 225         return NULL;
 226
 227     nsIDOMWindow_GetSelection(dom_window, &nsselection);
 228     nsIDOMWindow_Release(dom_window);
 229
 230     return nsselection;
 231
 232 }
 233
 234 static void remove_child_attr(nsIDOMElement *elem, LPCWSTR tag, nsAString *attr_str)
 235 {
 236     PRBool has_children;
 237     PRUint32 child_cnt, i;
 238     nsIDOMNode *child_node;
 239     nsIDOMNodeList *node_list;
 240     PRUint16 node_type;
 241
 242     nsIDOMElement_HasChildNodes(elem, &has_children);
 243     if(!has_children)
 244         return;
 245
 246     nsIDOMElement_GetChildNodes(elem, &node_list);
 247     nsIDOMNodeList_GetLength(node_list, &child_cnt);
 248
 249     for(i=0; i<child_cnt; i++) {
 250         nsIDOMNodeList_Item(node_list, i, &child_node);
 251
 252         nsIDOMNode_GetNodeType(child_node, &node_type);
 253         if(node_type == ELEMENT_NODE) {
 254             nsIDOMElement *child_elem;
 255             nsAString tag_str;
 256             const PRUnichar *ctag;
 257
 258             nsIDOMNode_QueryInterface(child_node, &IID_nsIDOMElement, (void**)&child_elem);
 259
 260             nsAString_Init(&tag_str, NULL);
 261             nsIDOMElement_GetTagName(child_elem, &tag_str);
 262             nsAString_GetData(&tag_str, &ctag, NULL);
 263
 264             if(!strcmpiW(ctag, tag))
 265                 /* FIXME: remove node if there are no more attributes */
 266                 nsIDOMElement_RemoveAttribute(child_elem, attr_str);
 267
 268             nsAString_Finish(&tag_str);
 269
 270             remove_child_attr(child_elem, tag, attr_str);
 271
 272             nsIDOMNode_Release(child_elem);
 273         }
 274
 275         nsIDOMNode_Release(child_node);
 276     }
 277
 278     nsIDOMNodeList_Release(node_list);
 279 }
 280
 281 static void get_font_size(HTMLDocument *This, WCHAR *ret)
 282 {
 283     nsISelection *nsselection = get_ns_selection(This);
 284     nsIDOMElement *elem = NULL;
 285     nsIDOMNode *node = NULL, *tmp_node;
 286     nsAString tag_str;
 287     LPCWSTR tag;
 288     PRUint16 node_type;
 289     nsresult nsres;
 290
 291     *ret = 0;
 292
 293     if(!nsselection)
 294         return;
 295
 296     nsISelection_GetFocusNode(nsselection, &node);
 297     nsISelection_Release(nsselection);
 298
 299     while(node) {
 300         nsres = nsIDOMNode_GetNodeType(node, &node_type);
 301         if(NS_FAILED(nsres) || node_type == DOCUMENT_NODE)
 302             break;
 303
 304         if(node_type == ELEMENT_NODE) {
 305             nsIDOMNode_QueryInterface(node, &IID_nsIDOMElement, (void**)&elem);
 306
 307             nsAString_Init(&tag_str, NULL);
 308             nsIDOMElement_GetTagName(elem, &tag_str);
 309             nsAString_GetData(&tag_str, &tag, NULL);
 310
 311             if(!strcmpiW(tag, wszFont)) {
 312                 nsAString size_str, val_str;
 313                 LPCWSTR val;
 314
 315                 TRACE("found font tag %p\n", elem);
 316
 317                 nsAString_Init(&size_str, wszSize);
 318                 nsAString_Init(&val_str, NULL);
 319
 320                 nsIDOMElement_GetAttribute(elem, &size_str, &val_str);
 321                 nsAString_GetData(&val_str, &val, NULL);
 322
 323                 if(*val) {
 324                     TRACE("found size %s\n", debugstr_w(val));
 325                     strcpyW(ret, val);
 326                 }
 327
 328                 nsAString_Finish(&size_str);
 329                 nsAString_Finish(&val_str);
 330             }
 331
 332             nsAString_Finish(&tag_str);
 333
 334             nsIDOMElement_Release(elem);
 335         }
 336
 337         if(*ret)
 338             break;
 339
 340         tmp_node = node;
 341         nsIDOMNode_GetParentNode(node, &node);
 342         nsIDOMNode_Release(tmp_node);
 343     }
 344
 345     if(node)
 346         nsIDOMNode_Release(node);
 347 }
 348
 349 static void set_font_size(HTMLDocument *This, LPCWSTR size)
 350 {
 351     nsISelection *nsselection;
 352     PRBool collapsed;
 353     nsIDOMDocument *nsdoc;
 354     nsIDOMElement *elem;
 355     nsIDOMRange *range;
 356     PRInt32 range_cnt = 0;
 357     nsAString font_str;
 358     nsAString size_str;
 359     nsAString val_str;
 360     nsresult nsres;
 361
 362     nsselection = get_ns_selection(This);
 363
 364     if(!nsselection)
 365         return;
 366
 367     nsISelection_GetRangeCount(nsselection, &range_cnt);
 368     if(range_cnt != 1) {
 369         FIXME("range_cnt %d not supprted\n", range_cnt);
 370         if(!range_cnt) {
 371             nsISelection_Release(nsselection);
 372             return;
 373         }
 374     }
 375
 376     nsres = nsIWebNavigation_GetDocument(This->nscontainer->navigation, &nsdoc);
 377     if(NS_FAILED(nsres))
 378         return;
 379
 380     nsAString_Init(&font_str, wszFont);
 381     nsAString_Init(&size_str, wszSize);
 382     nsAString_Init(&val_str, size);
 383
 384     nsIDOMDocument_CreateElement(nsdoc, &font_str, &elem);
 385     nsIDOMElement_SetAttribute(elem, &size_str, &val_str);
 386
 387     nsISelection_GetRangeAt(nsselection, 0, &range);
 388     nsISelection_GetIsCollapsed(nsselection, &collapsed);
 389     nsISelection_RemoveAllRanges(nsselection);
 390
 391     nsIDOMRange_SurroundContents(range, (nsIDOMNode*)elem);
 392
 393     if(collapsed) {
 394         nsISelection_Collapse(nsselection, (nsIDOMNode*)elem, 0);
 395     }else {
 396         /* Remove all size attrbutes from the range */
 397         remove_child_attr(elem, wszFont, &size_str);
 398         nsISelection_SelectAllChildren(nsselection, (nsIDOMNode*)elem);
 399     }
 400
 401     nsIDOMRange_Release(range);
 402     nsIDOMElement_Release(elem);
 403
 404     nsAString_Finish(&font_str);
 405     nsAString_Finish(&size_str);
 406     nsAString_Finish(&val_str);
 407
 408     nsISelection_Release(nsselection);
 409     nsIDOMDocument_Release(nsdoc);
 410 }
 411
 412 static BOOL is_visible_text_node(nsIDOMNode *node)
 413 {
 414     nsIDOMCharacterData *char_data;
 415     nsAString data_str;
 416     LPCWSTR data, ptr;
 417     PRUint32 len;
 418
 419     nsIDOMNode_QueryInterface(node, &IID_nsIDOMCharacterData, (void**)&char_data);
 420
 421     nsIDOMCharacterData_GetLength(char_data, &len);
 422
 423     nsAString_Init(&data_str, NULL);
 424     nsIDOMCharacterData_GetData(char_data, &data_str);
 425     nsAString_GetData(&data_str, &data, NULL);
 426
 427     if(*data == '\n') {
 428         len--;
 429         for(ptr=data+1; ptr && isspaceW(*ptr); ptr++)
 430             len--;
 431     }
 432
 433     nsAString_Finish(&data_str);
 434
 435     nsIDOMCharacterData_Release(char_data);
 436
 437     return len != 0;
 438 }
 439
 440 static nsIDOMNode *get_child_text_node(nsIDOMNode *node, BOOL first)
 441 {
 442     nsIDOMNode *iter, *iter2;
 443
 444     if(first)
 445         nsIDOMNode_GetFirstChild(node, &iter);
 446     else
 447         nsIDOMNode_GetLastChild(node, &iter);
 448
 449     while(iter) {
 450         PRUint16 node_type;
 451
 452         nsIDOMNode_GetNodeType(iter, &node_type);
 453         switch(node_type) {
 454         case TEXT_NODE:
 455             if(is_visible_text_node(iter))
 456                 return iter;
 457         case ELEMENT_NODE:
 458             iter2 = get_child_text_node(iter, first);
 459             if(iter2) {
 460                 nsIDOMNode_Release(iter);
 461                 return iter2;
 462             }
 463         }
 464
 465         if(first)
 466             nsIDOMNode_GetNextSibling(iter, &iter2);
 467         else
 468             nsIDOMNode_GetPreviousSibling(iter, &iter2);
 469
 470         nsIDOMNode_Release(iter);
 471         iter = iter2;
 472     }
 473
 474     return NULL;
 475 }
 476
 477 static void handle_arrow_key(HTMLDocument *This, nsIDOMKeyEvent *event, const char **cmds)
 478 {
 479     int i=0;
 480     PRBool b;
 481
 482     nsIDOMKeyEvent_GetCtrlKey(event, &b);
 483     if(b)
 484         i |= 1;
 485
 486     nsIDOMKeyEvent_GetShiftKey(event, &b);
 487     if(b)
 488         i |= 2;
 489
 490     do_ns_editor_command(This->nscontainer, cmds[i]);
 491
 492     nsIDOMKeyEvent_PreventDefault(event);
 493 }
 494
 495 void handle_edit_event(HTMLDocument *This, nsIDOMEvent *event)
 496 {
 497     nsIDOMKeyEvent *key_event;
 498     PRUint32 code;
 499
 500     nsIDOMEvent_QueryInterface(event, &IID_nsIDOMKeyEvent, (void**)&key_event);
 501
 502     nsIDOMKeyEvent_GetKeyCode(key_event, &code);
 503
 504     switch(code) {
 505     case DOM_VK_LEFT: {
 506         static const char *cmds[] = {
 507             NSCMD_CHARPREVIOUS,
 508             NSCMD_WORDPREVIOUS,
 509             NSCMD_SELECTCHARPREVIOUS,
 510             NSCMD_SELECTWORDPREVIOUS
 511         };
 512
 513         TRACE("left\n");
 514         handle_arrow_key(This, key_event, cmds);
 515         break;
 516     }
 517     case DOM_VK_RIGHT: {
 518         static const char *cmds[] = {
 519             NSCMD_CHARNEXT,
 520             NSCMD_WORDNEXT,
 521             NSCMD_SELECTCHARNEXT,
 522             NSCMD_SELECTWORDNEXT
 523         };
 524
 525         TRACE("right\n");
 526         handle_arrow_key(This, key_event, cmds);
 527         break;
 528     }
 529     case DOM_VK_UP: {
 530         static const char *cmds[] = {
 531             NSCMD_LINEPREVIOUS,
 532             NSCMD_MOVEPAGEUP,
 533             NSCMD_SELECTLINEPREVIOUS,
 534             NSCMD_SELECTPAGEUP
 535         };
 536
 537         TRACE("up\n");
 538         handle_arrow_key(This, key_event, cmds);
 539         break;
 540     }
 541     case DOM_VK_DOWN: {
 542         static const char *cmds[] = {
 543             NSCMD_LINENEXT,
 544             NSCMD_MOVEPAGEDOWN,
 545             NSCMD_SELECTLINENEXT,
 546             NSCMD_SELECTPAGEDOWN
 547         };
 548
 549         TRACE("down\n");
 550         handle_arrow_key(This, key_event, cmds);
 551         break;
 552     }
 553     };
 554
 555     nsIDOMKeyEvent_Release(key_event);
 556 }
 557
 558 static void set_ns_fontname(NSContainer *This, const char *fontname)
 559 {
 560     nsICommandParams *nsparam = create_nscommand_params();
 561
 562     nsICommandParams_SetCStringValue(nsparam, NSSTATE_ATTRIBUTE, fontname);
 563     do_ns_command(This, NSCMD_FONTFACE, nsparam);
 564     nsICommandParams_Release(nsparam);
 565 }
 566
 567 static HRESULT exec_fontname(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 568 {
 569     TRACE("(%p)->(%p %p)\n", This, in, out);
 570
 571     if(!This->nscontainer) {
 572         update_doc(This, UPDATE_UI);
 573         return E_FAIL;
 574     }
 575
 576     if(in) {
 577         char *stra;
 578         DWORD len;
 579
 580         if(V_VT(in) != VT_BSTR) {
 581             FIXME("Unsupported vt=%d\n", V_VT(out));
 582             return E_INVALIDARG;
 583         }
 584
 585         TRACE("%s\n", debugstr_w(V_BSTR(in)));
 586
 587         len = WideCharToMultiByte(CP_ACP, 0, V_BSTR(in), -1, NULL, 0, NULL, NULL);
 588         stra = mshtml_alloc(len);
 589         WideCharToMultiByte(CP_ACP, 0, V_BSTR(in), -1, stra, -1, NULL, NULL);
 590
 591         set_ns_fontname(This->nscontainer, stra);
 592
 593         mshtml_free(stra);
 594
 595         update_doc(This, UPDATE_UI);
 596     }
 597
 598     if(out) {
 599         nsICommandParams *nsparam;
 600         LPWSTR strw;
 601         char *stra;
 602         DWORD len;
 603         nsresult nsres;
 604
 605         nsparam = create_nscommand_params();
 606
 607         nsres = get_ns_command_state(This->nscontainer, NSCMD_FONTFACE, nsparam);
 608         if(NS_FAILED(nsres))
 609             return S_OK;
 610
 611         nsICommandParams_GetCStringValue(nsparam, NSSTATE_ATTRIBUTE, &stra);
 612         nsICommandParams_Release(nsparam);
 613
 614         len = MultiByteToWideChar(CP_ACP, 0, stra, -1, NULL, 0);
 615         strw = mshtml_alloc(len*sizeof(WCHAR));
 616         MultiByteToWideChar(CP_ACP, 0, stra, -1, strw, -1);
 617         nsfree(stra);
 618
 619         V_VT(out) = VT_BSTR;
 620         V_BSTR(out) = SysAllocString(strw);
 621         mshtml_free(strw);
 622     }
 623
 624     return S_OK;
 625 }
 626
 627 static HRESULT exec_forecolor(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 628 {
 629     TRACE("(%p)->(%p %p)\n", This, in, out);
 630
 631     if(in) {
 632         if(V_VT(in) == VT_I4) {
 633             nsICommandParams *nsparam = create_nscommand_params();
 634             char color_str[10];
 635
 636             sprintf(color_str, "#%02x%02x%02x",
 637                     V_I4(in)&0xff, (V_I4(in)>>8)&0xff, (V_I4(in)>>16)&0xff);
 638
 639             nsICommandParams_SetCStringValue(nsparam, NSSTATE_ATTRIBUTE, color_str);
 640             do_ns_command(This->nscontainer, NSCMD_FONTCOLOR, nsparam);
 641
 642             nsICommandParams_Release(nsparam);
 643         }else {
 644             FIXME("unsupported in vt=%d\n", V_VT(in));
 645         }
 646
 647         update_doc(This, UPDATE_UI);
 648     }
 649
 650     if(out) {
 651         FIXME("unsupported out\n");
 652         return E_NOTIMPL;
 653     }
 654
 655     return S_OK;
 656 }
 657
 658 static HRESULT exec_fontsize(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 659 {
 660     TRACE("(%p)->(%p %p)\n", This, in, out);
 661
 662     if(out) {
 663         WCHAR val[10] = {0};
 664
 665         switch(V_VT(out)) {
 666         case VT_I4:
 667             get_font_size(This, val);
 668             V_I4(out) = strtolW(val, NULL, 10);
 669             break;
 670         case VT_BSTR:
 671             get_font_size(This, val);
 672             V_BSTR(out) = SysAllocString(val);
 673             break;
 674         default:
 675             FIXME("unsupported vt %d\n", V_VT(out));
 676         }
 677     }
 678
 679     if(in) {
 680         switch(V_VT(in)) {
 681         case VT_I4: {
 682             WCHAR size[10];
 683             static const WCHAR format[] = {'%','d',0};
 684             wsprintfW(size, format, V_I4(in));
 685             set_font_size(This, size);
 686             break;
 687         }
 688         case VT_BSTR:
 689             set_font_size(This, V_BSTR(in));
 690             break;
 691         default:
 692             FIXME("unsupported vt %d\n", V_VT(in));
 693         }
 694
 695         update_doc(This, UPDATE_UI);
 696     }
 697
 698     return S_OK;
 699 }
 700
 701 static HRESULT exec_bold(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 702 {
 703     TRACE("(%p)\n", This);
 704
 705     if(in || out)
 706         FIXME("unsupported args\n");
 707
 708     if(This->nscontainer)
 709         do_ns_command(This->nscontainer, NSCMD_BOLD, NULL);
 710
 711     update_doc(This, UPDATE_UI);
 712     return S_OK;
 713 }
 714
 715 static HRESULT exec_italic(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 716 {
 717     TRACE("(%p)\n", This);
 718
 719     if(in || out)
 720         FIXME("unsupported args\n");
 721
 722     if(This->nscontainer)
 723         do_ns_command(This->nscontainer, NSCMD_ITALIC, NULL);
 724
 725     update_doc(This, UPDATE_UI);
 726     return S_OK;
 727 }
 728
 729 static HRESULT query_justify(HTMLDocument *This, OLECMD *cmd)
 730 {
 731     switch(cmd->cmdID) {
 732     case IDM_JUSTIFYCENTER:
 733         TRACE("(%p) IDM_JUSTIFYCENTER\n", This);
 734         cmd->cmdf = query_align_status(This, NSALIGN_CENTER);
 735         break;
 736     case IDM_JUSTIFYLEFT:
 737         TRACE("(%p) IDM_JUSTIFYLEFT\n", This);
 738         /* FIXME: We should set OLECMDF_LATCHED only if it's set explicitly. */
 739         if(This->usermode != EDITMODE || This->readystate < READYSTATE_INTERACTIVE)
 740             cmd->cmdf = OLECMDF_SUPPORTED;
 741         else
 742             cmd->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
 743         break;
 744     case IDM_JUSTIFYRIGHT:
 745         TRACE("(%p) IDM_JUSTIFYRIGHT\n", This);
 746         cmd->cmdf = query_align_status(This, NSALIGN_RIGHT);
 747         break;
 748     }
 749
 750     return S_OK;
 751 }
 752
 753 static HRESULT exec_justifycenter(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 754 {
 755     TRACE("(%p)\n", This);
 756
 757     if(in || out)
 758         FIXME("unsupported args\n");
 759
 760     set_ns_align(This, NSALIGN_CENTER);
 761     update_doc(This, UPDATE_UI);
 762     return S_OK;
 763 }
 764
 765 static HRESULT exec_justifyleft(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 766 {
 767     TRACE("(%p)\n", This);
 768
 769     if(in || out)
 770         FIXME("unsupported args\n");
 771
 772     set_ns_align(This, NSALIGN_LEFT);
 773     update_doc(This, UPDATE_UI);
 774     return S_OK;
 775 }
 776
 777 static HRESULT exec_justifyright(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 778 {
 779     TRACE("(%p)\n", This);
 780
 781     if(in || out)
 782         FIXME("unsupported args\n");
 783
 784     set_ns_align(This, NSALIGN_RIGHT);
 785     update_doc(This, UPDATE_UI);
 786     return S_OK;
 787 }
 788
 789 static HRESULT exec_underline(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 790 {
 791     TRACE("(%p)\n", This);
 792
 793     if(in || out)
 794         FIXME("unsupported args\n");
 795
 796     if(This->nscontainer)
 797         do_ns_command(This->nscontainer, NSCMD_UNDERLINE, NULL);
 798
 799     update_doc(This, UPDATE_UI);
 800     return S_OK;
 801 }
 802
 803 static HRESULT exec_horizontalline(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 804 {
 805     TRACE("(%p)\n", This);
 806
 807     if(in || out)
 808         FIXME("unsupported args\n");
 809
 810     if(This->nscontainer)
 811         do_ns_command(This->nscontainer, NSCMD_INSERTHR, NULL);
 812
 813     update_doc(This, UPDATE_UI);
 814     return S_OK;
 815 }
 816
 817 static HRESULT exec_orderlist(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 818 {
 819     TRACE("(%p)\n", This);
 820
 821     if(in || out)
 822         FIXME("unsupported args\n");
 823
 824     if(This->nscontainer)
 825         do_ns_command(This->nscontainer, NSCMD_OL, NULL);
 826
 827     update_doc(This, UPDATE_UI);
 828     return S_OK;
 829 }
 830
 831 static HRESULT exec_unorderlist(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 832 {
 833     TRACE("(%p)\n", This);
 834
 835     if(in || out)
 836         FIXME("unsupported args\n");
 837
 838     if(This->nscontainer)
 839         do_ns_command(This->nscontainer, NSCMD_UL, NULL);
 840
 841     update_doc(This, UPDATE_UI);
 842     return S_OK;
 843 }
 844
 845 static HRESULT exec_indent(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 846 {
 847     TRACE("(%p)\n", This);
 848
 849     if(in || out)
 850         FIXME("unsupported args\n");
 851
 852     if(This->nscontainer)
 853         do_ns_command(This->nscontainer, NSCMD_INDENT, NULL);
 854
 855     update_doc(This, UPDATE_UI);
 856     return S_OK;
 857 }
 858
 859 static HRESULT exec_outdent(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 860 {
 861     TRACE("(%p)\n", This);
 862
 863     if(in || out)
 864         FIXME("unsupported args\n");
 865
 866     if(This->nscontainer)
 867         do_ns_command(This->nscontainer, NSCMD_OUTDENT, NULL);
 868
 869     update_doc(This, UPDATE_UI);
 870     return S_OK;
 871 }
 872
 873 static HRESULT exec_composesettings(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 874 {
 875     WCHAR *ptr;
 876
 877     if(out || !in || V_VT(in) != VT_BSTR) {
 878         WARN("invalid arg\n");
 879         return E_INVALIDARG;
 880     }
 881
 882     TRACE("(%p)->(%x %s)\n", This, cmdexecopt, debugstr_w(V_BSTR(in)));
 883
 884     update_doc(This, UPDATE_UI);
 885
 886     ptr = V_BSTR(in);
 887     if(*ptr == '1')
 888         exec_bold(This, cmdexecopt, NULL, NULL);
 889     ptr = strchrW(ptr, ',');
 890     if(!ptr)
 891         return S_OK;
 892
 893     if(*++ptr == '1')
 894         exec_italic(This, cmdexecopt, NULL, NULL);
 895     ptr = strchrW(ptr, ',');
 896     if(!ptr)
 897         return S_OK;
 898
 899     if(*++ptr == '1')
 900         exec_underline(This, cmdexecopt, NULL, NULL);
 901     ptr = strchrW(ptr, ',');
 902     if(!ptr)
 903         return S_OK;
 904
 905     if(isdigitW(*++ptr)) {
 906         VARIANT v;
 907
 908         V_VT(&v) = VT_I4;
 909         V_I4(&v) = *ptr-'0';
 910
 911         exec_fontsize(This, cmdexecopt, &v, NULL);
 912     }
 913     ptr = strchrW(ptr, ',');
 914     if(!ptr)
 915         return S_OK;
 916
 917     if(*++ptr != ',')
 918         FIXME("set font color\n");
 919     ptr = strchrW(ptr, ',');
 920     if(!ptr)
 921         return S_OK;
 922
 923     if(*++ptr != ',')
 924         FIXME("set background color\n");
 925     ptr = strchrW(ptr, ',');
 926     if(!ptr)
 927         return S_OK;
 928
 929     ptr++;
 930     if(*ptr) {
 931         VARIANT v;
 932
 933         V_VT(&v) = VT_BSTR;
 934         V_BSTR(&v) = SysAllocString(ptr);
 935
 936         exec_fontname(This, cmdexecopt, &v, NULL);
 937
 938         SysFreeString(V_BSTR(&v));
 939     }
 940
 941     return S_OK;
 942 }
 943
 944 HRESULT editor_exec_copy(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 945 {
 946     update_doc(This, UPDATE_UI);
 947
 948     if(!This->nscontainer)
 949         return E_FAIL;
 950
 951     do_ns_editor_command(This->nscontainer, NSCMD_COPY);
 952     return S_OK;
 953 }
 954
 955 HRESULT editor_exec_cut(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 956 {
 957     update_doc(This, UPDATE_UI);
 958
 959     if(!This->nscontainer)
 960         return E_FAIL;
 961
 962     do_ns_editor_command(This->nscontainer, NSCMD_CUT);
 963     return S_OK;
 964 }
 965
 966 HRESULT editor_exec_paste(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 967 {
 968     update_doc(This, UPDATE_UI);
 969
 970     if(!This->nscontainer)
 971         return E_FAIL;
 972
 973     do_ns_editor_command(This->nscontainer, NSCMD_PASTE);
 974     return S_OK;
 975 }
 976
 977 static HRESULT query_edit_status(HTMLDocument *This, OLECMD *cmd)
 978 {
 979     switch(cmd->cmdID) {
 980     case IDM_FONTNAME:
 981         TRACE("CGID_MSHTML: IDM_FONTNAME\n");
 982         cmd->cmdf = query_ns_edit_status(This, NULL);
 983         break;
 984     case IDM_FONTSIZE:
 985         TRACE("CGID_MSHTML: IDM_FONTSIZE\n");
 986         cmd->cmdf = query_ns_edit_status(This, NULL);
 987         break;
 988     case IDM_BOLD:
 989         TRACE("CGID_MSHTML: IDM_BOLD\n");
 990         cmd->cmdf = query_ns_edit_status(This, NSCMD_BOLD);
 991         break;
 992     case IDM_FORECOLOR:
 993         TRACE("CGID_MSHTML: IDM_FORECOLOR\n");
 994         cmd->cmdf = query_ns_edit_status(This, NULL);
 995         break;
 996     case IDM_ITALIC:
 997         TRACE("CGID_MSHTML: IDM_ITALIC\n");
 998         cmd->cmdf = query_ns_edit_status(This, NSCMD_ITALIC);
 999         break;
1000     case IDM_UNDERLINE:
1001         TRACE("CGID_MSHTML: IDM_UNDERLINE\n");
1002         cmd->cmdf = query_ns_edit_status(This, NSCMD_UNDERLINE);
1003         break;
1004     case IDM_HORIZONTALLINE:
1005         TRACE("CGID_MSHTML: IDM_HORIZONTALLINE\n");
1006         cmd->cmdf = query_ns_edit_status(This, NULL);
1007         break;
1008     case IDM_ORDERLIST:
1009         TRACE("CGID_MSHTML: IDM_ORDERLIST\n");
1010         cmd->cmdf = query_ns_edit_status(This, NSCMD_OL);
1011         break;
1012     case IDM_UNORDERLIST:
1013         TRACE("CGID_MSHTML: IDM_HORIZONTALLINE\n");
1014         cmd->cmdf = query_ns_edit_status(This, NSCMD_UL);
1015         break;
1016     case IDM_INDENT:
1017         TRACE("CGID_MSHTML: IDM_INDENT\n");
1018         cmd->cmdf = query_ns_edit_status(This, NULL);
1019         break;
1020     case IDM_OUTDENT:
1021         TRACE("CGID_MSHTML: IDM_OUTDENT\n");
1022         cmd->cmdf = query_ns_edit_status(This, NULL);
1023         break;
1024     }
1025
1026     return S_OK;
1027 }
1028
1029 const cmdtable_t editmode_cmds[] = {
1030     {IDM_FONTNAME,        query_edit_status,    exec_fontname},
1031     {IDM_FONTSIZE,        query_edit_status,    exec_fontsize},
1032     {IDM_FORECOLOR,       query_edit_status,    exec_forecolor},
1033     {IDM_BOLD,            query_edit_status,    exec_bold},
1034     {IDM_ITALIC,          query_edit_status,    exec_italic},
1035     {IDM_JUSTIFYCENTER,   query_justify,        exec_justifycenter},
1036     {IDM_JUSTIFYRIGHT,    query_justify,        exec_justifyright},
1037     {IDM_JUSTIFYLEFT,     query_justify,        exec_justifyleft},
1038     {IDM_UNDERLINE,       query_edit_status,    exec_underline},
1039     {IDM_HORIZONTALLINE,  query_edit_status,    exec_horizontalline},
1040     {IDM_ORDERLIST,       query_edit_status,    exec_orderlist},
1041     {IDM_UNORDERLIST,     query_edit_status,    exec_unorderlist},
1042     {IDM_INDENT,          query_edit_status,    exec_indent},
1043     {IDM_OUTDENT,         query_edit_status,    exec_outdent},
1044     {IDM_COMPOSESETTINGS, NULL,                 exec_composesettings},
1045     {0,NULL,NULL}
1046 };
1047
1048 void init_editor(HTMLDocument *This)
1049 {
1050     update_doc(This, UPDATE_UI);
1051
1052     if(!This->nscontainer)
1053         return;
1054
1055     set_ns_fontname(This->nscontainer, "Times New Roman");
1056 }