dlls/mshtml/olecmd.c

   1 /*
   2  * Copyright 2005-2006 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 "shlguid.h"
  32 #include "mshtmdid.h"
  33 #include "idispids.h"
  34 #include "mshtmcid.h"
  35
  36 #include "wine/debug.h"
  37 #include "wine/unicode.h"
  38
  39 #include "mshtml_private.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  42
  43 #define NSCMD_BOLD "cmd_bold"
  44 #define NSCMD_ITALIC "cmd_italic"
  45 #define NSCMD_UNDERLINE "cmd_underline"
  46 #define NSCMD_FONTCOLOR "cmd_fontColor"
  47 #define NSCMD_ALIGN "cmd_align"
  48 #define NSCMD_FONTFACE "cmd_fontFace"
  49 #define NSCMD_INDENT "cmd_indent"
  50 #define NSCMD_OUTDENT "cmd_outdent"
  51 #define NSCMD_INSERTHR "cmd_insertHR"
  52 #define NSCMD_UL "cmd_ul"
  53 #define NSCMD_OL "cmd_ol"
  54
  55 #define NSSTATE_ATTRIBUTE "state_attribute"
  56 #define NSSTATE_ALL "state_all"
  57
  58 #define NSALIGN_CENTER "center"
  59 #define NSALIGN_LEFT   "left"
  60 #define NSALIGN_RIGHT  "right"
  61
  62 /**********************************************************
  63  * IOleCommandTarget implementation
  64  */
  65
  66 #define CMDTARGET_THIS(iface) DEFINE_THIS(HTMLDocument, OleCommandTarget, iface)
  67
  68 static HRESULT exec_open(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
  69 {
  70     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
  71     return E_NOTIMPL;
  72 }
  73
  74 static HRESULT exec_new(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
  75 {
  76     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
  77     return E_NOTIMPL;
  78 }
  79
  80 static HRESULT exec_save(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
  81 {
  82     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
  83     return E_NOTIMPL;
  84 }
  85
  86 static HRESULT exec_save_as(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
  87 {
  88     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
  89     return E_NOTIMPL;
  90 }
  91
  92 static HRESULT exec_save_copy_as(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
  93 {
  94     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
  95     return E_NOTIMPL;
  96 }
  97
  98 static HRESULT exec_print(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
  99 {
 100     nsIInterfaceRequestor *iface_req;
 101     nsIWebBrowserPrint *nsprint;
 102     nsresult nsres;
 103
 104     TRACE("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 105
 106     if(pvaOut)
 107         FIXME("unsupported pvaOut\n");
 108     if(pvaIn)
 109         FIXME("unsupported pvaIn\n");
 110
 111     if(!This->nscontainer)
 112         return S_OK;
 113
 114     nsres = nsIWebBrowser_QueryInterface(This->nscontainer->webbrowser,
 115             &IID_nsIInterfaceRequestor, (void**)&iface_req);
 116     if(NS_FAILED(nsres)) {
 117         ERR("Could not get nsIInterfaceRequestor: %08x\n", nsres);
 118         return S_OK;
 119     }
 120
 121     nsres = nsIInterfaceRequestor_GetInterface(iface_req, &IID_nsIWebBrowserPrint,
 122             (void**)&nsprint);
 123     nsIInterfaceRequestor_Release(iface_req);
 124     if(NS_FAILED(nsres)) {
 125         ERR("Could not get nsIWebBrowserPrint: %08x\n", nsres);
 126         return S_OK;
 127     }
 128
 129     nsres = nsIWebBrowserPrint_Print(nsprint, NULL, NULL);
 130     if(NS_FAILED(nsres))
 131         ERR("Print failed: %08x\n", nsres);
 132
 133     nsIWebBrowserPrint_Release(nsprint);
 134
 135     return S_OK;
 136 }
 137
 138 static HRESULT exec_print_preview(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 139 {
 140     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 141     return E_NOTIMPL;
 142 }
 143
 144 static HRESULT exec_page_setup(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 145 {
 146     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 147     return E_NOTIMPL;
 148 }
 149
 150 static HRESULT exec_spell(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 151 {
 152     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 153     return E_NOTIMPL;
 154 }
 155
 156 static HRESULT exec_properties(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 157 {
 158     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 159     return E_NOTIMPL;
 160 }
 161
 162 static HRESULT exec_cut(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 163 {
 164     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 165     return E_NOTIMPL;
 166 }
 167
 168 static HRESULT exec_copy(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 169 {
 170     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 171     return E_NOTIMPL;
 172 }
 173
 174 static HRESULT exec_paste(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 175 {
 176     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 177     return E_NOTIMPL;
 178 }
 179
 180 static HRESULT exec_paste_special(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 181 {
 182     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 183     return E_NOTIMPL;
 184 }
 185
 186 static HRESULT exec_undo(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 187 {
 188     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 189     return E_NOTIMPL;
 190 }
 191
 192 static HRESULT exec_rendo(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 193 {
 194     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 195     return E_NOTIMPL;
 196 }
 197
 198 static HRESULT exec_select_all(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 199 {
 200     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 201     return E_NOTIMPL;
 202 }
 203
 204 static HRESULT exec_clear_selection(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 205 {
 206     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 207     return E_NOTIMPL;
 208 }
 209
 210 static HRESULT exec_zoom(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 211 {
 212     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 213     return E_NOTIMPL;
 214 }
 215
 216 static HRESULT exec_get_zoom_range(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 217 {
 218     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 219     return E_NOTIMPL;
 220 }
 221
 222 static HRESULT exec_refresh(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 223 {
 224     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 225     return E_NOTIMPL;
 226 }
 227
 228 static HRESULT exec_stop(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 229 {
 230     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 231     return E_NOTIMPL;
 232 }
 233
 234 static HRESULT exec_stop_download(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 235 {
 236     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 237     return E_NOTIMPL;
 238 }
 239
 240 static HRESULT exec_delete(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 241 {
 242     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 243     return E_NOTIMPL;
 244 }
 245
 246 static HRESULT exec_enable_interaction(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 247 {
 248     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 249     return E_NOTIMPL;
 250 }
 251
 252 static HRESULT exec_on_unload(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 253 {
 254     TRACE("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 255
 256     /* Tests show that we have nothing more to do here */
 257
 258     if(pvaOut) {
 259         V_VT(pvaOut) = VT_BOOL;
 260         V_BOOL(pvaOut) = VARIANT_TRUE;
 261     }
 262
 263     return S_OK;
 264 }
 265
 266 static HRESULT exec_show_page_setup(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 267 {
 268     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 269     return E_NOTIMPL;
 270 }
 271
 272 static HRESULT exec_show_print(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 273 {
 274     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 275     return E_NOTIMPL;
 276 }
 277
 278 static HRESULT exec_close(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 279 {
 280     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 281     return E_NOTIMPL;
 282 }
 283
 284 static HRESULT exec_set_print_template(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 285 {
 286     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 287     return E_NOTIMPL;
 288 }
 289
 290 static HRESULT exec_get_print_template(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 291 {
 292     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 293     return E_NOTIMPL;
 294 }
 295
 296 static void do_ns_command(NSContainer *This, const char *cmd, nsICommandParams *nsparam)
 297 {
 298     nsICommandManager *cmdmgr;
 299     nsIInterfaceRequestor *iface_req;
 300     nsresult nsres;
 301
 302     TRACE("(%p)\n", This);
 303
 304     nsres = nsIWebBrowser_QueryInterface(This->webbrowser,
 305             &IID_nsIInterfaceRequestor, (void**)&iface_req);
 306     if(NS_FAILED(nsres)) {
 307         ERR("Could not get nsIInterfaceRequestor: %08x\n", nsres);
 308         return;
 309     }
 310
 311     nsres = nsIInterfaceRequestor_GetInterface(iface_req, &IID_nsICommandManager,
 312                                                (void**)&cmdmgr);
 313     nsIInterfaceRequestor_Release(iface_req);
 314     if(NS_FAILED(nsres)) {
 315         ERR("Could not get nsICommandManager: %08x\n", nsres);
 316         return;
 317     }
 318
 319     nsres = nsICommandManager_DoCommand(cmdmgr, cmd, nsparam, NULL);
 320     if(NS_FAILED(nsres))
 321         ERR("DoCommand(%s) failed: %08x\n", debugstr_a(cmd), nsres);
 322
 323     nsICommandManager_Release(cmdmgr);
 324 }
 325
 326 static nsresult get_ns_command_state(NSContainer *This, const char *cmd, nsICommandParams *nsparam)
 327 {
 328     nsICommandManager *cmdmgr;
 329     nsIInterfaceRequestor *iface_req;
 330     nsresult nsres;
 331
 332     nsres = nsIWebBrowser_QueryInterface(This->webbrowser,
 333             &IID_nsIInterfaceRequestor, (void**)&iface_req);
 334     if(NS_FAILED(nsres)) {
 335         ERR("Could not get nsIInterfaceRequestor: %08x\n", nsres);
 336         return nsres;
 337     }
 338
 339     nsres = nsIInterfaceRequestor_GetInterface(iface_req, &IID_nsICommandManager,
 340                                                (void**)&cmdmgr);
 341     nsIInterfaceRequestor_Release(iface_req);
 342     if(NS_FAILED(nsres)) {
 343         ERR("Could not get nsICommandManager: %08x\n", nsres);
 344         return nsres;
 345     }
 346
 347     nsres = nsICommandManager_GetCommandState(cmdmgr, cmd, NULL, nsparam);
 348     if(NS_FAILED(nsres))
 349         ERR("GetCommandState(%s) failed: %08x\n", debugstr_a(cmd), nsres);
 350
 351     nsICommandManager_Release(cmdmgr);
 352     return nsres;
 353 }
 354
 355 static DWORD query_edit_status(HTMLDocument *This, const char *nscmd)
 356 {
 357     nsICommandParams *nsparam;
 358     PRBool b = FALSE;
 359
 360     if(This->usermode != EDITMODE || This->readystate < READYSTATE_INTERACTIVE)
 361         return OLECMDF_SUPPORTED;
 362
 363     if(This->nscontainer && nscmd) {
 364         nsparam = create_nscommand_params();
 365         get_ns_command_state(This->nscontainer, nscmd, nsparam);
 366
 367         nsICommandParams_GetBooleanValue(nsparam, NSSTATE_ALL, &b);
 368
 369         nsICommandParams_Release(nsparam);
 370     }
 371
 372     return OLECMDF_SUPPORTED | OLECMDF_ENABLED | (b ? OLECMDF_LATCHED : 0);
 373 }
 374
 375 static DWORD query_align_status(HTMLDocument *This, const char *align_str)
 376 {
 377     nsICommandParams *nsparam;
 378     char *align = NULL;
 379
 380     if(This->usermode != EDITMODE || This->readystate < READYSTATE_INTERACTIVE)
 381         return OLECMDF_SUPPORTED;
 382
 383     if(This->nscontainer) {
 384         nsparam = create_nscommand_params();
 385         get_ns_command_state(This->nscontainer, NSCMD_ALIGN, nsparam);
 386
 387         nsICommandParams_GetCStringValue(nsparam, NSSTATE_ATTRIBUTE, &align);
 388
 389         nsICommandParams_Release(nsparam);
 390     }
 391
 392     return OLECMDF_SUPPORTED | OLECMDF_ENABLED | (align && !strcmp(align_str, align) ? OLECMDF_LATCHED : 0);
 393 }
 394
 395 static void set_ns_align(HTMLDocument *This, const char *align_str)
 396 {
 397     nsICommandParams *nsparam;
 398
 399     if(!This->nscontainer)
 400         return;
 401
 402     nsparam = create_nscommand_params();
 403     nsICommandParams_SetCStringValue(nsparam, NSSTATE_ATTRIBUTE, align_str);
 404
 405     do_ns_command(This->nscontainer, NSCMD_ALIGN, nsparam);
 406
 407     nsICommandParams_Release(nsparam);
 408 }
 409
 410 static HRESULT exec_fontname(HTMLDocument *This, VARIANT *in, VARIANT *out)
 411 {
 412     TRACE("(%p)->(%p %p)\n", This, in, out);
 413
 414     if(!This->nscontainer)
 415         return E_FAIL;
 416
 417     if(in) {
 418         nsICommandParams *nsparam = create_nscommand_params();
 419         char *stra;
 420         DWORD len;
 421
 422         if(V_VT(in) != VT_BSTR) {
 423             FIXME("Unsupported vt=%d\n", V_VT(out));
 424             return E_INVALIDARG;
 425         }
 426
 427         len = WideCharToMultiByte(CP_ACP, 0, V_BSTR(in), -1, NULL, 0, NULL, NULL);
 428         stra = mshtml_alloc(len);
 429         WideCharToMultiByte(CP_ACP, 0, V_BSTR(in), -1, stra, -1, NULL, NULL);
 430         nsICommandParams_SetCStringValue(nsparam, NSSTATE_ATTRIBUTE, stra);
 431         mshtml_free(stra);
 432
 433         do_ns_command(This->nscontainer, NSCMD_FONTFACE, nsparam);
 434
 435         nsICommandParams_Release(nsparam);
 436     }
 437
 438     if(out) {
 439         nsICommandParams *nsparam;
 440         LPWSTR strw;
 441         char *stra;
 442         DWORD len;
 443         nsresult nsres;
 444
 445         if(V_VT(out) != VT_BSTR) {
 446             FIXME("Unsupported vt=%d\n", V_VT(out));
 447             return E_INVALIDARG;
 448         }
 449
 450         nsparam = create_nscommand_params();
 451
 452         nsres = get_ns_command_state(This->nscontainer, NSCMD_FONTFACE, nsparam);
 453         if(NS_FAILED(nsres))
 454             return S_OK;
 455
 456         nsICommandParams_GetCStringValue(nsparam, NSSTATE_ATTRIBUTE, &stra);
 457         nsICommandParams_Release(nsparam);
 458
 459         len = MultiByteToWideChar(CP_ACP, 0, stra, -1, NULL, 0);
 460         strw = mshtml_alloc(len*sizeof(WCHAR));
 461         MultiByteToWideChar(CP_ACP, 0, stra, -1, strw, -1);
 462         nsfree(stra);
 463
 464         V_BSTR(out) = SysAllocString(strw);
 465         mshtml_free(strw);
 466     }
 467
 468     return S_OK;
 469 }
 470
 471 static HRESULT exec_forecolor(HTMLDocument *This, VARIANT *in, VARIANT *out)
 472 {
 473     TRACE("(%p)->(%p %p)\n", This, in, out);
 474
 475     if(in) {
 476         if(V_VT(in) == VT_I4) {
 477             nsICommandParams *nsparam = create_nscommand_params();
 478             char color_str[10];
 479
 480             sprintf(color_str, "#%02x%02x%02x",
 481                     V_I4(in)&0xff, (V_I4(in)>>8)&0xff, (V_I4(in)>>16)&0xff);
 482
 483             nsICommandParams_SetCStringValue(nsparam, NSSTATE_ATTRIBUTE, color_str);
 484             do_ns_command(This->nscontainer, NSCMD_FONTCOLOR, nsparam);
 485
 486             nsICommandParams_Release(nsparam);
 487         }else {
 488             FIXME("unsupported in vt=%d\n", V_VT(in));
 489         }
 490     }
 491
 492     if(out) {
 493         FIXME("unsupported out\n");
 494         return E_NOTIMPL;
 495     }
 496
 497     return S_OK;
 498 }
 499
 500 static HRESULT exec_fontsize(HTMLDocument *This, VARIANT *in, VARIANT *out)
 501 {
 502     TRACE("(%p)->(%p %p)\n", This, in, out);
 503
 504     if(out) {
 505         WCHAR val[10] = {0};
 506
 507         switch(V_VT(out)) {
 508         case VT_I4:
 509             get_font_size(This, val);
 510             V_I4(out) = strtolW(val, NULL, 10);
 511             break;
 512         case VT_BSTR:
 513             get_font_size(This, val);
 514             V_BSTR(out) = SysAllocString(val);
 515             break;
 516         default:
 517             FIXME("unsupported vt %d\n", V_VT(out));
 518         }
 519     }
 520
 521     if(in) {
 522         switch(V_VT(in)) {
 523         case VT_I4: {
 524             WCHAR size[10];
 525             static const WCHAR format[] = {'%','d',0};
 526             wsprintfW(size, format, V_I4(in));
 527             set_font_size(This, size);
 528             break;
 529         }
 530         case VT_BSTR:
 531             set_font_size(This, V_BSTR(in));
 532             break;
 533         default:
 534             FIXME("unsupported vt %d\n", V_VT(out));
 535         }
 536     }
 537
 538     return S_OK;
 539 }
 540
 541 static HRESULT exec_bold(HTMLDocument *This)
 542 {
 543     TRACE("(%p)\n", This);
 544
 545     if(This->nscontainer)
 546         do_ns_command(This->nscontainer, NSCMD_BOLD, NULL);
 547
 548     return S_OK;
 549 }
 550
 551 static HRESULT exec_italic(HTMLDocument *This)
 552 {
 553     TRACE("(%p)\n", This);
 554
 555     if(This->nscontainer)
 556         do_ns_command(This->nscontainer, NSCMD_ITALIC, NULL);
 557
 558     return S_OK;
 559 }
 560
 561 static HRESULT exec_justifycenter(HTMLDocument *This)
 562 {
 563     TRACE("(%p)\n", This);
 564     set_ns_align(This, NSALIGN_CENTER);
 565     return S_OK;
 566 }
 567
 568 static HRESULT exec_justifyleft(HTMLDocument *This)
 569 {
 570     TRACE("(%p)\n", This);
 571     set_ns_align(This, NSALIGN_LEFT);
 572     return S_OK;
 573 }
 574
 575 static HRESULT exec_justifyright(HTMLDocument *This)
 576 {
 577     TRACE("(%p)\n", This);
 578     set_ns_align(This, NSALIGN_RIGHT);
 579     return S_OK;
 580 }
 581
 582 static HRESULT exec_underline(HTMLDocument *This)
 583 {
 584     TRACE("(%p)\n", This);
 585
 586     if(This->nscontainer)
 587         do_ns_command(This->nscontainer, NSCMD_UNDERLINE, NULL);
 588
 589     return S_OK;
 590 }
 591
 592 static HRESULT exec_browsemode(HTMLDocument *This)
 593 {
 594     WARN("(%p)\n", This);
 595
 596     This->usermode = BROWSEMODE;
 597
 598     return S_OK;
 599 }
 600
 601 static void setup_ns_editing(NSContainer *This)
 602 {
 603     nsIInterfaceRequestor *iface_req;
 604     nsIEditingSession *editing_session = NULL;
 605     nsIURIContentListener *listener = NULL;
 606     nsIDOMWindow *dom_window = NULL;
 607     nsresult nsres;
 608
 609     nsres = nsIWebBrowser_QueryInterface(This->webbrowser,
 610             &IID_nsIInterfaceRequestor, (void**)&iface_req);
 611     if(NS_FAILED(nsres)) {
 612         ERR("Could not get nsIInterfaceRequestor: %08x\n", nsres);
 613         return;
 614     }
 615
 616     nsres = nsIInterfaceRequestor_GetInterface(iface_req, &IID_nsIEditingSession,
 617                                                (void**)&editing_session);
 618     nsIInterfaceRequestor_Release(iface_req);
 619     if(NS_FAILED(nsres)) {
 620         ERR("Could not get nsIEditingSession: %08x\n", nsres);
 621         return;
 622     }
 623
 624     nsres = nsIWebBrowser_GetContentDOMWindow(This->webbrowser, &dom_window);
 625     if(NS_FAILED(nsres)) {
 626         ERR("Could not get content DOM window: %08x\n", nsres);
 627         nsIEditingSession_Release(editing_session);
 628         return;
 629     }
 630
 631     nsres = nsIEditingSession_MakeWindowEditable(editing_session, dom_window, NULL, FALSE);
 632     nsIEditingSession_Release(editing_session);
 633     nsIDOMWindow_Release(dom_window);
 634     if(NS_FAILED(nsres)) {
 635         ERR("MakeWindowEditable failed: %08x\n", nsres);
 636         return;
 637     }
 638
 639     /* MakeWindowEditable changes WebBrowser's parent URI content listener.
 640      * It seams to be a bug in Gecko. To workaround it we set our content
 641      * listener again and Gecko's one as its parent.
 642      */
 643     nsIWebBrowser_GetParentURIContentListener(This->webbrowser, &listener);
 644     nsIURIContentListener_SetParentContentListener(NSURICL(This), listener);
 645     nsIURIContentListener_Release(listener);
 646     nsIWebBrowser_SetParentURIContentListener(This->webbrowser, NSURICL(This));
 647 }
 648
 649 static HRESULT exec_editmode(HTMLDocument *This)
 650 {
 651     IMoniker *mon;
 652     HRESULT hres;
 653
 654     static const WCHAR wszAboutBlank[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
 655
 656     TRACE("(%p)\n", This);
 657
 658     This->usermode = EDITMODE;
 659
 660     if(This->frame)
 661         IOleInPlaceFrame_SetStatusText(This->frame, NULL);
 662
 663     if(This->hostui) {
 664         DOCHOSTUIINFO hostinfo;
 665
 666         memset(&hostinfo, 0, sizeof(DOCHOSTUIINFO));
 667         hostinfo.cbSize = sizeof(DOCHOSTUIINFO);
 668         hres = IDocHostUIHandler_GetHostInfo(This->hostui, &hostinfo);
 669         if(SUCCEEDED(hres))
 670             /* FIXME: use hostinfo */
 671             TRACE("hostinfo = {%u %08x %08x %s %s}\n",
 672                     hostinfo.cbSize, hostinfo.dwFlags, hostinfo.dwDoubleClick,
 673                     debugstr_w(hostinfo.pchHostCss), debugstr_w(hostinfo.pchHostNS));
 674     }
 675
 676     if(This->nscontainer)
 677         setup_ns_editing(This->nscontainer);
 678
 679     hres = CreateURLMoniker(NULL, wszAboutBlank, &mon);
 680     if(FAILED(hres)) {
 681         FIXME("CreateURLMoniker failed: %08x\n", hres);
 682         return hres;
 683     }
 684
 685     return IPersistMoniker_Load(PERSISTMON(This), TRUE, mon, NULL, 0);
 686 }
 687
 688 static HRESULT exec_baselinefont3(HTMLDocument *This)
 689 {
 690     FIXME("(%p)\n", This);
 691     return S_OK;
 692 }
 693
 694 static HRESULT exec_horizontalline(HTMLDocument *This)
 695 {
 696     TRACE("(%p)\n", This);
 697
 698     if(This->nscontainer)
 699         do_ns_command(This->nscontainer, NSCMD_INSERTHR, NULL);
 700
 701     return S_OK;
 702 }
 703
 704 static HRESULT exec_orderlist(HTMLDocument *This)
 705 {
 706     TRACE("(%p)\n", This);
 707
 708     if(This->nscontainer)
 709         do_ns_command(This->nscontainer, NSCMD_OL, NULL);
 710
 711     return S_OK;
 712 }
 713
 714 static HRESULT exec_unorderlist(HTMLDocument *This)
 715 {
 716     TRACE("(%p)\n", This);
 717
 718     if(This->nscontainer)
 719         do_ns_command(This->nscontainer, NSCMD_UL, NULL);
 720
 721     return S_OK;
 722 }
 723
 724 static HRESULT exec_indent(HTMLDocument *This)
 725 {
 726     TRACE("(%p)\n", This);
 727
 728     if(This->nscontainer)
 729         do_ns_command(This->nscontainer, NSCMD_INDENT, NULL);
 730
 731     return S_OK;
 732 }
 733
 734 static HRESULT exec_outdent(HTMLDocument *This)
 735 {
 736     TRACE("(%p)\n", This);
 737
 738     if(This->nscontainer)
 739         do_ns_command(This->nscontainer, NSCMD_OUTDENT, NULL);
 740
 741     return S_OK;
 742 }
 743
 744 static const struct {
 745     OLECMDF cmdf;
 746     HRESULT (*func)(HTMLDocument*,DWORD,VARIANT*,VARIANT*);
 747 } exec_table[OLECMDID_GETPRINTTEMPLATE+1] = {
 748     {0},
 749     { OLECMDF_SUPPORTED,                  exec_open                 }, /* OLECMDID_OPEN */
 750     { OLECMDF_SUPPORTED,                  exec_new                  }, /* OLECMDID_NEW */
 751     { OLECMDF_SUPPORTED,                  exec_save                 }, /* OLECMDID_SAVE */
 752     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_save_as              }, /* OLECMDID_SAVEAS */
 753     { OLECMDF_SUPPORTED,                  exec_save_copy_as         }, /* OLECMDID_SAVECOPYAS */
 754     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_print                }, /* OLECMDID_PRINT */
 755     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_print_preview        }, /* OLECMDID_PRINTPREVIEW */
 756     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_page_setup           }, /* OLECMDID_PAGESETUP */
 757     { OLECMDF_SUPPORTED,                  exec_spell                }, /* OLECMDID_SPELL */
 758     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_properties           }, /* OLECMDID_PROPERTIES */
 759     { OLECMDF_SUPPORTED,                  exec_cut                  }, /* OLECMDID_CUT */
 760     { OLECMDF_SUPPORTED,                  exec_copy                 }, /* OLECMDID_COPY */
 761     { OLECMDF_SUPPORTED,                  exec_paste                }, /* OLECMDID_PASTE */
 762     { OLECMDF_SUPPORTED,                  exec_paste_special        }, /* OLECMDID_PASTESPECIAL */
 763     { OLECMDF_SUPPORTED,                  exec_undo                 }, /* OLECMDID_UNDO */
 764     { OLECMDF_SUPPORTED,                  exec_rendo                }, /* OLECMDID_REDO */
 765     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_select_all           }, /* OLECMDID_SELECTALL */
 766     { OLECMDF_SUPPORTED,                  exec_clear_selection      }, /* OLECMDID_CLEARSELECTION */
 767     { OLECMDF_SUPPORTED,                  exec_zoom                 }, /* OLECMDID_ZOOM */
 768     { OLECMDF_SUPPORTED,                  exec_get_zoom_range       }, /* OLECMDID_GETZOOMRANGE */
 769     {0},
 770     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_refresh              }, /* OLECMDID_REFRESH */
 771     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_stop                 }, /* OLECMDID_STOP */
 772     {0},{0},{0},{0},{0},{0},
 773     { OLECMDF_SUPPORTED,                  exec_stop_download        }, /* OLECMDID_STOPDOWNLOAD */
 774     {0},{0},
 775     { OLECMDF_SUPPORTED,                  exec_delete               }, /* OLECMDID_DELETE */
 776     {0},{0},
 777     { OLECMDF_SUPPORTED,                  exec_enable_interaction   }, /* OLECMDID_ENABLE_INTERACTION */
 778     { OLECMDF_SUPPORTED,                  exec_on_unload            }, /* OLECMDID_ONUNLOAD */
 779     {0},{0},{0},{0},{0},
 780     { OLECMDF_SUPPORTED,                  exec_show_page_setup      }, /* OLECMDID_SHOWPAGESETUP */
 781     { OLECMDF_SUPPORTED,                  exec_show_print           }, /* OLECMDID_SHOWPRINT */
 782     {0},{0},
 783     { OLECMDF_SUPPORTED,                  exec_close                }, /* OLECMDID_CLOSE */
 784     {0},{0},{0},
 785     { OLECMDF_SUPPORTED,                  exec_set_print_template   }, /* OLECMDID_SETPRINTTEMPLATE */
 786     { OLECMDF_SUPPORTED,                  exec_get_print_template   }  /* OLECMDID_GETPRINTTEMPLATE */
 787 };
 788
 789 static HRESULT WINAPI OleCommandTarget_QueryInterface(IOleCommandTarget *iface, REFIID riid, void **ppv)
 790 {
 791     HTMLDocument *This = CMDTARGET_THIS(iface);
 792     return IHTMLDocument2_QueryInterface(HTMLDOC(This), riid, ppv);
 793 }
 794
 795 static ULONG WINAPI OleCommandTarget_AddRef(IOleCommandTarget *iface)
 796 {
 797     HTMLDocument *This = CMDTARGET_THIS(iface);
 798     return IHTMLDocument2_AddRef(HTMLDOC(This));
 799 }
 800
 801 static ULONG WINAPI OleCommandTarget_Release(IOleCommandTarget *iface)
 802 {
 803     HTMLDocument *This = CMDTARGET_THIS(iface);
 804     return IHTMLDocument_Release(HTMLDOC(This));
 805 }
 806
 807 static HRESULT WINAPI OleCommandTarget_QueryStatus(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
 808         ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText)
 809 {
 810     HTMLDocument *This = CMDTARGET_THIS(iface);
 811     HRESULT hres = S_OK, hr;
 812
 813     TRACE("(%p)->(%s %d %p %p)\n", This, debugstr_guid(pguidCmdGroup), cCmds, prgCmds, pCmdText);
 814
 815     if(!pguidCmdGroup) {
 816         ULONG i;
 817
 818         for(i=0; i<cCmds; i++) {
 819             if(prgCmds[i].cmdID<OLECMDID_OPEN || prgCmds[i].cmdID>OLECMDID_GETPRINTTEMPLATE) {
 820                 WARN("Unsupported cmdID = %d\n", prgCmds[i].cmdID);
 821                 prgCmds[i].cmdf = 0;
 822                 hres = OLECMDERR_E_NOTSUPPORTED;
 823             }else {
 824                 if(prgCmds[i].cmdID == OLECMDID_OPEN || prgCmds[i].cmdID == OLECMDID_NEW) {
 825                     IOleCommandTarget *cmdtrg = NULL;
 826                     OLECMD olecmd;
 827
 828                     prgCmds[i].cmdf = OLECMDF_SUPPORTED;
 829                     if(This->client) {
 830                         hr = IOleClientSite_QueryInterface(This->client, &IID_IOleCommandTarget,
 831                                 (void**)&cmdtrg);
 832                         if(SUCCEEDED(hr)) {
 833                             olecmd.cmdID = prgCmds[i].cmdID;
 834                             olecmd.cmdf = 0;
 835
 836                             hr = IOleCommandTarget_QueryStatus(cmdtrg, NULL, 1, &olecmd, NULL);
 837                             if(SUCCEEDED(hr) && olecmd.cmdf)
 838                                 prgCmds[i].cmdf = olecmd.cmdf;
 839                         }
 840                     }else {
 841                         ERR("This->client == NULL, native would crash\n");
 842                     }
 843                 }else {
 844                     prgCmds[i].cmdf = exec_table[prgCmds[i].cmdID].cmdf;
 845                     TRACE("cmdID = %d  returning %x\n", prgCmds[i].cmdID, prgCmds[i].cmdf);
 846                 }
 847                 hres = S_OK;
 848             }
 849         }
 850
 851         if(pCmdText)
 852             FIXME("Set pCmdText\n");
 853     }else if(IsEqualGUID(&CGID_MSHTML, pguidCmdGroup)) {
 854         ULONG i;
 855
 856         for(i=0; i<cCmds; i++) {
 857             switch(prgCmds[i].cmdID) {
 858             case IDM_COPY:
 859                 FIXME("CGID_MSHTML: IDM_COPY\n");
 860                 prgCmds[i].cmdf = OLECMDF_SUPPORTED|OLECMDF_ENABLED;
 861                 break;
 862             case IDM_CUT:
 863                 FIXME("CGID_MSHTML: IDM_CUT\n");
 864                 prgCmds[i].cmdf = OLECMDF_SUPPORTED|OLECMDF_ENABLED;
 865                 break;
 866             case IDM_FONTNAME:
 867                 TRACE("CGID_MSHTML: IDM_FONTNAME\n");
 868                 prgCmds[i].cmdf = query_edit_status(This, NULL);
 869                 break;
 870             case IDM_FONTSIZE:
 871                 TRACE("CGID_MSHTML: IDM_FONTSIZE\n");
 872                 prgCmds[i].cmdf = query_edit_status(This, NULL);
 873                 break;
 874             case IDM_PRINT:
 875                 FIXME("CGID_MSHTML: IDM_PRINT\n");
 876                 prgCmds[i].cmdf = OLECMDF_SUPPORTED|OLECMDF_ENABLED;
 877                 break;
 878             case IDM_PASTE:
 879                 FIXME("CGID_MSHTML: IDM_PASTE\n");
 880                 prgCmds[i].cmdf = OLECMDF_SUPPORTED|OLECMDF_ENABLED;
 881                 break;
 882             case IDM_BOLD:
 883                 TRACE("CGID_MSHTML: IDM_BOLD\n");
 884                 prgCmds[i].cmdf = query_edit_status(This, NSCMD_BOLD);
 885                 break;
 886             case IDM_FORECOLOR:
 887                 TRACE("CGID_MSHTML: IDM_FORECOLOR\n");
 888                 prgCmds[i].cmdf = query_edit_status(This, NULL);
 889                 break;
 890             case IDM_ITALIC:
 891                 TRACE("CGID_MSHTML: IDM_ITALIC\n");
 892                 prgCmds[i].cmdf = query_edit_status(This, NSCMD_ITALIC);
 893                 break;
 894             case IDM_JUSTIFYCENTER:
 895                 TRACE("CGID_MSHTML: IDM_JUSTIFYCENTER\n");
 896                 prgCmds[i].cmdf = query_align_status(This, NSALIGN_CENTER);
 897                 break;
 898             case IDM_JUSTIFYLEFT:
 899                 TRACE("CGID_MSHTML: IDM_JUSTIFYLEFT\n");
 900                 prgCmds[i].cmdf = query_align_status(This, NSALIGN_LEFT);
 901                 break;
 902             case IDM_JUSTIFYRIGHT:
 903                 TRACE("CGID_MSHTML: IDM_JUSTIFYRIGHT\n");
 904                 prgCmds[i].cmdf = query_align_status(This, NSALIGN_RIGHT);
 905                 break;
 906             case IDM_UNDERLINE:
 907                 TRACE("CGID_MSHTML: IDM_UNDERLINE\n");
 908                 prgCmds[i].cmdf = query_edit_status(This, NSCMD_UNDERLINE);
 909                 break;
 910             case IDM_HORIZONTALLINE:
 911                 TRACE("CGID_MSHTML: IDM_HORIZONTALLINE\n");
 912                 prgCmds[i].cmdf = query_edit_status(This, NULL);
 913                 break;
 914             case IDM_ORDERLIST:
 915                 TRACE("CGID_MSHTML: IDM_ORDERLIST\n");
 916                 prgCmds[i].cmdf = query_edit_status(This, NSCMD_OL);
 917                 break;
 918             case IDM_UNORDERLIST:
 919                 TRACE("CGID_MSHTML: IDM_HORIZONTALLINE\n");
 920                 prgCmds[i].cmdf = query_edit_status(This, NSCMD_UL);
 921                 break;
 922             case IDM_INDENT:
 923                 TRACE("CGID_MSHTML: IDM_INDENT\n");
 924                 prgCmds[i].cmdf = query_edit_status(This, NULL);
 925                 break;
 926             case IDM_OUTDENT:
 927                 TRACE("CGID_MSHTML: IDM_OUTDENT\n");
 928                 prgCmds[i].cmdf = query_edit_status(This, NULL);
 929                 break;
 930             case IDM_BLOCKDIRLTR:
 931                 FIXME("CGID_MSHTML: IDM_BLOCKDIRLTR\n");
 932                 prgCmds[i].cmdf = OLECMDF_SUPPORTED|OLECMDF_ENABLED;
 933                 break;
 934             case IDM_BLOCKDIRRTL:
 935                 FIXME("CGID_MSHTML: IDM_BLOCKDIRRTL\n");
 936                 prgCmds[i].cmdf = OLECMDF_SUPPORTED|OLECMDF_ENABLED;
 937                 break;
 938             default:
 939                 FIXME("CGID_MSHTML: unsupported cmdID %d\n", prgCmds[i].cmdID);
 940                 prgCmds[i].cmdf = 0;
 941             }
 942         }
 943
 944         hres = prgCmds[i-1].cmdf ? S_OK : OLECMDERR_E_NOTSUPPORTED;
 945
 946         if(pCmdText)
 947             FIXME("Set pCmdText\n");
 948     }else {
 949         FIXME("Unsupported pguidCmdGroup %s\n", debugstr_guid(pguidCmdGroup));
 950         hres = OLECMDERR_E_UNKNOWNGROUP;
 951     }
 952
 953     return hres;
 954 }
 955
 956 static HRESULT WINAPI OleCommandTarget_Exec(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
 957         DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 958 {
 959     HTMLDocument *This = CMDTARGET_THIS(iface);
 960
 961     if(!pguidCmdGroup) {
 962         if(nCmdID<OLECMDID_OPEN || nCmdID>OLECMDID_GETPRINTTEMPLATE || !exec_table[nCmdID].func) {
 963             WARN("Unsupported cmdID = %d\n", nCmdID);
 964             return OLECMDERR_E_NOTSUPPORTED;
 965         }
 966
 967         return exec_table[nCmdID].func(This, nCmdexecopt, pvaIn, pvaOut);
 968     }else if(IsEqualGUID(&CGID_Explorer, pguidCmdGroup)) {
 969         FIXME("unsupported nCmdID %d of CGID_Explorer group\n", nCmdID);
 970         TRACE("%p %p\n", pvaIn, pvaOut);
 971         return OLECMDERR_E_NOTSUPPORTED;
 972     }else if(IsEqualGUID(&CGID_ShellDocView, pguidCmdGroup)) {
 973         FIXME("unsupported nCmdID %d of CGID_ShellDocView group\n", nCmdID);
 974         return OLECMDERR_E_NOTSUPPORTED;
 975     }else if(IsEqualGUID(&CGID_MSHTML, pguidCmdGroup)) {
 976         switch(nCmdID) {
 977         case IDM_FONTNAME:
 978             return exec_fontname(This, pvaIn, pvaOut);
 979         case IDM_FONTSIZE:
 980             return exec_fontsize(This, pvaIn, pvaOut);
 981         case IDM_PRINT:
 982             return exec_print(This, nCmdexecopt, pvaIn, pvaOut);
 983         case IDM_BOLD:
 984             if(pvaIn || pvaOut)
 985                 FIXME("unsupported arguments\n");
 986             return exec_bold(This);
 987         case IDM_FORECOLOR:
 988             return exec_forecolor(This, pvaIn, pvaOut);
 989         case IDM_ITALIC:
 990             if(pvaIn || pvaOut)
 991                 FIXME("unsupported arguments\n");
 992             return exec_italic(This);
 993         case IDM_JUSTIFYCENTER:
 994             if(pvaIn || pvaOut)
 995                 FIXME("unsupported arguments\n");
 996             return exec_justifycenter(This);
 997         case IDM_JUSTIFYLEFT:
 998             if(pvaIn || pvaOut)
 999                 FIXME("unsupported arguments\n");
1000             return exec_justifyleft(This);
1001         case IDM_JUSTIFYRIGHT:
1002             if(pvaIn || pvaOut)
1003                 FIXME("unsupported arguments\n");
1004             return exec_justifyright(This);
1005         case IDM_UNDERLINE:
1006             if(pvaIn || pvaOut)
1007                 FIXME("unsupported arguments\n");
1008             return exec_underline(This);
1009         case IDM_BROWSEMODE:
1010             if(pvaIn || pvaOut)
1011                 FIXME("unsupported arguments\n");
1012             return exec_browsemode(This);
1013         case IDM_EDITMODE:
1014             if(pvaIn || pvaOut)
1015                 FIXME("unsupported arguments\n");
1016             return exec_editmode(This);
1017         case IDM_BASELINEFONT3:
1018             return exec_baselinefont3(This);
1019         case IDM_HORIZONTALLINE:
1020             if(pvaIn || pvaOut)
1021                 FIXME("unsupported arguments\n");
1022             return exec_horizontalline(This);
1023         case IDM_ORDERLIST:
1024             if(pvaIn || pvaOut)
1025                 FIXME("unsupported arguments\n");
1026             return exec_orderlist(This);
1027         case IDM_UNORDERLIST:
1028             if(pvaIn || pvaOut)
1029                 FIXME("unsupported arguments\n");
1030             return exec_unorderlist(This);
1031         case IDM_INDENT:
1032             if(pvaIn || pvaOut)
1033                 FIXME("unsupported arguments\n");
1034             return exec_indent(This);
1035         case IDM_OUTDENT:
1036             if(pvaIn || pvaOut)
1037                 FIXME("unsupported arguments\n");
1038             return exec_outdent(This);
1039         default:
1040             FIXME("unsupported nCmdID %d of CGID_MSHTML group\n", nCmdID);
1041             return OLECMDERR_E_NOTSUPPORTED;
1042         }
1043     }
1044
1045     FIXME("Unsupported pguidCmdGroup %s\n", debugstr_guid(pguidCmdGroup));
1046     return OLECMDERR_E_UNKNOWNGROUP;
1047 }
1048
1049 #undef CMDTARGET_THIS
1050
1051 static const IOleCommandTargetVtbl OleCommandTargetVtbl = {
1052     OleCommandTarget_QueryInterface,
1053     OleCommandTarget_AddRef,
1054     OleCommandTarget_Release,
1055     OleCommandTarget_QueryStatus,
1056     OleCommandTarget_Exec
1057 };
1058
1059 void HTMLDocument_OleCmd_Init(HTMLDocument *This)
1060 {
1061     This->lpOleCommandTargetVtbl = &OleCommandTargetVtbl;
1062 }