dlls/mshtml/olecmd.c

   1 /*
   2  * Copyright 2005-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 <stdarg.h>
  20
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "ole2.h"
  27 #include "shlguid.h"
  28 #include "mshtmdid.h"
  29 #include "idispids.h"
  30 #include "mshtmcid.h"
  31
  32 #include "wine/debug.h"
  33
  34 #include "mshtml_private.h"
  35 #include "binding.h"
  36 #include "resource.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  39
  40 #define NSCMD_COPY "cmd_copy"
  41 #define NSCMD_SELECTALL           "cmd_selectAll"
  42
  43 void do_ns_command(HTMLDocument *This, const char *cmd, nsICommandParams *nsparam)
  44 {
  45     nsICommandManager *cmdmgr;
  46     nsresult nsres;
  47
  48     TRACE("(%p)\n", This);
  49
  50     if(!This->doc_obj || !This->doc_obj->nscontainer)
  51         return;
  52
  53     nsres = get_nsinterface((nsISupports*)This->doc_obj->nscontainer->webbrowser, &IID_nsICommandManager, (void**)&cmdmgr);
  54     if(NS_FAILED(nsres)) {
  55         ERR("Could not get nsICommandManager: %08x\n", nsres);
  56         return;
  57     }
  58
  59     nsres = nsICommandManager_DoCommand(cmdmgr, cmd, nsparam, This->window->window_proxy);
  60     if(NS_FAILED(nsres))
  61         ERR("DoCommand(%s) failed: %08x\n", debugstr_a(cmd), nsres);
  62
  63     nsICommandManager_Release(cmdmgr);
  64 }
  65
  66 static nsIClipboardCommands *get_clipboard_commands(HTMLDocument *doc)
  67 {
  68     nsIClipboardCommands *clipboard_commands;
  69     nsIDocShell *doc_shell;
  70     nsresult nsres;
  71
  72     nsres = get_nsinterface((nsISupports*)doc->window->nswindow, &IID_nsIDocShell, (void**)&doc_shell);
  73     if(NS_FAILED(nsres)) {
  74         ERR("Could not get nsIDocShell interface\n");
  75         return NULL;
  76     }
  77
  78     nsres = nsIDocShell_QueryInterface(doc_shell, &IID_nsIClipboardCommands, (void**)&clipboard_commands);
  79     nsIDocShell_Release(doc_shell);
  80     if(NS_FAILED(nsres)) {
  81         ERR("Could not get nsIClipboardCommands interface\n");
  82         return NULL;
  83     }
  84
  85     return clipboard_commands;
  86 }
  87
  88 /**********************************************************
  89  * IOleCommandTarget implementation
  90  */
  91
  92 static inline HTMLDocument *impl_from_IOleCommandTarget(IOleCommandTarget *iface)
  93 {
  94     return CONTAINING_RECORD(iface, HTMLDocument, IOleCommandTarget_iface);
  95 }
  96
  97 static HRESULT exec_open(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
  98 {
  99     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 100     return E_NOTIMPL;
 101 }
 102
 103 static HRESULT exec_new(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 104 {
 105     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 106     return E_NOTIMPL;
 107 }
 108
 109 static HRESULT exec_save(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 110 {
 111     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 112     return E_NOTIMPL;
 113 }
 114
 115 static HRESULT exec_save_as(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 116 {
 117     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 118     return E_NOTIMPL;
 119 }
 120
 121 static HRESULT exec_save_copy_as(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 122 {
 123     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 124     return E_NOTIMPL;
 125 }
 126
 127 static nsresult set_head_text(nsIPrintSettings *settings, LPCWSTR template, BOOL head, int pos)
 128 {
 129     if(head) {
 130         switch(pos) {
 131         case 0:
 132             return nsIPrintSettings_SetHeaderStrLeft(settings, template);
 133         case 1:
 134             return nsIPrintSettings_SetHeaderStrRight(settings, template);
 135         case 2:
 136             return nsIPrintSettings_SetHeaderStrCenter(settings, template);
 137         }
 138     }else {
 139         switch(pos) {
 140         case 0:
 141             return nsIPrintSettings_SetFooterStrLeft(settings, template);
 142         case 1:
 143             return nsIPrintSettings_SetFooterStrRight(settings, template);
 144         case 2:
 145             return nsIPrintSettings_SetFooterStrCenter(settings, template);
 146         }
 147     }
 148
 149     return NS_OK;
 150 }
 151
 152 static void set_print_template(nsIPrintSettings *settings, LPCWSTR template, BOOL head)
 153 {
 154     PRUnichar nstemplate[200]; /* FIXME: Use dynamic allocation */
 155     PRUnichar *p = nstemplate;
 156     LPCWSTR ptr=template;
 157     int pos=0;
 158
 159     while(*ptr) {
 160         if(*ptr != '&') {
 161             *p++ = *ptr++;
 162             continue;
 163         }
 164
 165         switch(*++ptr) {
 166         case '&':
 167             *p++ = '&';
 168             *p++ = '&';
 169             ptr++;
 170             break;
 171         case 'b': /* change align */
 172             ptr++;
 173             *p = 0;
 174             set_head_text(settings, nstemplate, head, pos);
 175             p = nstemplate;
 176             pos++;
 177             break;
 178         case 'd': { /* short date */
 179             SYSTEMTIME systime;
 180             GetLocalTime(&systime);
 181             GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &systime, NULL, p,
 182                     sizeof(nstemplate)-(p-nstemplate)*sizeof(WCHAR));
 183             p += strlenW(p);
 184             ptr++;
 185             break;
 186         }
 187         case 'p': /* page number */
 188             *p++ = '&';
 189             *p++ = 'P';
 190             ptr++;
 191             break;
 192         case 'P': /* page count */
 193             *p++ = '?'; /* FIXME */
 194             ptr++;
 195             break;
 196         case 'u':
 197             *p++ = '&';
 198             *p++ = 'U';
 199             ptr++;
 200             break;
 201         case 'w':
 202             /* FIXME: set window title */
 203             ptr++;
 204             break;
 205         default:
 206             *p++ = '&';
 207             *p++ = *ptr++;
 208         }
 209     }
 210
 211     *p = 0;
 212     set_head_text(settings, nstemplate, head, pos);
 213
 214     while(++pos < 3)
 215         set_head_text(settings, p, head, pos);
 216 }
 217
 218 static void set_default_templates(nsIPrintSettings *settings)
 219 {
 220     WCHAR buf[64];
 221
 222     static const PRUnichar empty[] = {0};
 223
 224     nsIPrintSettings_SetHeaderStrLeft(settings, empty);
 225     nsIPrintSettings_SetHeaderStrRight(settings, empty);
 226     nsIPrintSettings_SetHeaderStrCenter(settings, empty);
 227     nsIPrintSettings_SetFooterStrLeft(settings, empty);
 228     nsIPrintSettings_SetFooterStrRight(settings, empty);
 229     nsIPrintSettings_SetFooterStrCenter(settings, empty);
 230
 231     if(LoadStringW(get_shdoclc(), IDS_PRINT_HEADER_TEMPLATE, buf, ARRAY_SIZE(buf)))
 232         set_print_template(settings, buf, TRUE);
 233
 234     if(LoadStringW(get_shdoclc(), IDS_PRINT_FOOTER_TEMPLATE, buf, ARRAY_SIZE(buf)))
 235         set_print_template(settings, buf, FALSE);
 236
 237 }
 238
 239 static HRESULT exec_print(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 240 {
 241     nsIWebBrowserPrint *nsprint;
 242     nsIPrintSettings *settings;
 243     nsresult nsres;
 244
 245     TRACE("(%p)->(%d %s %p)\n", This, nCmdexecopt, debugstr_variant(pvaIn), pvaOut);
 246
 247     if(pvaOut)
 248         FIXME("unsupported pvaOut\n");
 249
 250     if(!This->doc_obj->nscontainer)
 251         return S_OK;
 252
 253     nsres = get_nsinterface((nsISupports*)This->doc_obj->nscontainer->webbrowser, &IID_nsIWebBrowserPrint,
 254             (void**)&nsprint);
 255     if(NS_FAILED(nsres)) {
 256         ERR("Could not get nsIWebBrowserPrint: %08x\n", nsres);
 257         return S_OK;
 258     }
 259
 260     nsres = nsIWebBrowserPrint_GetGlobalPrintSettings(nsprint, &settings);
 261     if(NS_FAILED(nsres))
 262         ERR("GetCurrentPrintSettings failed: %08x\n", nsres);
 263
 264     set_default_templates(settings);
 265
 266     if(pvaIn) {
 267         switch(V_VT(pvaIn)) {
 268         case VT_BYREF|VT_ARRAY: {
 269             VARIANT *opts;
 270             DWORD opts_cnt;
 271
 272             if(V_ARRAY(pvaIn)->cDims != 1)
 273                 WARN("cDims = %d\n", V_ARRAY(pvaIn)->cDims);
 274
 275             SafeArrayAccessData(V_ARRAY(pvaIn), (void**)&opts);
 276             opts_cnt = V_ARRAY(pvaIn)->rgsabound[0].cElements;
 277
 278             if(opts_cnt >= 1) {
 279                 switch(V_VT(opts)) {
 280                 case VT_BSTR:
 281                     TRACE("setting footer %s\n", debugstr_w(V_BSTR(opts)));
 282                     set_print_template(settings, V_BSTR(opts), TRUE);
 283                     break;
 284                 case VT_NULL:
 285                     break;
 286                 default:
 287                     WARN("opts = %s\n", debugstr_variant(opts));
 288                 }
 289             }
 290
 291             if(opts_cnt >= 2) {
 292                 switch(V_VT(opts+1)) {
 293                 case VT_BSTR:
 294                     TRACE("setting footer %s\n", debugstr_w(V_BSTR(opts+1)));
 295                     set_print_template(settings, V_BSTR(opts+1), FALSE);
 296                     break;
 297                 case VT_NULL:
 298                     break;
 299                 default:
 300                     WARN("opts[1] = %s\n", debugstr_variant(opts+1));
 301                 }
 302             }
 303
 304             if(opts_cnt >= 3)
 305                 FIXME("Unsupported opts_cnt %d\n", opts_cnt);
 306
 307             SafeArrayUnaccessData(V_ARRAY(pvaIn));
 308             break;
 309         }
 310         default:
 311             FIXME("unsupported arg %s\n", debugstr_variant(pvaIn));
 312         }
 313     }
 314
 315     nsres = nsIWebBrowserPrint_Print(nsprint, settings, NULL);
 316     if(NS_FAILED(nsres))
 317         ERR("Print failed: %08x\n", nsres);
 318
 319     nsIWebBrowserPrint_Release(nsprint);
 320
 321     return S_OK;
 322 }
 323
 324 static HRESULT exec_print_preview(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 325 {
 326     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 327     return E_NOTIMPL;
 328 }
 329
 330 static HRESULT exec_page_setup(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 331 {
 332     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 333     return E_NOTIMPL;
 334 }
 335
 336 static HRESULT exec_spell(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 337 {
 338     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 339     return E_NOTIMPL;
 340 }
 341
 342 static HRESULT exec_properties(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 343 {
 344     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 345     return E_NOTIMPL;
 346 }
 347
 348 static HRESULT exec_cut(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 349 {
 350     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 351     return E_NOTIMPL;
 352 }
 353
 354 static HRESULT exec_copy(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 355 {
 356     TRACE("(%p)->(%d %s %p)\n", This, nCmdexecopt, debugstr_variant(pvaIn), pvaOut);
 357
 358     do_ns_command(This, NSCMD_COPY, NULL);
 359     return S_OK;
 360 }
 361
 362 static HRESULT exec_paste(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 363 {
 364     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 365     return E_NOTIMPL;
 366 }
 367
 368 static HRESULT exec_paste_special(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 369 {
 370     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 371     return E_NOTIMPL;
 372 }
 373
 374 static HRESULT exec_undo(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 375 {
 376     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 377     return E_NOTIMPL;
 378 }
 379
 380 static HRESULT exec_rendo(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 381 {
 382     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 383     return E_NOTIMPL;
 384 }
 385
 386 static HRESULT exec_select_all(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *in, VARIANT *out)
 387 {
 388     TRACE("(%p)\n", This);
 389
 390     if(in || out)
 391         FIXME("unsupported args\n");
 392
 393     if(This->doc_obj->nscontainer)
 394         do_ns_command(This, NSCMD_SELECTALL, NULL);
 395
 396     update_doc(This->doc_obj, UPDATE_UI);
 397     return S_OK;
 398 }
 399
 400 static HRESULT exec_clear_selection(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 401 {
 402     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 403     return E_NOTIMPL;
 404 }
 405
 406 static HRESULT exec_zoom(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 407 {
 408     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 409     return E_NOTIMPL;
 410 }
 411
 412 static HRESULT exec_get_zoom_range(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 413 {
 414     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 415     return E_NOTIMPL;
 416 }
 417
 418 typedef struct {
 419     task_t header;
 420     HTMLOuterWindow *window;
 421 }refresh_task_t;
 422
 423 static void refresh_proc(task_t *_task)
 424 {
 425     refresh_task_t *task = (refresh_task_t*)_task;
 426     HTMLOuterWindow *window = task->window;
 427
 428     TRACE("%p\n", window);
 429
 430     window->readystate = READYSTATE_UNINITIALIZED;
 431
 432     if(window->doc_obj && window->doc_obj->client_cmdtrg) {
 433         VARIANT var;
 434
 435         V_VT(&var) = VT_I4;
 436         V_I4(&var) = 0;
 437         IOleCommandTarget_Exec(window->doc_obj->client_cmdtrg, &CGID_ShellDocView, 37, 0, &var, NULL);
 438     }
 439
 440     load_uri(task->window, task->window->uri, BINDING_REFRESH|BINDING_NOFRAG);
 441 }
 442
 443 static void refresh_destr(task_t *_task)
 444 {
 445     refresh_task_t *task = (refresh_task_t*)_task;
 446
 447     IHTMLWindow2_Release(&task->window->base.IHTMLWindow2_iface);
 448     heap_free(task);
 449 }
 450
 451 static HRESULT exec_refresh(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 452 {
 453     refresh_task_t *task;
 454     HRESULT hres;
 455
 456     TRACE("(%p)->(%d %s %p)\n", This, nCmdexecopt, debugstr_variant(pvaIn), pvaOut);
 457
 458     if(This->doc_obj->client) {
 459         IOleCommandTarget *olecmd;
 460
 461         hres = IOleClientSite_QueryInterface(This->doc_obj->client, &IID_IOleCommandTarget, (void**)&olecmd);
 462         if(SUCCEEDED(hres)) {
 463             hres = IOleCommandTarget_Exec(olecmd, &CGID_DocHostCommandHandler, 2300, nCmdexecopt, pvaIn, pvaOut);
 464             IOleCommandTarget_Release(olecmd);
 465             if(SUCCEEDED(hres))
 466                 return S_OK;
 467         }
 468     }
 469
 470     if(!This->window)
 471         return E_UNEXPECTED;
 472
 473     task = heap_alloc(sizeof(*task));
 474     if(!task)
 475         return E_OUTOFMEMORY;
 476
 477     IHTMLWindow2_AddRef(&This->window->base.IHTMLWindow2_iface);
 478     task->window = This->window;
 479
 480     return push_task(&task->header, refresh_proc, refresh_destr, This->window->task_magic);
 481 }
 482
 483 static HRESULT exec_stop(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 484 {
 485     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 486     return E_NOTIMPL;
 487 }
 488
 489 static HRESULT exec_stop_download(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 490 {
 491     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 492     return E_NOTIMPL;
 493 }
 494
 495 static HRESULT exec_find(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 496 {
 497     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 498     return E_NOTIMPL;
 499 }
 500
 501 static HRESULT exec_delete(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 502 {
 503     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 504     return E_NOTIMPL;
 505 }
 506
 507 static HRESULT exec_enable_interaction(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 508 {
 509     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 510     return E_NOTIMPL;
 511 }
 512
 513 static HRESULT exec_on_unload(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 514 {
 515     TRACE("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 516
 517     /* Tests show that we have nothing more to do here */
 518
 519     if(pvaOut) {
 520         V_VT(pvaOut) = VT_BOOL;
 521         V_BOOL(pvaOut) = VARIANT_TRUE;
 522     }
 523
 524     return S_OK;
 525 }
 526
 527 static HRESULT exec_show_page_setup(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 528 {
 529     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 530     return E_NOTIMPL;
 531 }
 532
 533 static HRESULT exec_show_print(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 534 {
 535     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 536     return E_NOTIMPL;
 537 }
 538
 539 static HRESULT exec_close(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 540 {
 541     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 542     return E_NOTIMPL;
 543 }
 544
 545 static HRESULT exec_set_print_template(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 546 {
 547     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 548     return E_NOTIMPL;
 549 }
 550
 551 static HRESULT exec_get_print_template(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 552 {
 553     FIXME("(%p)->(%d %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 554     return E_NOTIMPL;
 555 }
 556
 557 static HRESULT exec_optical_zoom(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 558 {
 559     TRACE("(%p)->(%d %s %p)\n", This, nCmdexecopt, debugstr_variant(pvaIn), pvaOut);
 560
 561     if(!pvaIn || V_VT(pvaIn) != VT_I4) {
 562         FIXME("Unsupported argument %s\n", debugstr_variant(pvaIn));
 563         return E_NOTIMPL;
 564     }
 565
 566     set_viewer_zoom(This->doc_obj->nscontainer, (float)V_I4(pvaIn)/100);
 567     return S_OK;
 568 }
 569
 570 static HRESULT query_mshtml_copy(HTMLDocument *This, OLECMD *cmd)
 571 {
 572     FIXME("(%p)\n", This);
 573     cmd->cmdf = OLECMDF_SUPPORTED|OLECMDF_ENABLED;
 574     return S_OK;
 575 }
 576
 577 static HRESULT exec_mshtml_copy(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 578 {
 579     TRACE("(%p)->(%08x %p %p)\n", This, cmdexecopt, in, out);
 580
 581     if(This->doc_obj->usermode == EDITMODE)
 582         return editor_exec_copy(This, cmdexecopt, in, out);
 583
 584     do_ns_command(This, NSCMD_COPY, NULL);
 585     return S_OK;
 586 }
 587
 588 static HRESULT query_mshtml_cut(HTMLDocument *This, OLECMD *cmd)
 589 {
 590     FIXME("(%p)\n", This);
 591     cmd->cmdf = OLECMDF_SUPPORTED|OLECMDF_ENABLED;
 592     return S_OK;
 593 }
 594
 595 static HRESULT exec_mshtml_cut(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 596 {
 597     nsIClipboardCommands *clipboard_commands;
 598     nsresult nsres;
 599
 600     TRACE("(%p)->(%08x %p %p)\n", This, cmdexecopt, in, out);
 601
 602     if(This->doc_obj->usermode == EDITMODE)
 603         return editor_exec_cut(This, cmdexecopt, in, out);
 604
 605     clipboard_commands = get_clipboard_commands(This);
 606     if(!clipboard_commands)
 607         return E_UNEXPECTED;
 608
 609     nsres = nsIClipboardCommands_CutSelection(clipboard_commands);
 610     nsIClipboardCommands_Release(clipboard_commands);
 611     if(NS_FAILED(nsres)) {
 612         ERR("Paste failed: %08x\n", nsres);
 613         return E_FAIL;
 614     }
 615
 616     return S_OK;
 617 }
 618
 619 static HRESULT query_mshtml_paste(HTMLDocument *This, OLECMD *cmd)
 620 {
 621     FIXME("(%p)\n", This);
 622     cmd->cmdf = OLECMDF_SUPPORTED|OLECMDF_ENABLED;
 623     return S_OK;
 624 }
 625
 626 static HRESULT exec_mshtml_paste(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 627 {
 628     nsIClipboardCommands *clipboard_commands;
 629     nsresult nsres;
 630
 631     TRACE("(%p)->(%08x %p %p)\n", This, cmdexecopt, in, out);
 632
 633     if(This->doc_obj->usermode == EDITMODE)
 634         return editor_exec_paste(This, cmdexecopt, in, out);
 635
 636     clipboard_commands = get_clipboard_commands(This);
 637     if(!clipboard_commands)
 638         return E_UNEXPECTED;
 639
 640     nsres = nsIClipboardCommands_Paste(clipboard_commands);
 641     nsIClipboardCommands_Release(clipboard_commands);
 642     if(NS_FAILED(nsres)) {
 643         ERR("Paste failed: %08x\n", nsres);
 644         return E_FAIL;
 645     }
 646
 647     return S_OK;
 648 }
 649
 650 static HRESULT query_selall_status(HTMLDocument *This, OLECMD *cmd)
 651 {
 652     TRACE("(%p)->(%p)\n", This, cmd);
 653
 654     cmd->cmdf = OLECMDF_SUPPORTED|OLECMDF_ENABLED;
 655     return S_OK;
 656 }
 657
 658 static HRESULT exec_browsemode(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 659 {
 660     WARN("(%p)->(%08x %p %p)\n", This, cmdexecopt, in, out);
 661
 662     if(in || out)
 663         FIXME("unsupported args\n");
 664
 665     This->doc_obj->usermode = BROWSEMODE;
 666
 667     return S_OK;
 668 }
 669
 670 static HRESULT exec_editmode(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 671 {
 672     TRACE("(%p)->(%08x %p %p)\n", This, cmdexecopt, in, out);
 673
 674     if(in || out)
 675         FIXME("unsupported args\n");
 676
 677     return setup_edit_mode(This->doc_obj);
 678 }
 679
 680 static HRESULT exec_htmleditmode(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 681 {
 682     FIXME("(%p)->(%08x %p %p)\n", This, cmdexecopt, in, out);
 683     return S_OK;
 684 }
 685
 686 static HRESULT exec_baselinefont3(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 687 {
 688     FIXME("(%p)->(%08x %p %p)\n", This, cmdexecopt, in, out);
 689     return S_OK;
 690 }
 691
 692 static HRESULT exec_respectvisibility_indesign(HTMLDocument *This, DWORD cmdexecopt,
 693         VARIANT *in, VARIANT *out)
 694 {
 695     TRACE("(%p)->(%x %s %p)\n", This, cmdexecopt, debugstr_variant(in), out);
 696
 697     /* This is turned on by default in Gecko. */
 698     if(!in || V_VT(in) != VT_BOOL || !V_BOOL(in))
 699         FIXME("Unsupported argument %s\n", debugstr_variant(in));
 700
 701     return S_OK;
 702 }
 703
 704 static HRESULT query_enabled_stub(HTMLDocument *This, OLECMD *cmd)
 705 {
 706     switch(cmd->cmdID) {
 707     case IDM_PRINT:
 708         FIXME("CGID_MSHTML: IDM_PRINT\n");
 709         cmd->cmdf = OLECMDF_SUPPORTED|OLECMDF_ENABLED;
 710         break;
 711     case IDM_BLOCKDIRLTR:
 712         FIXME("CGID_MSHTML: IDM_BLOCKDIRLTR\n");
 713         cmd->cmdf = OLECMDF_SUPPORTED|OLECMDF_ENABLED;
 714         break;
 715     case IDM_BLOCKDIRRTL:
 716         FIXME("CGID_MSHTML: IDM_BLOCKDIRRTL\n");
 717         cmd->cmdf = OLECMDF_SUPPORTED|OLECMDF_ENABLED;
 718         break;
 719     }
 720
 721     return S_OK;
 722 }
 723
 724 static const struct {
 725     OLECMDF cmdf;
 726     HRESULT (*func)(HTMLDocument*,DWORD,VARIANT*,VARIANT*);
 727 } exec_table[] = {
 728     {0},
 729     { OLECMDF_SUPPORTED,                  exec_open                 }, /* OLECMDID_OPEN */
 730     { OLECMDF_SUPPORTED,                  exec_new                  }, /* OLECMDID_NEW */
 731     { OLECMDF_SUPPORTED,                  exec_save                 }, /* OLECMDID_SAVE */
 732     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_save_as              }, /* OLECMDID_SAVEAS */
 733     { OLECMDF_SUPPORTED,                  exec_save_copy_as         }, /* OLECMDID_SAVECOPYAS */
 734     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_print                }, /* OLECMDID_PRINT */
 735     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_print_preview        }, /* OLECMDID_PRINTPREVIEW */
 736     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_page_setup           }, /* OLECMDID_PAGESETUP */
 737     { OLECMDF_SUPPORTED,                  exec_spell                }, /* OLECMDID_SPELL */
 738     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_properties           }, /* OLECMDID_PROPERTIES */
 739     { OLECMDF_SUPPORTED,                  exec_cut                  }, /* OLECMDID_CUT */
 740     { OLECMDF_SUPPORTED,                  exec_copy                 }, /* OLECMDID_COPY */
 741     { OLECMDF_SUPPORTED,                  exec_paste                }, /* OLECMDID_PASTE */
 742     { OLECMDF_SUPPORTED,                  exec_paste_special        }, /* OLECMDID_PASTESPECIAL */
 743     { OLECMDF_SUPPORTED,                  exec_undo                 }, /* OLECMDID_UNDO */
 744     { OLECMDF_SUPPORTED,                  exec_rendo                }, /* OLECMDID_REDO */
 745     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_select_all           }, /* OLECMDID_SELECTALL */
 746     { OLECMDF_SUPPORTED,                  exec_clear_selection      }, /* OLECMDID_CLEARSELECTION */
 747     { OLECMDF_SUPPORTED,                  exec_zoom                 }, /* OLECMDID_ZOOM */
 748     { OLECMDF_SUPPORTED,                  exec_get_zoom_range       }, /* OLECMDID_GETZOOMRANGE */
 749     {0},
 750     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_refresh              }, /* OLECMDID_REFRESH */
 751     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_stop                 }, /* OLECMDID_STOP */
 752     {0},{0},{0},{0},{0},{0},
 753     { OLECMDF_SUPPORTED,                  exec_stop_download        }, /* OLECMDID_STOPDOWNLOAD */
 754     {0},
 755     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_find                 }, /* OLECMDID_FIND */
 756     { OLECMDF_SUPPORTED,                  exec_delete               }, /* OLECMDID_DELETE */
 757     {0},{0},
 758     { OLECMDF_SUPPORTED,                  exec_enable_interaction   }, /* OLECMDID_ENABLE_INTERACTION */
 759     { OLECMDF_SUPPORTED,                  exec_on_unload            }, /* OLECMDID_ONUNLOAD */
 760     {0},{0},{0},{0},{0},
 761     { OLECMDF_SUPPORTED,                  exec_show_page_setup      }, /* OLECMDID_SHOWPAGESETUP */
 762     { OLECMDF_SUPPORTED,                  exec_show_print           }, /* OLECMDID_SHOWPRINT */
 763     {0},{0},
 764     { OLECMDF_SUPPORTED,                  exec_close                }, /* OLECMDID_CLOSE */
 765     {0},{0},{0},
 766     { OLECMDF_SUPPORTED,                  exec_set_print_template   }, /* OLECMDID_SETPRINTTEMPLATE */
 767     { OLECMDF_SUPPORTED,                  exec_get_print_template   }, /* OLECMDID_GETPRINTTEMPLATE */
 768     {0},{0},{0},{0},{0},{0},{0},{0},{0},{0},
 769     { 0, /* not reported as supported */  exec_optical_zoom         }  /* OLECMDID_OPTICAL_ZOOM */
 770 };
 771
 772 static const cmdtable_t base_cmds[] = {
 773     {IDM_COPY,             query_mshtml_copy,     exec_mshtml_copy},
 774     {IDM_PASTE,            query_mshtml_paste,    exec_mshtml_paste},
 775     {IDM_CUT,              query_mshtml_cut,      exec_mshtml_cut},
 776     {IDM_SELECTALL,        query_selall_status,   exec_select_all},
 777     {IDM_BROWSEMODE,       NULL,                  exec_browsemode},
 778     {IDM_EDITMODE,         NULL,                  exec_editmode},
 779     {IDM_PRINT,            query_enabled_stub,    exec_print},
 780     {IDM_HTMLEDITMODE,     NULL,                  exec_htmleditmode},
 781     {IDM_BASELINEFONT3,    NULL,                  exec_baselinefont3},
 782     {IDM_BLOCKDIRLTR,      query_enabled_stub,    NULL},
 783     {IDM_BLOCKDIRRTL,      query_enabled_stub,    NULL},
 784     {IDM_RESPECTVISIBILITY_INDESIGN, NULL,        exec_respectvisibility_indesign},
 785     {0,NULL,NULL}
 786 };
 787
 788 static HRESULT WINAPI OleCommandTarget_QueryInterface(IOleCommandTarget *iface, REFIID riid, void **ppv)
 789 {
 790     HTMLDocument *This = impl_from_IOleCommandTarget(iface);
 791     return htmldoc_query_interface(This, riid, ppv);
 792 }
 793
 794 static ULONG WINAPI OleCommandTarget_AddRef(IOleCommandTarget *iface)
 795 {
 796     HTMLDocument *This = impl_from_IOleCommandTarget(iface);
 797     return htmldoc_addref(This);
 798 }
 799
 800 static ULONG WINAPI OleCommandTarget_Release(IOleCommandTarget *iface)
 801 {
 802     HTMLDocument *This = impl_from_IOleCommandTarget(iface);
 803     return htmldoc_release(This);
 804 }
 805
 806 static HRESULT query_from_table(HTMLDocument *This, const cmdtable_t *cmdtable, OLECMD *cmd)
 807 {
 808     const cmdtable_t *iter = cmdtable;
 809
 810     cmd->cmdf = 0;
 811
 812     while(iter->id && iter->id != cmd->cmdID)
 813         iter++;
 814
 815     if(!iter->id || !iter->query)
 816         return OLECMDERR_E_NOTSUPPORTED;
 817
 818     return iter->query(This, cmd);
 819 }
 820
 821 static HRESULT WINAPI OleCommandTarget_QueryStatus(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
 822         ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText)
 823 {
 824     HTMLDocument *This = impl_from_IOleCommandTarget(iface);
 825     HRESULT hres;
 826
 827     TRACE("(%p)->(%s %d %p %p)\n", This, debugstr_guid(pguidCmdGroup), cCmds, prgCmds, pCmdText);
 828
 829     if(pCmdText)
 830         FIXME("Unsupported pCmdText\n");
 831     if(!cCmds)
 832         return S_OK;
 833
 834     if(!pguidCmdGroup) {
 835         ULONG i;
 836
 837         for(i=0; i<cCmds; i++) {
 838             if(prgCmds[i].cmdID < OLECMDID_OPEN || prgCmds[i].cmdID >= ARRAY_SIZE(exec_table)) {
 839                 WARN("Unsupported cmdID = %d\n", prgCmds[i].cmdID);
 840                 prgCmds[i].cmdf = 0;
 841             }else {
 842                 if(prgCmds[i].cmdID == OLECMDID_OPEN || prgCmds[i].cmdID == OLECMDID_NEW) {
 843                     IOleCommandTarget *cmdtrg = NULL;
 844                     OLECMD olecmd;
 845
 846                     prgCmds[i].cmdf = OLECMDF_SUPPORTED;
 847                     if(This->doc_obj->client) {
 848                         hres = IOleClientSite_QueryInterface(This->doc_obj->client, &IID_IOleCommandTarget,
 849                                 (void**)&cmdtrg);
 850                         if(SUCCEEDED(hres)) {
 851                             olecmd.cmdID = prgCmds[i].cmdID;
 852                             olecmd.cmdf = 0;
 853
 854                             hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, 1, &olecmd, NULL);
 855                             if(SUCCEEDED(hres) && olecmd.cmdf)
 856                                 prgCmds[i].cmdf = olecmd.cmdf;
 857                         }
 858                     }else {
 859                         ERR("This->client == NULL, native would crash\n");
 860                     }
 861                 }else {
 862                     prgCmds[i].cmdf = exec_table[prgCmds[i].cmdID].cmdf;
 863                     TRACE("cmdID = %d  returning %x\n", prgCmds[i].cmdID, prgCmds[i].cmdf);
 864                 }
 865             }
 866         }
 867
 868         return (prgCmds[cCmds-1].cmdf & OLECMDF_SUPPORTED) ? S_OK : OLECMDERR_E_NOTSUPPORTED;
 869     }
 870
 871     if(IsEqualGUID(&CGID_MSHTML, pguidCmdGroup)) {
 872         ULONG i;
 873
 874         for(i=0; i<cCmds; i++) {
 875             hres = query_from_table(This, base_cmds, prgCmds+i);
 876             if(hres == OLECMDERR_E_NOTSUPPORTED)
 877                 hres = query_from_table(This, editmode_cmds, prgCmds+i);
 878             if(hres == OLECMDERR_E_NOTSUPPORTED)
 879                 FIXME("CGID_MSHTML: unsupported cmdID %d\n", prgCmds[i].cmdID);
 880         }
 881
 882         return (prgCmds[cCmds-1].cmdf & OLECMDF_SUPPORTED) ? S_OK : OLECMDERR_E_NOTSUPPORTED;
 883     }
 884
 885     FIXME("Unsupported pguidCmdGroup %s\n", debugstr_guid(pguidCmdGroup));
 886     return OLECMDERR_E_UNKNOWNGROUP;
 887 }
 888
 889 static HRESULT exec_from_table(HTMLDocument *This, const cmdtable_t *cmdtable, DWORD cmdid,
 890                                DWORD cmdexecopt, VARIANT *in, VARIANT *out)
 891 {
 892     const cmdtable_t *iter = cmdtable;
 893
 894     while(iter->id && iter->id != cmdid)
 895         iter++;
 896
 897     if(!iter->id || !iter->exec)
 898         return OLECMDERR_E_NOTSUPPORTED;
 899
 900     return iter->exec(This, cmdexecopt, in, out);
 901 }
 902
 903 static HRESULT WINAPI OleCommandTarget_Exec(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
 904         DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 905 {
 906     HTMLDocument *This = impl_from_IOleCommandTarget(iface);
 907
 908     if(!pguidCmdGroup) {
 909         if(nCmdID < OLECMDID_OPEN || nCmdID >= ARRAY_SIZE(exec_table) || !exec_table[nCmdID].func) {
 910             WARN("Unsupported cmdID = %d\n", nCmdID);
 911             return OLECMDERR_E_NOTSUPPORTED;
 912         }
 913
 914         return exec_table[nCmdID].func(This, nCmdexecopt, pvaIn, pvaOut);
 915     }else if(IsEqualGUID(&CGID_Explorer, pguidCmdGroup)) {
 916         FIXME("unsupported nCmdID %d of CGID_Explorer group\n", nCmdID);
 917         TRACE("%p %p\n", pvaIn, pvaOut);
 918         return OLECMDERR_E_NOTSUPPORTED;
 919     }else if(IsEqualGUID(&CGID_ShellDocView, pguidCmdGroup)) {
 920         FIXME("unsupported nCmdID %d of CGID_ShellDocView group\n", nCmdID);
 921         return OLECMDERR_E_NOTSUPPORTED;
 922     }else if(IsEqualGUID(&CGID_MSHTML, pguidCmdGroup)) {
 923         HRESULT hres = exec_from_table(This, base_cmds, nCmdID, nCmdexecopt, pvaIn, pvaOut);
 924         if(hres == OLECMDERR_E_NOTSUPPORTED)
 925             hres = exec_from_table(This, editmode_cmds, nCmdID,
 926                                    nCmdexecopt, pvaIn, pvaOut);
 927         if(hres == OLECMDERR_E_NOTSUPPORTED)
 928             FIXME("unsupported nCmdID %d of CGID_MSHTML group\n", nCmdID);
 929
 930         return hres;
 931     }
 932
 933     FIXME("Unsupported pguidCmdGroup %s\n", debugstr_guid(pguidCmdGroup));
 934     return OLECMDERR_E_UNKNOWNGROUP;
 935 }
 936
 937 static const IOleCommandTargetVtbl OleCommandTargetVtbl = {
 938     OleCommandTarget_QueryInterface,
 939     OleCommandTarget_AddRef,
 940     OleCommandTarget_Release,
 941     OleCommandTarget_QueryStatus,
 942     OleCommandTarget_Exec
 943 };
 944
 945 void show_context_menu(HTMLDocumentObj *This, DWORD dwID, POINT *ppt, IDispatch *elem)
 946 {
 947     HMENU menu_res, menu;
 948     DWORD cmdid;
 949
 950     if(This->hostui && S_OK == IDocHostUIHandler_ShowContextMenu(This->hostui,
 951             dwID, ppt, (IUnknown*)&This->basedoc.IOleCommandTarget_iface, elem))
 952         return;
 953
 954     menu_res = LoadMenuW(get_shdoclc(), MAKEINTRESOURCEW(IDR_BROWSE_CONTEXT_MENU));
 955     menu = GetSubMenu(menu_res, dwID);
 956
 957     cmdid = TrackPopupMenu(menu, TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_RETURNCMD,
 958             ppt->x, ppt->y, 0, This->hwnd, NULL);
 959     DestroyMenu(menu_res);
 960
 961     if(cmdid)
 962         IOleCommandTarget_Exec(&This->basedoc.IOleCommandTarget_iface, &CGID_MSHTML, cmdid, 0,
 963                 NULL, NULL);
 964 }
 965
 966 void HTMLDocument_OleCmd_Init(HTMLDocument *This)
 967 {
 968     This->IOleCommandTarget_iface.lpVtbl = &OleCommandTargetVtbl;
 969 }