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