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