avifil32: Reorder some code to avoid forward declarations for the IGetFrameVtbl methods.
[wine] / dlls / shdocvw / dochost.c
1 /*
2  * Copyright 2005-2006 Jacek Caban for CodeWeavers
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #include "wine/debug.h"
20 #include "shdocvw.h"
21 #include "hlink.h"
22 #include "exdispid.h"
23 #include "mshtml.h"
24 #include "initguid.h"
25
26 WINE_DEFAULT_DEBUG_CHANNEL(shdocvw);
27
28 DEFINE_OLEGUID(CGID_DocHostCmdPriv, 0x000214D4L, 0, 0);
29
30 #define DOCHOST_DOCCANNAVIGATE  0
31
32 static ATOM doc_view_atom = 0;
33
34 void push_dochost_task(DocHost *This, task_header_t *task, task_proc_t proc, BOOL send)
35 {
36     task->proc = proc;
37
38     /* FIXME: Don't use lParam */
39     if(send)
40         SendMessageW(This->frame_hwnd, WM_DOCHOSTTASK, 0, (LPARAM)task);
41     else
42         PostMessageW(This->frame_hwnd, WM_DOCHOSTTASK, 0, (LPARAM)task);
43 }
44
45 LRESULT process_dochost_task(DocHost *This, LPARAM lparam)
46 {
47     task_header_t *task = (task_header_t*)lparam;
48
49     task->proc(This, task);
50
51     heap_free(task);
52     return 0;
53 }
54
55 static void notif_complete(DocHost *This, DISPID dispid)
56 {
57     DISPPARAMS dispparams;
58     VARIANTARG params[2];
59     VARIANT url;
60
61     dispparams.cArgs = 2;
62     dispparams.cNamedArgs = 0;
63     dispparams.rgdispidNamedArgs = NULL;
64     dispparams.rgvarg = params;
65
66     V_VT(params) = (VT_BYREF|VT_VARIANT);
67     V_BYREF(params) = &url;
68
69     V_VT(params+1) = VT_DISPATCH;
70     V_DISPATCH(params+1) = This->disp;
71
72     V_VT(&url) = VT_BSTR;
73     V_BSTR(&url) = SysAllocString(This->url);
74
75     TRACE("%d >>>\n", dispid);
76     call_sink(This->cps.wbe2, dispid, &dispparams);
77     TRACE("%d <<<\n", dispid);
78
79     SysFreeString(V_BSTR(&url));
80     This->busy = VARIANT_FALSE;
81 }
82
83 static void object_available(DocHost *This)
84 {
85     IHlinkTarget *hlink;
86     HRESULT hres;
87
88     TRACE("(%p)\n", This);
89
90     if(!This->document) {
91         WARN("document == NULL\n");
92         return;
93     }
94
95     hres = IUnknown_QueryInterface(This->document, &IID_IHlinkTarget, (void**)&hlink);
96     if(FAILED(hres)) {
97         FIXME("Could not get IHlinkTarget interface\n");
98         return;
99     }
100
101     hres = IHlinkTarget_Navigate(hlink, 0, NULL);
102     IHlinkTarget_Release(hlink);
103     if(FAILED(hres))
104         FIXME("Navigate failed\n");
105 }
106
107 static HRESULT get_doc_ready_state(DocHost *This, READYSTATE *ret)
108 {
109     DISPPARAMS dp = {NULL,NULL,0,0};
110     IDispatch *disp;
111     EXCEPINFO ei;
112     VARIANT var;
113     HRESULT hres;
114
115     hres = IUnknown_QueryInterface(This->document, &IID_IDispatch, (void**)&disp);
116     if(FAILED(hres))
117         return hres;
118
119     hres = IDispatch_Invoke(disp, DISPID_READYSTATE, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYGET,
120             &dp, &var, &ei, NULL);
121     IDispatch_Release(disp);
122     if(FAILED(hres)) {
123         WARN("Invoke(DISPID_READYSTATE failed: %08x\n", hres);
124         return hres;
125     }
126
127     if(V_VT(&var) != VT_I4) {
128         WARN("V_VT(var) = %d\n", V_VT(&var));
129         VariantClear(&var);
130         return E_FAIL;
131     }
132
133     *ret = V_I4(&var);
134     return S_OK;
135 }
136
137 static void advise_prop_notif(DocHost *This, BOOL set)
138 {
139     IConnectionPointContainer *cp_container;
140     IConnectionPoint *cp;
141     HRESULT hres;
142
143     hres = IUnknown_QueryInterface(This->document, &IID_IConnectionPointContainer, (void**)&cp_container);
144     if(FAILED(hres))
145         return;
146
147     hres = IConnectionPointContainer_FindConnectionPoint(cp_container, &IID_IPropertyNotifySink, &cp);
148     IConnectionPointContainer_Release(cp_container);
149     if(FAILED(hres))
150         return;
151
152     if(set)
153         hres = IConnectionPoint_Advise(cp, (IUnknown*)&This->IPropertyNotifySink_iface, &This->prop_notif_cookie);
154     else
155         hres = IConnectionPoint_Unadvise(cp, This->prop_notif_cookie);
156     IConnectionPoint_Release(cp);
157
158     if(SUCCEEDED(hres))
159         This->is_prop_notif = set;
160 }
161
162 void set_doc_state(DocHost *This, READYSTATE doc_state)
163 {
164     This->doc_state = doc_state;
165     if(doc_state > This->ready_state)
166         This->ready_state = doc_state;
167 }
168
169 static void update_ready_state(DocHost *This, READYSTATE ready_state)
170 {
171     if(ready_state > READYSTATE_LOADING && This->doc_state <= READYSTATE_LOADING)
172         notif_complete(This, DISPID_NAVIGATECOMPLETE2);
173
174     if(ready_state == READYSTATE_COMPLETE && This->doc_state < READYSTATE_COMPLETE) {
175         set_doc_state(This, READYSTATE_COMPLETE);
176         notif_complete(This, DISPID_DOCUMENTCOMPLETE);
177     }else {
178         set_doc_state(This, ready_state);
179     }
180 }
181
182 typedef struct {
183     task_header_t header;
184     IUnknown *doc;
185     READYSTATE ready_state;
186 } ready_state_task_t;
187
188 static void ready_state_proc(DocHost *This, task_header_t *_task)
189 {
190     ready_state_task_t *task = (ready_state_task_t*)_task;
191
192     if(task->doc == This->document)
193         update_ready_state(This, task->ready_state);
194
195     IUnknown_Release(task->doc);
196 }
197
198 static void push_ready_state_task(DocHost *This, READYSTATE ready_state)
199 {
200     ready_state_task_t *task = heap_alloc(sizeof(ready_state_task_t));
201
202     IUnknown_AddRef(This->document);
203     task->doc = This->document;
204     task->ready_state = ready_state;
205
206     push_dochost_task(This, &task->header, ready_state_proc, FALSE);
207 }
208
209 static void object_available_proc(DocHost *This, task_header_t *task)
210 {
211     object_available(This);
212 }
213
214 HRESULT dochost_object_available(DocHost *This, IUnknown *doc)
215 {
216     READYSTATE ready_state;
217     task_header_t *task;
218     IOleObject *oleobj;
219     HRESULT hres;
220
221     IUnknown_AddRef(doc);
222     This->document = doc;
223
224     hres = IUnknown_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
225     if(SUCCEEDED(hres)) {
226         CLSID clsid;
227
228         hres = IOleObject_GetUserClassID(oleobj, &clsid);
229         if(SUCCEEDED(hres))
230             TRACE("Got clsid %s\n",
231                   IsEqualGUID(&clsid, &CLSID_HTMLDocument) ? "CLSID_HTMLDocument" : debugstr_guid(&clsid));
232
233         hres = IOleObject_SetClientSite(oleobj, &This->IOleClientSite_iface);
234         if(FAILED(hres))
235             FIXME("SetClientSite failed: %08x\n", hres);
236
237         IOleObject_Release(oleobj);
238     }else {
239         FIXME("Could not get IOleObject iface: %08x\n", hres);
240     }
241
242     /* FIXME: Call SetAdvise */
243
244     task = heap_alloc(sizeof(*task));
245     push_dochost_task(This, task, object_available_proc, FALSE);
246
247     hres = get_doc_ready_state(This, &ready_state);
248     if(SUCCEEDED(hres)) {
249         if(ready_state == READYSTATE_COMPLETE)
250             push_ready_state_task(This, READYSTATE_COMPLETE);
251         if(ready_state != READYSTATE_COMPLETE || This->doc_navigate)
252             advise_prop_notif(This, TRUE);
253     }
254
255     return S_OK;
256 }
257
258 static LRESULT resize_document(DocHost *This, LONG width, LONG height)
259 {
260     RECT rect = {0, 0, width, height};
261
262     TRACE("(%p)->(%d %d)\n", This, width, height);
263
264     if(This->view)
265         IOleDocumentView_SetRect(This->view, &rect);
266
267     return 0;
268 }
269
270 static LRESULT WINAPI doc_view_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
271 {
272     DocHost *This;
273
274     static const WCHAR wszTHIS[] = {'T','H','I','S',0};
275
276     if(msg == WM_CREATE) {
277         This = *(DocHost**)lParam;
278         SetPropW(hwnd, wszTHIS, This);
279     }else {
280         This = GetPropW(hwnd, wszTHIS);
281     }
282
283     switch(msg) {
284     case WM_SIZE:
285         return resize_document(This, LOWORD(lParam), HIWORD(lParam));
286     }
287
288     return DefWindowProcW(hwnd, msg, wParam, lParam);
289 }
290
291 void create_doc_view_hwnd(DocHost *This)
292 {
293     RECT rect;
294
295     static const WCHAR wszShell_DocObject_View[] =
296         {'S','h','e','l','l',' ','D','o','c','O','b','j','e','c','t',' ','V','i','e','w',0};
297
298     if(!doc_view_atom) {
299         static WNDCLASSEXW wndclass = {
300             sizeof(wndclass),
301             CS_PARENTDC,
302             doc_view_proc,
303             0, 0 /* native uses 4*/, NULL, NULL, NULL,
304             (HBRUSH)(COLOR_WINDOW + 1), NULL,
305             wszShell_DocObject_View,
306             NULL
307         };
308
309         wndclass.hInstance = shdocvw_hinstance;
310
311         doc_view_atom = RegisterClassExW(&wndclass);
312     }
313
314     This->container_vtbl->GetDocObjRect(This, &rect);
315     This->hwnd = CreateWindowExW(0, wszShell_DocObject_View,
316          wszShell_DocObject_View,
317          WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_TABSTOP,
318          rect.left, rect.top, rect.right, rect.bottom, This->frame_hwnd,
319          NULL, shdocvw_hinstance, This);
320 }
321
322 void deactivate_document(DocHost *This)
323 {
324     IOleInPlaceObjectWindowless *winobj;
325     IOleObject *oleobj = NULL;
326     IHlinkTarget *hlink = NULL;
327     HRESULT hres;
328
329     if(This->doc_navigate) {
330         IUnknown_Release(This->doc_navigate);
331         This->doc_navigate = NULL;
332     }
333
334     if(This->is_prop_notif)
335         advise_prop_notif(This, FALSE);
336
337     if(This->view)
338         IOleDocumentView_UIActivate(This->view, FALSE);
339
340     hres = IUnknown_QueryInterface(This->document, &IID_IOleInPlaceObjectWindowless,
341                                    (void**)&winobj);
342     if(SUCCEEDED(hres)) {
343         IOleInPlaceObjectWindowless_InPlaceDeactivate(winobj);
344         IOleInPlaceObjectWindowless_Release(winobj);
345     }
346
347     if(This->view) {
348         IOleDocumentView_Show(This->view, FALSE);
349         IOleDocumentView_CloseView(This->view, 0);
350         IOleDocumentView_SetInPlaceSite(This->view, NULL);
351         IOleDocumentView_Release(This->view);
352         This->view = NULL;
353     }
354
355     hres = IUnknown_QueryInterface(This->document, &IID_IOleObject, (void**)&oleobj);
356     if(SUCCEEDED(hres))
357         IOleObject_Close(oleobj, OLECLOSE_NOSAVE);
358
359     hres = IUnknown_QueryInterface(This->document, &IID_IHlinkTarget, (void**)&hlink);
360     if(SUCCEEDED(hres)) {
361         IHlinkTarget_SetBrowseContext(hlink, NULL);
362         IHlinkTarget_Release(hlink);
363     }
364
365     if(oleobj) {
366         IOleClientSite *client_site = NULL;
367
368         IOleObject_GetClientSite(oleobj, &client_site);
369         if(client_site) {
370             if(client_site == &This->IOleClientSite_iface)
371                 IOleObject_SetClientSite(oleobj, NULL);
372             IOleClientSite_Release(client_site);
373         }
374
375         IOleObject_Release(oleobj);
376     }
377
378     IUnknown_Release(This->document);
379     This->document = NULL;
380 }
381
382 void release_dochost_client(DocHost *This)
383 {
384     if(This->hwnd) {
385         DestroyWindow(This->hwnd);
386         This->hwnd = NULL;
387     }
388
389     if(This->hostui) {
390         IDocHostUIHandler_Release(This->hostui);
391         This->hostui = NULL;
392     }
393
394     if(This->client_disp) {
395         IDispatch_Release(This->client_disp);
396         This->client_disp = NULL;
397     }
398
399     if(This->frame) {
400         IOleInPlaceFrame_Release(This->frame);
401         This->frame = NULL;
402     }
403 }
404
405 static inline DocHost *impl_from_IOleCommandTarget(IOleCommandTarget *iface)
406 {
407     return CONTAINING_RECORD(iface, DocHost, IOleCommandTarget_iface);
408 }
409
410 static HRESULT WINAPI ClOleCommandTarget_QueryInterface(IOleCommandTarget *iface,
411         REFIID riid, void **ppv)
412 {
413     DocHost *This = impl_from_IOleCommandTarget(iface);
414     return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv);
415 }
416
417 static ULONG WINAPI ClOleCommandTarget_AddRef(IOleCommandTarget *iface)
418 {
419     DocHost *This = impl_from_IOleCommandTarget(iface);
420     return IOleClientSite_AddRef(&This->IOleClientSite_iface);
421 }
422
423 static ULONG WINAPI ClOleCommandTarget_Release(IOleCommandTarget *iface)
424 {
425     DocHost *This = impl_from_IOleCommandTarget(iface);
426     return IOleClientSite_Release(&This->IOleClientSite_iface);
427 }
428
429 static HRESULT WINAPI ClOleCommandTarget_QueryStatus(IOleCommandTarget *iface,
430         const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText)
431 {
432     DocHost *This = impl_from_IOleCommandTarget(iface);
433     ULONG i= 0;
434     FIXME("(%p)->(%s %u %p %p)\n", This, debugstr_guid(pguidCmdGroup), cCmds, prgCmds,
435           pCmdText);
436     while (prgCmds && (cCmds > i)) {
437         FIXME("command_%u: %u, 0x%x\n", i, prgCmds[i].cmdID, prgCmds[i].cmdf);
438         i++;
439     }
440     return E_NOTIMPL;
441 }
442
443 static HRESULT WINAPI ClOleCommandTarget_Exec(IOleCommandTarget *iface,
444         const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn,
445         VARIANT *pvaOut)
446 {
447     DocHost *This = impl_from_IOleCommandTarget(iface);
448
449     TRACE("(%p)->(%s %d %d %p %p)\n", This, debugstr_guid(pguidCmdGroup), nCmdID,
450           nCmdexecopt, debugstr_variant(pvaIn), debugstr_variant(pvaOut));
451
452     if(!pguidCmdGroup) {
453         switch(nCmdID) {
454         case OLECMDID_UPDATECOMMANDS:
455             return This->container_vtbl->exec(This, pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
456         default:
457             FIXME("Unimplemented cmdid %d\n", nCmdID);
458             return E_NOTIMPL;
459         }
460         return S_OK;
461     }
462
463     if(IsEqualGUID(pguidCmdGroup, &CGID_DocHostCmdPriv)) {
464         switch(nCmdID) {
465         case DOCHOST_DOCCANNAVIGATE:
466             if(!pvaIn || V_VT(pvaIn) != VT_UNKNOWN)
467                 return E_INVALIDARG;
468
469             if(This->doc_navigate)
470                 IUnknown_Release(This->doc_navigate);
471             IUnknown_AddRef(V_UNKNOWN(pvaIn));
472             This->doc_navigate = V_UNKNOWN(pvaIn);
473             return S_OK;
474
475         default:
476             FIXME("unsupported command %d of CGID_DocHostCmdPriv\n", nCmdID);
477             return E_NOTIMPL;
478         }
479     }
480
481     FIXME("Unimplemented group %s\n", debugstr_guid(pguidCmdGroup));
482     return E_NOTIMPL;
483 }
484
485 #undef impl_from_IOleCommandTarget
486
487 static const IOleCommandTargetVtbl OleCommandTargetVtbl = {
488     ClOleCommandTarget_QueryInterface,
489     ClOleCommandTarget_AddRef,
490     ClOleCommandTarget_Release,
491     ClOleCommandTarget_QueryStatus,
492     ClOleCommandTarget_Exec
493 };
494
495 static inline DocHost *impl_from_IDocHostUIHandler2(IDocHostUIHandler2 *iface)
496 {
497     return CONTAINING_RECORD(iface, DocHost, IDocHostUIHandler2_iface);
498 }
499
500 static HRESULT WINAPI DocHostUIHandler_QueryInterface(IDocHostUIHandler2 *iface,
501                                                       REFIID riid, void **ppv)
502 {
503     DocHost *This = impl_from_IDocHostUIHandler2(iface);
504     return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv);
505 }
506
507 static ULONG WINAPI DocHostUIHandler_AddRef(IDocHostUIHandler2 *iface)
508 {
509     DocHost *This = impl_from_IDocHostUIHandler2(iface);
510     return IOleClientSite_AddRef(&This->IOleClientSite_iface);
511 }
512
513 static ULONG WINAPI DocHostUIHandler_Release(IDocHostUIHandler2 *iface)
514 {
515     DocHost *This = impl_from_IDocHostUIHandler2(iface);
516     return IOleClientSite_Release(&This->IOleClientSite_iface);
517 }
518
519 static HRESULT WINAPI DocHostUIHandler_ShowContextMenu(IDocHostUIHandler2 *iface,
520          DWORD dwID, POINT *ppt, IUnknown *pcmdtReserved, IDispatch *pdispReserved)
521 {
522     DocHost *This = impl_from_IDocHostUIHandler2(iface);
523     HRESULT hres;
524
525     TRACE("(%p)->(%d %p %p %p)\n", This, dwID, ppt, pcmdtReserved, pdispReserved);
526
527     if(This->hostui) {
528         hres = IDocHostUIHandler_ShowContextMenu(This->hostui, dwID, ppt, pcmdtReserved,
529                                                  pdispReserved);
530         if(hres == S_OK)
531             return S_OK;
532     }
533
534     FIXME("default action not implemented\n");
535     return E_NOTIMPL;
536 }
537
538 static HRESULT WINAPI DocHostUIHandler_GetHostInfo(IDocHostUIHandler2 *iface,
539         DOCHOSTUIINFO *pInfo)
540 {
541     DocHost *This = impl_from_IDocHostUIHandler2(iface);
542     HRESULT hres;
543
544     TRACE("(%p)->(%p)\n", This, pInfo);
545
546     if(This->hostui) {
547         hres = IDocHostUIHandler_GetHostInfo(This->hostui, pInfo);
548         if(SUCCEEDED(hres))
549             return hres;
550     }
551
552     pInfo->dwFlags = DOCHOSTUIFLAG_DISABLE_HELP_MENU | DOCHOSTUIFLAG_OPENNEWWIN
553         | DOCHOSTUIFLAG_URL_ENCODING_ENABLE_UTF8 | DOCHOSTUIFLAG_ENABLE_INPLACE_NAVIGATION
554         | DOCHOSTUIFLAG_IME_ENABLE_RECONVERSION;
555     return S_OK;
556 }
557
558 static HRESULT WINAPI DocHostUIHandler_ShowUI(IDocHostUIHandler2 *iface, DWORD dwID,
559         IOleInPlaceActiveObject *pActiveObject, IOleCommandTarget *pCommandTarget,
560         IOleInPlaceFrame *pFrame, IOleInPlaceUIWindow *pDoc)
561 {
562     DocHost *This = impl_from_IDocHostUIHandler2(iface);
563     FIXME("(%p)->(%d %p %p %p %p)\n", This, dwID, pActiveObject, pCommandTarget,
564           pFrame, pDoc);
565     return E_NOTIMPL;
566 }
567
568 static HRESULT WINAPI DocHostUIHandler_HideUI(IDocHostUIHandler2 *iface)
569 {
570     DocHost *This = impl_from_IDocHostUIHandler2(iface);
571     FIXME("(%p)\n", This);
572     return E_NOTIMPL;
573 }
574
575 static HRESULT WINAPI DocHostUIHandler_UpdateUI(IDocHostUIHandler2 *iface)
576 {
577     DocHost *This = impl_from_IDocHostUIHandler2(iface);
578
579     TRACE("(%p)\n", This);
580
581     if(!This->hostui)
582         return S_FALSE;
583
584     return IDocHostUIHandler_UpdateUI(This->hostui);
585 }
586
587 static HRESULT WINAPI DocHostUIHandler_EnableModeless(IDocHostUIHandler2 *iface,
588                                                       BOOL fEnable)
589 {
590     DocHost *This = impl_from_IDocHostUIHandler2(iface);
591     FIXME("(%p)->(%x)\n", This, fEnable);
592     return E_NOTIMPL;
593 }
594
595 static HRESULT WINAPI DocHostUIHandler_OnDocWindowActivate(IDocHostUIHandler2 *iface,
596                                                            BOOL fActivate)
597 {
598     DocHost *This = impl_from_IDocHostUIHandler2(iface);
599     FIXME("(%p)->(%x)\n", This, fActivate);
600     return E_NOTIMPL;
601 }
602
603 static HRESULT WINAPI DocHostUIHandler_OnFrameWindowActivate(IDocHostUIHandler2 *iface,
604                                                              BOOL fActivate)
605 {
606     DocHost *This = impl_from_IDocHostUIHandler2(iface);
607     FIXME("(%p)->(%x)\n", This, fActivate);
608     return E_NOTIMPL;
609 }
610
611 static HRESULT WINAPI DocHostUIHandler_ResizeBorder(IDocHostUIHandler2 *iface,
612         LPCRECT prcBorder, IOleInPlaceUIWindow *pUIWindow, BOOL fRameWindow)
613 {
614     DocHost *This = impl_from_IDocHostUIHandler2(iface);
615     FIXME("(%p)->(%p %p %X)\n", This, prcBorder, pUIWindow, fRameWindow);
616     return E_NOTIMPL;
617 }
618
619 static HRESULT WINAPI DocHostUIHandler_TranslateAccelerator(IDocHostUIHandler2 *iface,
620         LPMSG lpMsg, const GUID *pguidCmdGroup, DWORD nCmdID)
621 {
622     DocHost *This = impl_from_IDocHostUIHandler2(iface);
623     HRESULT hr = S_FALSE;
624     TRACE("(%p)->(%p %p %d)\n", This, lpMsg, pguidCmdGroup, nCmdID);
625
626     if(This->hostui)
627         hr = IDocHostUIHandler_TranslateAccelerator(This->hostui, lpMsg, pguidCmdGroup, nCmdID);
628
629     return hr;
630 }
631
632 static HRESULT WINAPI DocHostUIHandler_GetOptionKeyPath(IDocHostUIHandler2 *iface,
633         LPOLESTR *pchKey, DWORD dw)
634 {
635     DocHost *This = impl_from_IDocHostUIHandler2(iface);
636
637     TRACE("(%p)->(%p %d)\n", This, pchKey, dw);
638
639     if(This->hostui)
640         return IDocHostUIHandler_GetOptionKeyPath(This->hostui, pchKey, dw);
641
642     return S_OK;
643 }
644
645 static HRESULT WINAPI DocHostUIHandler_GetDropTarget(IDocHostUIHandler2 *iface,
646         IDropTarget *pDropTarget, IDropTarget **ppDropTarget)
647 {
648     DocHost *This = impl_from_IDocHostUIHandler2(iface);
649     FIXME("(%p)\n", This);
650     return E_NOTIMPL;
651 }
652
653 static HRESULT WINAPI DocHostUIHandler_GetExternal(IDocHostUIHandler2 *iface,
654         IDispatch **ppDispatch)
655 {
656     DocHost *This = impl_from_IDocHostUIHandler2(iface);
657
658     TRACE("(%p)->(%p)\n", This, ppDispatch);
659
660     if(This->hostui)
661         return IDocHostUIHandler_GetExternal(This->hostui, ppDispatch);
662
663     FIXME("default action not implemented\n");
664     return E_NOTIMPL;
665 }
666
667 static HRESULT WINAPI DocHostUIHandler_TranslateUrl(IDocHostUIHandler2 *iface,
668         DWORD dwTranslate, OLECHAR *pchURLIn, OLECHAR **ppchURLOut)
669 {
670     DocHost *This = impl_from_IDocHostUIHandler2(iface);
671
672     TRACE("(%p)->(%d %s %p)\n", This, dwTranslate, debugstr_w(pchURLIn), ppchURLOut);
673
674     if(This->hostui)
675         return IDocHostUIHandler_TranslateUrl(This->hostui, dwTranslate,
676                                               pchURLIn, ppchURLOut);
677
678     return S_FALSE;
679 }
680
681 static HRESULT WINAPI DocHostUIHandler_FilterDataObject(IDocHostUIHandler2 *iface,
682         IDataObject *pDO, IDataObject **ppDORet)
683 {
684     DocHost *This = impl_from_IDocHostUIHandler2(iface);
685     FIXME("(%p)->(%p %p)\n", This, pDO, ppDORet);
686     return E_NOTIMPL;
687 }
688
689 static HRESULT WINAPI DocHostUIHandler_GetOverrideKeyPath(IDocHostUIHandler2 *iface,
690         LPOLESTR *pchKey, DWORD dw)
691 {
692     DocHost *This = impl_from_IDocHostUIHandler2(iface);
693     IDocHostUIHandler2 *handler;
694     HRESULT hres;
695
696     TRACE("(%p)->(%p %d)\n", This, pchKey, dw);
697
698     if(!This->hostui)
699         return S_OK;
700
701     hres = IDocHostUIHandler_QueryInterface(This->hostui, &IID_IDocHostUIHandler2,
702                                             (void**)&handler);
703     if(SUCCEEDED(hres)) {
704         hres = IDocHostUIHandler2_GetOverrideKeyPath(handler, pchKey, dw);
705         IDocHostUIHandler2_Release(handler);
706         return hres;
707     }
708
709     return S_OK;
710 }
711
712 static const IDocHostUIHandler2Vtbl DocHostUIHandler2Vtbl = {
713     DocHostUIHandler_QueryInterface,
714     DocHostUIHandler_AddRef,
715     DocHostUIHandler_Release,
716     DocHostUIHandler_ShowContextMenu,
717     DocHostUIHandler_GetHostInfo,
718     DocHostUIHandler_ShowUI,
719     DocHostUIHandler_HideUI,
720     DocHostUIHandler_UpdateUI,
721     DocHostUIHandler_EnableModeless,
722     DocHostUIHandler_OnDocWindowActivate,
723     DocHostUIHandler_OnFrameWindowActivate,
724     DocHostUIHandler_ResizeBorder,
725     DocHostUIHandler_TranslateAccelerator,
726     DocHostUIHandler_GetOptionKeyPath,
727     DocHostUIHandler_GetDropTarget,
728     DocHostUIHandler_GetExternal,
729     DocHostUIHandler_TranslateUrl,
730     DocHostUIHandler_FilterDataObject,
731     DocHostUIHandler_GetOverrideKeyPath
732 };
733
734 static inline DocHost *impl_from_IPropertyNotifySink(IPropertyNotifySink *iface)
735 {
736     return CONTAINING_RECORD(iface, DocHost, IPropertyNotifySink_iface);
737 }
738
739 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
740         REFIID riid, void **ppv)
741 {
742     DocHost *This = impl_from_IPropertyNotifySink(iface);
743     return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv);
744 }
745
746 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
747 {
748     DocHost *This = impl_from_IPropertyNotifySink(iface);
749     return IOleClientSite_AddRef(&This->IOleClientSite_iface);
750 }
751
752 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
753 {
754     DocHost *This = impl_from_IPropertyNotifySink(iface);
755     return IOleClientSite_Release(&This->IOleClientSite_iface);
756 }
757
758 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
759 {
760     DocHost *This = impl_from_IPropertyNotifySink(iface);
761
762     TRACE("(%p)->(%d)\n", This, dispID);
763
764     switch(dispID) {
765     case DISPID_READYSTATE: {
766         READYSTATE ready_state;
767         HRESULT hres;
768
769         hres = get_doc_ready_state(This, &ready_state);
770         if(FAILED(hres))
771             return hres;
772
773         if(ready_state == READYSTATE_COMPLETE && !This->doc_navigate)
774             advise_prop_notif(This, FALSE);
775
776         push_ready_state_task(This, ready_state);
777         break;
778     }
779     default:
780         FIXME("unimplemented dispid %d\n", dispID);
781         return E_NOTIMPL;
782     }
783
784     return S_OK;
785 }
786
787 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
788 {
789     DocHost *This = impl_from_IPropertyNotifySink(iface);
790     FIXME("(%p)->(%d)\n", This, dispID);
791     return E_NOTIMPL;
792 }
793
794 static const IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
795     PropertyNotifySink_QueryInterface,
796     PropertyNotifySink_AddRef,
797     PropertyNotifySink_Release,
798     PropertyNotifySink_OnChanged,
799     PropertyNotifySink_OnRequestEdit
800 };
801
802 void DocHost_Init(DocHost *This, IDispatch *disp, const IDocHostContainerVtbl* container)
803 {
804     This->IDocHostUIHandler2_iface.lpVtbl  = &DocHostUIHandler2Vtbl;
805     This->IOleCommandTarget_iface.lpVtbl   = &OleCommandTargetVtbl;
806     This->IPropertyNotifySink_iface.lpVtbl = &PropertyNotifySinkVtbl;
807
808     This->disp = disp;
809     This->container_vtbl = container;
810
811     This->ready_state = READYSTATE_UNINITIALIZED;
812
813     DocHost_ClientSite_Init(This);
814     DocHost_Frame_Init(This);
815
816     ConnectionPointContainer_Init(&This->cps, (IUnknown*)disp);
817 }
818
819 void DocHost_Release(DocHost *This)
820 {
821     release_dochost_client(This);
822     DocHost_ClientSite_Release(This);
823
824     ConnectionPointContainer_Destroy(&This->cps);
825
826     heap_free(This->url);
827 }