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