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