?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ws2_32/tests: Add some tests for opening the Afd device.
[wine.git] / dlls / mshtml / pluginhost.c
blobd880cc89a9d5eaa72776e60705e8b118b1b2492b
1 /*
2 * Copyright 2010 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 #include <assert.h>
21
22 #define COBJMACROS
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winuser.h"
27 #include "ole2.h"
28 #include "shlobj.h"
29 #include "mshtmdid.h"
30
31 #include "mshtml_private.h"
32 #include "pluginhost.h"
33
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
37
38 typedef struct {
39 IPropertyBag IPropertyBag_iface;
40 IPropertyBag2 IPropertyBag2_iface;
41
42 LONG ref;
43
44 struct list props;
45 } PropertyBag;
46
47 typedef struct {
48 struct list entry;
49 WCHAR *name;
50 WCHAR *value;
51 } param_prop_t;
52
53 static void free_prop(param_prop_t *prop)
54 {
55 list_remove(&prop->entry);
56
57 heap_free(prop->name);
58 heap_free(prop->value);
59 heap_free(prop);
60 }
61
62 static param_prop_t *find_prop(PropertyBag *prop_bag, const WCHAR *name)
63 {
64 param_prop_t *iter;
65
66 LIST_FOR_EACH_ENTRY(iter, &prop_bag->props, param_prop_t, entry) {
67 if(!wcsicmp(iter->name, name))
68 return iter;
69 }
70
71 return NULL;
72 }
73
74 static HRESULT add_prop(PropertyBag *prop_bag, const WCHAR *name, const WCHAR *value)
75 {
76 param_prop_t *prop;
77
78 if(!name || !value)
79 return S_OK;
80
81 TRACE("%p %s %s\n", prop_bag, debugstr_w(name), debugstr_w(value));
82
83 prop = heap_alloc(sizeof(*prop));
84 if(!prop)
85 return E_OUTOFMEMORY;
86
87 prop->name = heap_strdupW(name);
88 prop->value = heap_strdupW(value);
89 if(!prop->name || !prop->value) {
90 list_init(&prop->entry);
91 free_prop(prop);
92 return E_OUTOFMEMORY;
93 }
94
95 list_add_tail(&prop_bag->props, &prop->entry);
96 return S_OK;
97 }
98
99 static inline PropertyBag *impl_from_IPropertyBag(IPropertyBag *iface)
100 {
101 return CONTAINING_RECORD(iface, PropertyBag, IPropertyBag_iface);
102 }
103
104 static HRESULT WINAPI PropertyBag_QueryInterface(IPropertyBag *iface, REFIID riid, void **ppv)
105 {
106 PropertyBag *This = impl_from_IPropertyBag(iface);
107
108 if(IsEqualGUID(&IID_IUnknown, riid)) {
109 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
110 *ppv = &This->IPropertyBag_iface;
111 }else if(IsEqualGUID(&IID_IPropertyBag, riid)) {
112 TRACE("(%p)->(IID_IPropertyBag %p)\n", This, ppv);
113 *ppv = &This->IPropertyBag_iface;
114 }else if(IsEqualGUID(&IID_IPropertyBag2, riid)) {
115 TRACE("(%p)->(IID_IPropertyBag2 %p)\n", This, ppv);
116 *ppv = &This->IPropertyBag2_iface;
117 }else {
118 WARN("Unsopported interface %s\n", debugstr_guid(riid));
119 *ppv = NULL;
120 return E_NOINTERFACE;
121 }
122
123 IUnknown_AddRef((IUnknown*)*ppv);
124 return S_OK;
125 }
126
127 static ULONG WINAPI PropertyBag_AddRef(IPropertyBag *iface)
128 {
129 PropertyBag *This = impl_from_IPropertyBag(iface);
130 LONG ref = InterlockedIncrement(&This->ref);
131
132 TRACE("(%p) ref=%d\n", This, ref);
133
134 return ref;
135 }
136
137 static ULONG WINAPI PropertyBag_Release(IPropertyBag *iface)
138 {
139 PropertyBag *This = impl_from_IPropertyBag(iface);
140 LONG ref = InterlockedDecrement(&This->ref);
141
142 TRACE("(%p) ref=%d\n", This, ref);
143
144 if(!ref) {
145 while(!list_empty(&This->props))
146 free_prop(LIST_ENTRY(This->props.next, param_prop_t, entry));
147 heap_free(This);
148 }
149
150 return ref;
151 }
152
153 static HRESULT WINAPI PropertyBag_Read(IPropertyBag *iface, LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog)
154 {
155 PropertyBag *This = impl_from_IPropertyBag(iface);
156 param_prop_t *prop;
157 VARIANT v;
158
159 TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(pszPropName), pVar, pErrorLog);
160
161 prop = find_prop(This, pszPropName);
162 if(!prop) {
163 TRACE("Not found\n");
164 return E_INVALIDARG;
165 }
166
167 V_BSTR(&v) = SysAllocString(prop->value);
168 if(!V_BSTR(&v))
169 return E_OUTOFMEMORY;
170
171 if(V_VT(pVar) != VT_BSTR) {
172 HRESULT hres;
173
174 V_VT(&v) = VT_BSTR;
175 hres = VariantChangeType(pVar, &v, 0, V_VT(pVar));
176 SysFreeString(V_BSTR(&v));
177 return hres;
178 }
179
180 V_BSTR(pVar) = V_BSTR(&v);
181 return S_OK;
182 }
183
184 static HRESULT WINAPI PropertyBag_Write(IPropertyBag *iface, LPCOLESTR pszPropName, VARIANT *pVar)
185 {
186 PropertyBag *This = impl_from_IPropertyBag(iface);
187 FIXME("(%p)->(%s %s)\n", This, debugstr_w(pszPropName), debugstr_variant(pVar));
188 return E_NOTIMPL;
189 }
190
191 static const IPropertyBagVtbl PropertyBagVtbl = {
192 PropertyBag_QueryInterface,
193 PropertyBag_AddRef,
194 PropertyBag_Release,
195 PropertyBag_Read,
196 PropertyBag_Write
197 };
198
199 static inline PropertyBag *impl_from_IPropertyBag2(IPropertyBag2 *iface)
200 {
201 return CONTAINING_RECORD(iface, PropertyBag, IPropertyBag2_iface);
202 }
203
204 static HRESULT WINAPI PropertyBag2_QueryInterface(IPropertyBag2 *iface, REFIID riid, void **ppv)
205 {
206 PropertyBag *This = impl_from_IPropertyBag2(iface);
207 return IPropertyBag_QueryInterface(&This->IPropertyBag_iface, riid, ppv);
208 }
209
210 static ULONG WINAPI PropertyBag2_AddRef(IPropertyBag2 *iface)
211 {
212 PropertyBag *This = impl_from_IPropertyBag2(iface);
213 return IPropertyBag_AddRef(&This->IPropertyBag_iface);
214 }
215
216 static ULONG WINAPI PropertyBag2_Release(IPropertyBag2 *iface)
217 {
218 PropertyBag *This = impl_from_IPropertyBag2(iface);
219 return IPropertyBag_Release(&This->IPropertyBag_iface);
220 }
221
222 static HRESULT WINAPI PropertyBag2_Read(IPropertyBag2 *iface, ULONG cProperties, PROPBAG2 *pPropBag,
223 IErrorLog *pErrLog, VARIANT *pvarValue, HRESULT *phrError)
224 {
225 PropertyBag *This = impl_from_IPropertyBag2(iface);
226 FIXME("(%p)->(%d %p %p %p %p)\n", This, cProperties, pPropBag, pErrLog, pvarValue, phrError);
227 return E_NOTIMPL;
228 }
229
230 static HRESULT WINAPI PropertyBag2_Write(IPropertyBag2 *iface, ULONG cProperties, PROPBAG2 *pPropBag, VARIANT *pvarValue)
231 {
232 PropertyBag *This = impl_from_IPropertyBag2(iface);
233 FIXME("(%p)->(%d %p %s)\n", This, cProperties, pPropBag, debugstr_variant(pvarValue));
234 return E_NOTIMPL;
235 }
236
237 static HRESULT WINAPI PropertyBag2_CountProperties(IPropertyBag2 *iface, ULONG *pcProperties)
238 {
239 PropertyBag *This = impl_from_IPropertyBag2(iface);
240 FIXME("(%p)->(%p)\n", This, pcProperties);
241 return E_NOTIMPL;
242 }
243
244 static HRESULT WINAPI PropertyBag2_GetPropertyInfo(IPropertyBag2 *iface, ULONG iProperty, ULONG cProperties,
245 PROPBAG2 *pPropBag, ULONG *pcProperties)
246 {
247 PropertyBag *This = impl_from_IPropertyBag2(iface);
248 FIXME("(%p)->(%u %u %p %p)\n", This, iProperty, cProperties, pPropBag, pcProperties);
249 return E_NOTIMPL;
250 }
251
252 static HRESULT WINAPI PropertyBag2_LoadObject(IPropertyBag2 *iface, LPCOLESTR pstrName, DWORD dwHint,
253 IUnknown *pUnkObject, IErrorLog *pErrLog)
254 {
255 PropertyBag *This = impl_from_IPropertyBag2(iface);
256 FIXME("(%p)->(%s %x %p %p)\n", This, debugstr_w(pstrName), dwHint, pUnkObject, pErrLog);
257 return E_NOTIMPL;
258 }
259
260 static const IPropertyBag2Vtbl PropertyBag2Vtbl = {
261 PropertyBag2_QueryInterface,
262 PropertyBag2_AddRef,
263 PropertyBag2_Release,
264 PropertyBag2_Read,
265 PropertyBag2_Write,
266 PropertyBag2_CountProperties,
267 PropertyBag2_GetPropertyInfo,
268 PropertyBag2_LoadObject
269 };
270
271 static HRESULT fill_props(nsIDOMElement *nselem, PropertyBag *prop_bag)
272 {
273 const PRUnichar *name, *value;
274 nsAString name_str, value_str;
275 nsIDOMHTMLCollection *params;
276 nsIDOMElement *param_elem;
277 UINT32 length, i;
278 nsIDOMNode *nsnode;
279 nsresult nsres;
280 HRESULT hres = S_OK;
281
282 nsAString_InitDepend(&name_str, L"param");
283 nsres = nsIDOMElement_GetElementsByTagName(nselem, &name_str, &params);
284 nsAString_Finish(&name_str);
285 if(NS_FAILED(nsres))
286 return E_FAIL;
287
288 nsres = nsIDOMHTMLCollection_GetLength(params, &length);
289 if(NS_FAILED(nsres))
290 length = 0;
291
292 for(i=0; i < length; i++) {
293 nsres = nsIDOMHTMLCollection_Item(params, i, &nsnode);
294 if(NS_FAILED(nsres)) {
295 hres = E_FAIL;
296 break;
297 }
298
299 nsres = nsIDOMNode_QueryInterface(nsnode, &IID_nsIDOMElement, (void**)&param_elem);
300 nsIDOMNode_Release(nsnode);
301 if(NS_FAILED(nsres)) {
302 hres = E_FAIL;
303 break;
304 }
305
306 nsres = get_elem_attr_value(param_elem, L"name", &name_str, &name);
307 if(NS_SUCCEEDED(nsres)) {
308 nsres = get_elem_attr_value(param_elem, L"value", &value_str, &value);
309 if(NS_SUCCEEDED(nsres)) {
310 hres = add_prop(prop_bag, name, value);
311 nsAString_Finish(&value_str);
312 }
313
314 nsAString_Finish(&name_str);
315 }
316
317 nsIDOMElement_Release(param_elem);
318 if(FAILED(hres))
319 break;
320 if(NS_FAILED(nsres)) {
321 hres = E_FAIL;
322 break;
323 }
324 }
325
326 nsIDOMHTMLCollection_Release(params);
327 return hres;
328 }
329
330 static HRESULT create_param_prop_bag(nsIDOMElement *nselem, IPropertyBag **ret)
331 {
332 PropertyBag *prop_bag;
333 HRESULT hres;
334
335 prop_bag = heap_alloc(sizeof(*prop_bag));
336 if(!prop_bag)
337 return E_OUTOFMEMORY;
338
339 prop_bag->IPropertyBag_iface.lpVtbl = &PropertyBagVtbl;
340 prop_bag->IPropertyBag2_iface.lpVtbl = &PropertyBag2Vtbl;
341 prop_bag->ref = 1;
342
343 list_init(&prop_bag->props);
344 hres = fill_props(nselem, prop_bag);
345 if(FAILED(hres) || list_empty(&prop_bag->props)) {
346 IPropertyBag_Release(&prop_bag->IPropertyBag_iface);
347 *ret = NULL;
348 return hres;
349 }
350
351 *ret = &prop_bag->IPropertyBag_iface;
352 return S_OK;
353 }
354
355 static BOOL check_load_safety(PluginHost *host)
356 {
357 DWORD policy_size, policy;
358 struct CONFIRMSAFETY cs;
359 BYTE *ppolicy;
360 HRESULT hres;
361
362 cs.clsid = host->clsid;
363 cs.pUnk = host->plugin_unk;
364 cs.dwFlags = CONFIRMSAFETYACTION_LOADOBJECT;
365
366 hres = IInternetHostSecurityManager_QueryCustomPolicy(&host->doc->IInternetHostSecurityManager_iface,
367 &GUID_CUSTOM_CONFIRMOBJECTSAFETY, &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
368 if(FAILED(hres))
369 return FALSE;
370
371 policy = *(DWORD*)ppolicy;
372 CoTaskMemFree(ppolicy);
373 return policy == URLPOLICY_ALLOW;
374 }
375
376 static BOOL check_script_safety(PluginHost *host)
377 {
378 DISPPARAMS params = {NULL,NULL,0,0};
379 DWORD policy_size, policy;
380 struct CONFIRMSAFETY cs;
381 BYTE *ppolicy;
382 ULONG err = 0;
383 VARIANT v;
384 HRESULT hres;
385
386 cs.clsid = host->clsid;
387 cs.pUnk = host->plugin_unk;
388 cs.dwFlags = 0;
389
390 hres = IInternetHostSecurityManager_QueryCustomPolicy(&host->doc->IInternetHostSecurityManager_iface,
391 &GUID_CUSTOM_CONFIRMOBJECTSAFETY, &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
392 if(FAILED(hres))
393 return FALSE;
394
395 policy = *(DWORD*)ppolicy;
396 CoTaskMemFree(ppolicy);
397
398 if(policy != URLPOLICY_ALLOW)
399 return FALSE;
400
401 V_VT(&v) = VT_EMPTY;
402 hres = IDispatch_Invoke(host->disp, DISPID_SECURITYCTX, &IID_NULL, 0, DISPATCH_PROPERTYGET, &params, &v, NULL, &err);
403 if(SUCCEEDED(hres)) {
404 FIXME("Handle security ctx %s\n", debugstr_variant(&v));
405 return FALSE;
406 }
407
408 return TRUE;
409 }
410
411 static void update_readystate(PluginHost *host)
412 {
413 DISPPARAMS params = {NULL,NULL,0,0};
414 IDispatchEx *dispex;
415 IDispatch *disp;
416 ULONG err = 0;
417 VARIANT v;
418 HRESULT hres;
419
420 hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IDispatchEx, (void**)&dispex);
421 if(SUCCEEDED(hres)) {
422 FIXME("Use IDispatchEx\n");
423 IDispatchEx_Release(dispex);
424 }
425
426 hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IDispatch, (void**)&disp);
427 if(FAILED(hres))
428 return;
429
430 hres = IDispatch_Invoke(disp, DISPID_READYSTATE, &IID_NULL, 0, DISPATCH_PROPERTYGET, &params, &v, NULL, &err);
431 IDispatch_Release(disp);
432 if(SUCCEEDED(hres)) {
433 /* FIXME: make plugin readystate affect document readystate */
434 TRACE("readystate = %s\n", debugstr_variant(&v));
435 VariantClear(&v);
436 }
437 }
438
439 /* FIXME: We shouldn't need this function and we should embed plugin directly in the main document */
440 static void get_pos_rect(PluginHost *host, RECT *ret)
441 {
442 SetRect(ret, 0, 0, host->rect.right - host->rect.left, host->rect.bottom - host->rect.top);
443 }
444
445 static void load_prop_bag(PluginHost *host, IPersistPropertyBag *persist_prop_bag)
446 {
447 IPropertyBag *prop_bag;
448 HRESULT hres;
449
450 hres = create_param_prop_bag(host->element->element.dom_element, &prop_bag);
451 if(FAILED(hres))
452 return;
453
454 if(prop_bag && !check_load_safety(host)) {
455 IPropertyBag_Release(prop_bag);
456 prop_bag = NULL;
457 }
458
459 if(prop_bag) {
460 hres = IPersistPropertyBag_Load(persist_prop_bag, prop_bag, NULL);
461 IPropertyBag_Release(prop_bag);
462 if(FAILED(hres))
463 WARN("Load failed: %08x\n", hres);
464 }else {
465 hres = IPersistPropertyBag_InitNew(persist_prop_bag);
466 if(FAILED(hres))
467 WARN("InitNew failed: %08x\n", hres);
468 }
469 }
470
471 static void load_plugin(PluginHost *host)
472 {
473 IPersistPropertyBag2 *persist_prop_bag2;
474 IPersistPropertyBag *persist_prop_bag;
475 HRESULT hres;
476
477 hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IPersistPropertyBag2, (void**)&persist_prop_bag2);
478 if(SUCCEEDED(hres)) {
479 FIXME("Use IPersistPropertyBag2 iface\n");
480 IPersistPropertyBag2_Release(persist_prop_bag2);
481 return;
482 }
483
484 hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IPersistPropertyBag, (void**)&persist_prop_bag);
485 if(SUCCEEDED(hres)) {
486 load_prop_bag(host, persist_prop_bag);
487 IPersistPropertyBag_Release(persist_prop_bag);
488 return;
489 }
490
491 FIXME("No IPersistPropertyBag iface\n");
492 }
493
494 static void initialize_plugin_object(PluginHost *host)
495 {
496 IClientSecurity *client_security;
497 IQuickActivate *quick_activate;
498 IOleObject *ole_obj = NULL;
499 IOleCommandTarget *cmdtrg;
500 IViewObjectEx *view_obj;
501 IDispatchEx *dispex;
502 IDispatch *disp;
503 HRESULT hres;
504
505 /* Note native calls QI on plugin for an undocumented IID and CLSID_HTMLDocument */
506
507 /* FIXME: call FreezeEvents(TRUE) */
508
509 hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IClientSecurity, (void**)&client_security);
510 if(SUCCEEDED(hres)) {
511 FIXME("Handle IClientSecurity\n");
512 IClientSecurity_Release(client_security);
513 return;
514 }
515
516 hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IQuickActivate, (void**)&quick_activate);
517 if(SUCCEEDED(hres)) {
518 QACONTAINER container = {sizeof(container)};
519 QACONTROL control = {sizeof(control)};
520
521 TRACE("Using IQuickActivate\n");
522
523 container.pClientSite = &host->IOleClientSite_iface;
524 container.dwAmbientFlags = QACONTAINER_SUPPORTSMNEMONICS|QACONTAINER_MESSAGEREFLECT|QACONTAINER_USERMODE;
525 container.pAdviseSink = &host->IAdviseSinkEx_iface;
526 container.pPropertyNotifySink = &host->IPropertyNotifySink_iface;
527
528 hres = IQuickActivate_QuickActivate(quick_activate, &container, &control);
529 IQuickActivate_Release(quick_activate);
530 if(FAILED(hres))
531 FIXME("QuickActivate failed: %08x\n", hres);
532 }else {
533 DWORD status = 0;
534
535 hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IOleObject, (void**)&ole_obj);
536 if(SUCCEEDED(hres)) {
537 hres = IOleObject_GetMiscStatus(ole_obj, DVASPECT_CONTENT, &status);
538 TRACE("GetMiscStatus returned %08x %x\n", hres, status);
539
540 hres = IOleObject_SetClientSite(ole_obj, &host->IOleClientSite_iface);
541 IOleObject_Release(ole_obj);
542 if(FAILED(hres)) {
543 FIXME("SetClientSite failed: %08x\n", hres);
544 return;
545 }
546 }else {
547 TRACE("Plugin does not support IOleObject\n");
548 }
549 }
550
551 load_plugin(host);
552
553 if(ole_obj) {
554 hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IViewObjectEx, (void**)&view_obj);
555 if(SUCCEEDED(hres)) {
556 DWORD view_status = 0;
557
558 hres = IViewObjectEx_SetAdvise(view_obj, DVASPECT_CONTENT, 0, (IAdviseSink*)&host->IAdviseSinkEx_iface);
559 if(FAILED(hres))
560 WARN("SetAdvise failed: %08x\n", hres);
561
562 hres = IViewObjectEx_GetViewStatus(view_obj, &view_status);
563 IViewObjectEx_Release(view_obj);
564 TRACE("GetViewStatus returned %08x %x\n", hres, view_status);
565 }
566 }
567
568 update_readystate(host);
569
570 /* NOTE: Native QIs for IActiveScript, an undocumented IID, IOleControl and IRunnableObject */
571
572 hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IDispatchEx, (void**)&dispex);
573 if(SUCCEEDED(hres)) {
574 FIXME("Use IDispatchEx\n");
575 host->disp = (IDispatch*)dispex;
576 }else {
577 hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IDispatch, (void**)&disp);
578 if(SUCCEEDED(hres))
579 host->disp = disp;
580 else
581 TRACE("no IDispatch iface\n");
582 }
583
584 hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
585 if(SUCCEEDED(hres)) {
586 FIXME("Use IOleCommandTarget\n");
587 IOleCommandTarget_Release(cmdtrg);
588 }
589 }
590
591 static void embed_plugin_object(PluginHost *host)
592 {
593 IOleObject *ole_obj;
594 RECT rect;
595 HRESULT hres;
596
597 hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IOleObject, (void**)&ole_obj);
598 if(FAILED(hres)) {
599 FIXME("Plugin does not support IOleObject\n");
600 return;
601 }
602
603 get_pos_rect(host, &rect);
604 hres = IOleObject_DoVerb(ole_obj, OLEIVERB_INPLACEACTIVATE, NULL, &host->IOleClientSite_iface, 0, host->hwnd, &rect);
605 IOleObject_Release(ole_obj);
606 if(FAILED(hres))
607 WARN("DoVerb failed: %08x\n", hres);
608
609 if(host->ip_object) {
610 HWND hwnd;
611
612 hres = IOleInPlaceObject_GetWindow(host->ip_object, &hwnd);
613 if(SUCCEEDED(hres))
614 TRACE("hwnd %p\n", hwnd);
615 }
616 }
617
618 void update_plugin_window(PluginHost *host, HWND hwnd, const RECT *rect)
619 {
620 BOOL rect_changed = FALSE;
621
622 if(!hwnd || (host->hwnd && host->hwnd != hwnd)) {
623 FIXME("unhandled hwnd\n");
624 return;
625 }
626
627 TRACE("%p %s\n", hwnd, wine_dbgstr_rect(rect));
628
629 if(!EqualRect(rect, &host->rect)) {
630 host->rect = *rect;
631 rect_changed = TRUE;
632 }
633
634 if(!host->hwnd) {
635 host->hwnd = hwnd;
636 embed_plugin_object(host);
637 }
638
639 if(rect_changed && host->ip_object)
640 IOleInPlaceObject_SetObjectRects(host->ip_object, &host->rect, &host->rect);
641 }
642
643 static void notif_enabled(PluginHost *plugin_host)
644 {
645 DISPPARAMS args = {NULL, NULL, 0, 0};
646 IDispatch *disp;
647 ULONG err = 0;
648 VARIANT res;
649 HRESULT hres;
650
651 hres = IUnknown_QueryInterface(plugin_host->plugin_unk, &IID_IDispatch, (void**)&disp);
652 if(FAILED(hres)) {
653 FIXME("Could not get IDispatch iface: %08x\n", hres);
654 return;
655 }
656
657 V_VT(&res) = VT_EMPTY;
658 hres = IDispatch_Invoke(disp, DISPID_ENABLED, &IID_NULL, 0/*FIXME*/, DISPATCH_PROPERTYGET, &args, &res, NULL, &err);
659 IDispatch_Release(disp);
660 if(SUCCEEDED(hres)) {
661 FIXME("Got enabled %s\n", debugstr_variant(&res));
662 VariantClear(&res);
663 }
664 }
665
666 void notif_container_change(HTMLPluginContainer *plugin_container, DISPID dispid)
667 {
668 IOleControl *ole_control;
669 HRESULT hres;
670
671 if(!plugin_container->plugin_host || !plugin_container->plugin_host->plugin_unk)
672 return;
673
674 notif_enabled(plugin_container->plugin_host);
675
676 hres = IUnknown_QueryInterface(plugin_container->plugin_host->plugin_unk, &IID_IOleControl, (void**)&ole_control);
677 if(SUCCEEDED(hres)) {
678 IOleControl_OnAmbientPropertyChange(ole_control, dispid);
679 IOleControl_Release(ole_control);
680 }
681 }
682
683 HRESULT get_plugin_disp(HTMLPluginContainer *plugin_container, IDispatch **ret)
684 {
685 PluginHost *host;
686
687 host = plugin_container->plugin_host;
688 if(!host) {
689 ERR("No plugin host\n");
690 return E_UNEXPECTED;
691 }
692
693 if(!host->disp) {
694 *ret = NULL;
695 return S_OK;
696 }
697
698 if(!check_script_safety(host)) {
699 FIXME("Insecure object\n");
700 return E_FAIL;
701 }
702
703 IDispatch_AddRef(host->disp);
704 *ret = host->disp;
705 return S_OK;
706 }
707
708 HRESULT get_plugin_dispid(HTMLPluginContainer *plugin_container, WCHAR *name, DISPID *ret)
709 {
710 IDispatch *disp;
711 DISPID id;
712 DWORD i;
713 HRESULT hres;
714
715 if(!plugin_container->plugin_host) {
716 WARN("no plugin host\n");
717 return DISP_E_UNKNOWNNAME;
718 }
719
720 disp = plugin_container->plugin_host->disp;
721 if(!disp)
722 return DISP_E_UNKNOWNNAME;
723
724 hres = IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, &id);
725 if(FAILED(hres)) {
726 TRACE("no prop %s\n", debugstr_w(name));
727 return DISP_E_UNKNOWNNAME;
728 }
729
730 for(i=0; i < plugin_container->props_len; i++) {
731 if(id == plugin_container->props[i]) {
732 *ret = MSHTML_DISPID_CUSTOM_MIN+i;
733 return S_OK;
734 }
735 }
736
737 if(!plugin_container->props) {
738 plugin_container->props = heap_alloc(8*sizeof(DISPID));
739 if(!plugin_container->props)
740 return E_OUTOFMEMORY;
741 plugin_container->props_size = 8;
742 }else if(plugin_container->props_len == plugin_container->props_size) {
743 DISPID *new_props;
744
745 new_props = heap_realloc(plugin_container->props, plugin_container->props_size*2*sizeof(DISPID));
746 if(!new_props)
747 return E_OUTOFMEMORY;
748
749 plugin_container->props = new_props;
750 plugin_container->props_size *= 2;
751 }
752
753 plugin_container->props[plugin_container->props_len] = id;
754 *ret = MSHTML_DISPID_CUSTOM_MIN+plugin_container->props_len;
755 plugin_container->props_len++;
756 return S_OK;
757 }
758
759 HRESULT invoke_plugin_prop(HTMLPluginContainer *plugin_container, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
760 VARIANT *res, EXCEPINFO *ei)
761 {
762 PluginHost *host;
763
764 host = plugin_container->plugin_host;
765 if(!host || !host->disp) {
766 FIXME("Called with no disp\n");
767 return E_UNEXPECTED;
768 }
769
770 if(!check_script_safety(host)) {
771 FIXME("Insecure object\n");
772 return E_FAIL;
773 }
774
775 if(id < MSHTML_DISPID_CUSTOM_MIN || id > MSHTML_DISPID_CUSTOM_MIN + plugin_container->props_len) {
776 ERR("Invalid id\n");
777 return E_FAIL;
778 }
779
780 return IDispatch_Invoke(host->disp, plugin_container->props[id-MSHTML_DISPID_CUSTOM_MIN], &IID_NULL,
781 lcid, flags, params, res, ei, NULL);
782 }
783
784 typedef struct {
785 DISPID id;
786 IDispatch *disp;
787 } sink_entry_t;
788
789 struct PHEventSink {
790 IDispatch IDispatch_iface;
791
792 LONG ref;
793
794 PluginHost *host;
795 ITypeInfo *typeinfo;
796 GUID iid;
797 DWORD cookie;
798 BOOL is_dispiface;
799
800 sink_entry_t *handlers;
801 DWORD handlers_cnt;
802 DWORD handlers_size;
803 };
804
805 static sink_entry_t *find_sink_entry(PHEventSink *sink, DISPID id)
806 {
807 sink_entry_t *iter;
808
809 for(iter = sink->handlers; iter < sink->handlers+sink->handlers_cnt; iter++) {
810 if(iter->id == id)
811 return iter;
812 }
813
814 return NULL;
815 }
816
817 static void add_sink_handler(PHEventSink *sink, DISPID id, IDispatch *disp)
818 {
819 sink_entry_t *entry = find_sink_entry(sink, id);
820
821 if(entry) {
822 if(entry->disp)
823 IDispatch_Release(entry->disp);
824 }else {
825 if(!sink->handlers_size) {
826 sink->handlers = heap_alloc(4*sizeof(*sink->handlers));
827 if(!sink->handlers)
828 return;
829 sink->handlers_size = 4;
830 }else if(sink->handlers_cnt == sink->handlers_size) {
831 sink_entry_t *new_handlers;
832
833 new_handlers = heap_realloc(sink->handlers, 2*sink->handlers_size*sizeof(*sink->handlers));
834 if(!new_handlers)
835 return;
836 sink->handlers = new_handlers;
837 sink->handlers_size *= 2;
838 }
839 entry = sink->handlers + sink->handlers_cnt++;
840 entry->id = id;
841 }
842
843 IDispatch_AddRef(disp);
844 entry->disp = disp;
845 }
846
847 static inline PHEventSink *PHEventSink_from_IDispatch(IDispatch *iface)
848 {
849 return CONTAINING_RECORD(iface, PHEventSink, IDispatch_iface);
850 }
851
852 static HRESULT WINAPI PHEventSink_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
853 {
854 PHEventSink *This = PHEventSink_from_IDispatch(iface);
855
856 if(IsEqualGUID(riid, &IID_IUnknown)) {
857 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
858 *ppv = &This->IDispatch_iface;
859 }else if(IsEqualGUID(riid, &IID_IDispatch)) {
860 TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
861 *ppv = &This->IDispatch_iface;
862 }else if(This->is_dispiface && IsEqualGUID(riid, &This->iid)) {
863 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
864 *ppv = &This->IDispatch_iface;
865 }else {
866 WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
867 *ppv = NULL;
868 return E_NOINTERFACE;
869 }
870
871 IUnknown_AddRef((IUnknown*)*ppv);
872 return S_OK;
873 }
874
875 static ULONG WINAPI PHEventSink_AddRef(IDispatch *iface)
876 {
877 PHEventSink *This = PHEventSink_from_IDispatch(iface);
878 LONG ref = InterlockedIncrement(&This->ref);
879
880 TRACE("(%p)\n", This);
881
882 return ref;
883 }
884
885 static ULONG WINAPI PHEventSink_Release(IDispatch *iface)
886 {
887 PHEventSink *This = PHEventSink_from_IDispatch(iface);
888 LONG ref = InterlockedDecrement(&This->ref);
889
890 TRACE("(%p)\n", This);
891
892 if(!ref) {
893 unsigned i;
894
895 assert(!This->host);
896
897 for(i=0; i < This->handlers_cnt; i++) {
898 if(This->handlers[i].disp)
899 IDispatch_Release(This->handlers[i].disp);
900 }
901 heap_free(This->handlers);
902 heap_free(This);
903 }
904
905 return ref;
906 }
907
908 static HRESULT WINAPI PHEventSink_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
909 {
910 PHEventSink *This = PHEventSink_from_IDispatch(iface);
911 FIXME("(%p)->(%p)\n", This, pctinfo);
912 return E_NOTIMPL;
913 }
914
915 static HRESULT WINAPI PHEventSink_GetTypeInfo(IDispatch *iface, UINT iTInfo,
916 LCID lcid, ITypeInfo **ppTInfo)
917 {
918 PHEventSink *This = PHEventSink_from_IDispatch(iface);
919 FIXME("(%p)->(%d %d %p)\n", This, iTInfo, lcid, ppTInfo);
920 return E_NOTIMPL;
921 }
922
923 static HRESULT WINAPI PHEventSink_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames,
924 UINT cNames, LCID lcid, DISPID *rgDispId)
925 {
926 PHEventSink *This = PHEventSink_from_IDispatch(iface);
927 FIXME("(%p)->(%s %p %u %d %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
928 return E_NOTIMPL;
929 }
930
931 static HRESULT WINAPI PHEventSink_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
932 WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
933 {
934 PHEventSink *This = PHEventSink_from_IDispatch(iface);
935 IDispatchEx *dispex;
936 sink_entry_t *entry;
937 HRESULT hres;
938
939 TRACE("(%p)->(%d %s %d %x %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid), lcid, wFlags,
940 pDispParams, pVarResult, pExcepInfo, puArgErr);
941
942 if(!This->host) {
943 WARN("No host\n");
944 return E_UNEXPECTED;
945 }
946
947 entry = find_sink_entry(This, dispIdMember);
948 if(!entry || !entry->disp) {
949 WARN("No handler %d\n", dispIdMember);
950 if(pVarResult)
951 V_VT(pVarResult) = VT_EMPTY;
952 return S_OK;
953 }
954
955 hres = IDispatch_QueryInterface(entry->disp, &IID_IDispatchEx, (void**)&dispex);
956
957 TRACE("(%p) %d >>>\n", This, entry->id);
958 if(SUCCEEDED(hres)) {
959 hres = IDispatchEx_InvokeEx(dispex, DISPID_VALUE, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, NULL);
960 IDispatchEx_Release(dispex);
961 }else {
962 hres = IDispatch_Invoke(entry->disp, DISPID_VALUE, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
963 }
964 if(SUCCEEDED(hres))
965 TRACE("(%p) %d <<<\n", This, entry->id);
966 else
967 WARN("(%p) %d <<< %08x\n", This, entry->id, hres);
968 return hres;
969 }
970
971 static const IDispatchVtbl PHCPDispatchVtbl = {
972 PHEventSink_QueryInterface,
973 PHEventSink_AddRef,
974 PHEventSink_Release,
975 PHEventSink_GetTypeInfoCount,
976 PHEventSink_GetTypeInfo,
977 PHEventSink_GetIDsOfNames,
978 PHEventSink_Invoke
979 };
980
981 static PHEventSink *create_event_sink(PluginHost *plugin_host, ITypeInfo *typeinfo)
982 {
983 IConnectionPointContainer *cp_container;
984 PHEventSink *ret;
985 IConnectionPoint *cp;
986 TYPEATTR *typeattr;
987 TYPEKIND typekind;
988 GUID guid;
989 HRESULT hres;
990
991 hres = ITypeInfo_GetTypeAttr(typeinfo, &typeattr);
992 if(FAILED(hres))
993 return NULL;
994
995 typekind = typeattr->typekind;
996 guid = typeattr->guid;
997 ITypeInfo_ReleaseTypeAttr(typeinfo, typeattr);
998
999 TRACE("guid %s typekind %d\n", debugstr_guid(&guid), typekind);
1000
1001 if(typekind != TKIND_INTERFACE && typekind != TKIND_DISPATCH) {
1002 WARN("invalid typekind %d\n", typekind);
1003 return NULL;
1004 }
1005
1006 hres = IUnknown_QueryInterface(plugin_host->plugin_unk, &IID_IConnectionPointContainer, (void**)&cp_container);
1007 if(FAILED(hres)) {
1008 WARN("Could not get IConnectionPointContainer iface: %08x\n", hres);
1009 return NULL;
1010 }
1011
1012 hres = IConnectionPointContainer_FindConnectionPoint(cp_container, &guid, &cp);
1013 IConnectionPointContainer_Release(cp_container);
1014 if(FAILED(hres)) {
1015 WARN("Could not find %s connection point\n", debugstr_guid(&guid));
1016 return NULL;
1017 }
1018
1019 ret = heap_alloc_zero(sizeof(*ret));
1020 if(ret) {
1021 ret->IDispatch_iface.lpVtbl = &PHCPDispatchVtbl;
1022 ret->ref = 1;
1023 ret->host = plugin_host;
1024 ret->iid = guid;
1025 ret->is_dispiface = typekind == TKIND_DISPATCH;
1026
1027 ITypeInfo_AddRef(typeinfo);
1028 ret->typeinfo = typeinfo;
1029
1030 hres = IConnectionPoint_Advise(cp, (IUnknown*)&ret->IDispatch_iface, &ret->cookie);
1031 }else {
1032 hres = E_OUTOFMEMORY;
1033 }
1034
1035 IConnectionPoint_Release(cp);
1036 if(FAILED(hres)) {
1037 WARN("Advise failed: %08x\n", hres);
1038 return NULL;
1039 }
1040
1041 return ret;
1042 }
1043
1044 static ITypeInfo *get_eventiface_info(HTMLPluginContainer *plugin_container, ITypeInfo *class_info)
1045 {
1046 int impl_types, i, impl_flags;
1047 ITypeInfo *ret = NULL;
1048 TYPEATTR *typeattr;
1049 HREFTYPE ref;
1050 HRESULT hres;
1051
1052 hres = ITypeInfo_GetTypeAttr(class_info, &typeattr);
1053 if(FAILED(hres))
1054 return NULL;
1055
1056 if(typeattr->typekind != TKIND_COCLASS) {
1057 WARN("not coclass\n");
1058 ITypeInfo_ReleaseTypeAttr(class_info, typeattr);
1059 return NULL;
1060 }
1061
1062 impl_types = typeattr->cImplTypes;
1063 ITypeInfo_ReleaseTypeAttr(class_info, typeattr);
1064
1065 for(i=0; i<impl_types; i++) {
1066 hres = ITypeInfo_GetImplTypeFlags(class_info, i, &impl_flags);
1067 if(FAILED(hres))
1068 continue;
1069
1070 if((impl_flags & IMPLTYPEFLAG_FSOURCE)) {
1071 if(!(impl_flags & IMPLTYPEFLAG_FDEFAULT)) {
1072 FIXME("Handle non-default source iface\n");
1073 continue;
1074 }
1075
1076 hres = ITypeInfo_GetRefTypeOfImplType(class_info, i, &ref);
1077 if(FAILED(hres))
1078 continue;
1079
1080 hres = ITypeInfo_GetRefTypeInfo(class_info, ref, &ret);
1081 if(FAILED(hres))
1082 ret = NULL;
1083 }
1084 }
1085
1086 return ret;
1087 }
1088
1089 void bind_activex_event(HTMLDocumentNode *doc, HTMLPluginContainer *plugin_container, WCHAR *event, IDispatch *disp)
1090 {
1091 PluginHost *plugin_host = plugin_container->plugin_host;
1092 ITypeInfo *class_info, *source_info;
1093 DISPID id;
1094 HRESULT hres;
1095
1096 TRACE("(%p %p %s %p)\n", doc, plugin_host, debugstr_w(event), disp);
1097
1098 if(!plugin_host || !plugin_host->plugin_unk) {
1099 WARN("detached element %p\n", plugin_host);
1100 return;
1101 }
1102
1103 if(plugin_host->sink) {
1104 source_info = plugin_host->sink->typeinfo;
1105 ITypeInfo_AddRef(source_info);
1106 }else {
1107 IProvideClassInfo *provide_ci;
1108
1109 hres = IUnknown_QueryInterface(plugin_host->plugin_unk, &IID_IProvideClassInfo, (void**)&provide_ci);
1110 if(FAILED(hres)) {
1111 FIXME("No IProvideClassInfo, try GetTypeInfo?\n");
1112 return;
1113 }
1114
1115 hres = IProvideClassInfo_GetClassInfo(provide_ci, &class_info);
1116 IProvideClassInfo_Release(provide_ci);
1117 if(FAILED(hres) || !class_info) {
1118 WARN("GetClassInfo failed: %08x\n", hres);
1119 return;
1120 }
1121
1122 source_info = get_eventiface_info(plugin_container, class_info);
1123 ITypeInfo_Release(class_info);
1124 if(!source_info)
1125 return;
1126 }
1127
1128 hres = ITypeInfo_GetIDsOfNames(source_info, &event, 1, &id);
1129 if(FAILED(hres))
1130 WARN("Could not get disp id: %08x\n", hres);
1131 else if(!plugin_host->sink)
1132 plugin_host->sink = create_event_sink(plugin_host, source_info);
1133
1134 ITypeInfo_Release(source_info);
1135 if(FAILED(hres) || !plugin_host->sink)
1136 return;
1137
1138 add_sink_handler(plugin_host->sink, id, disp);
1139 }
1140
1141 typedef struct {
1142 IOleInPlaceFrame IOleInPlaceFrame_iface;
1143 LONG ref;
1144 } InPlaceFrame;
1145
1146 static inline InPlaceFrame *impl_from_IOleInPlaceFrame(IOleInPlaceFrame *iface)
1147 {
1148 return CONTAINING_RECORD(iface, InPlaceFrame, IOleInPlaceFrame_iface);
1149 }
1150
1151 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface,
1152 REFIID riid, void **ppv)
1153 {
1154 InPlaceFrame *This = impl_from_IOleInPlaceFrame(iface);
1155
1156 TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1157
1158 if(IsEqualGUID(&IID_IUnknown, riid)) {
1159 *ppv = &This->IOleInPlaceFrame_iface;
1160 }else if(IsEqualGUID(&IID_IOleWindow, riid)) {
1161 *ppv = &This->IOleInPlaceFrame_iface;
1162 }else if(IsEqualGUID(&IID_IOleInPlaceUIWindow, riid)) {
1163 *ppv = &This->IOleInPlaceFrame_iface;
1164 }else if(IsEqualGUID(&IID_IOleInPlaceFrame, riid)) {
1165 *ppv = &This->IOleInPlaceFrame_iface;
1166 }else {
1167 WARN("Unsopported interface %s\n", debugstr_mshtml_guid(riid));
1168 *ppv = NULL;
1169 return E_NOINTERFACE;
1170 }
1171
1172 IUnknown_AddRef((IUnknown*)*ppv);
1173 return S_OK;
1174 }
1175
1176 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
1177 {
1178 InPlaceFrame *This = impl_from_IOleInPlaceFrame(iface);
1179 LONG ref = InterlockedIncrement(&This->ref);
1180
1181 TRACE("(%p) ref=%d\n", This, ref);
1182
1183 return ref;
1184 }
1185
1186 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
1187 {
1188 InPlaceFrame *This = impl_from_IOleInPlaceFrame(iface);
1189 LONG ref = InterlockedDecrement(&This->ref);
1190
1191 TRACE("(%p) ref=%d\n", This, ref);
1192
1193 if(!ref)
1194 heap_free(This);
1195
1196 return ref;
1197 }
1198
1199 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
1200 {
1201 InPlaceFrame *This = impl_from_IOleInPlaceFrame(iface);
1202 FIXME("(%p)->(%p)\n", This, phwnd);
1203 return E_NOTIMPL;
1204 }
1205
1206 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface,
1207 BOOL fEnterMode)
1208 {
1209 InPlaceFrame *This = impl_from_IOleInPlaceFrame(iface);
1210 FIXME("(%p)->(%x)\n", This, fEnterMode);
1211 return E_NOTIMPL;
1212 }
1213
1214 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
1215 {
1216 InPlaceFrame *This = impl_from_IOleInPlaceFrame(iface);
1217 FIXME("(%p)->(%p)\n", This, lprectBorder);
1218 return E_NOTIMPL;
1219 }
1220
1221 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
1222 LPCBORDERWIDTHS pborderwidths)
1223 {
1224 InPlaceFrame *This = impl_from_IOleInPlaceFrame(iface);
1225 FIXME("(%p)->(%p)\n", This, pborderwidths);
1226 return E_NOTIMPL;
1227 }
1228
1229 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
1230 LPCBORDERWIDTHS pborderwidths)
1231 {
1232 InPlaceFrame *This = impl_from_IOleInPlaceFrame(iface);
1233 FIXME("(%p)->(%p)\n", This, pborderwidths);
1234 return E_NOTIMPL;
1235 }
1236
1237 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
1238 IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1239 {
1240 InPlaceFrame *This = impl_from_IOleInPlaceFrame(iface);
1241 FIXME("(%p)->(%p %s)\n", This, pActiveObject, debugstr_w(pszObjName));
1242 return E_NOTIMPL;
1243 }
1244
1245 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
1246 LPOLEMENUGROUPWIDTHS lpMenuWidths)
1247 {
1248 InPlaceFrame *This = impl_from_IOleInPlaceFrame(iface);
1249 FIXME("(%p)->(%p %p)\n", This, hmenuShared, lpMenuWidths);
1250 return E_NOTIMPL;
1251 }
1252
1253 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
1254 HOLEMENU holemenu, HWND hwndActiveObject)
1255 {
1256 InPlaceFrame *This = impl_from_IOleInPlaceFrame(iface);
1257 FIXME("(%p)->(%p %p %p)\n", This, hmenuShared, holemenu, hwndActiveObject);
1258 return E_NOTIMPL;
1259 }
1260
1261 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
1262 {
1263 InPlaceFrame *This = impl_from_IOleInPlaceFrame(iface);
1264 FIXME("(%p)->(%p)\n", This, hmenuShared);
1265 return E_NOTIMPL;
1266 }
1267
1268 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface,
1269 LPCOLESTR pszStatusText)
1270 {
1271 InPlaceFrame *This = impl_from_IOleInPlaceFrame(iface);
1272 FIXME("(%p)->(%s)\n", This, debugstr_w(pszStatusText));
1273 return E_NOTIMPL;
1274 }
1275
1276 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
1277 {
1278 InPlaceFrame *This = impl_from_IOleInPlaceFrame(iface);
1279 FIXME("(%p)->(%x)\n", This, fEnable);
1280 return E_NOTIMPL;
1281 }
1282
1283 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg,
1284 WORD wID)
1285 {
1286 InPlaceFrame *This = impl_from_IOleInPlaceFrame(iface);
1287 FIXME("(%p)->(%p %d)\n", This, lpmsg, wID);
1288 return E_NOTIMPL;
1289 }
1290
1291 static const IOleInPlaceFrameVtbl OleInPlaceFrameVtbl = {
1292 InPlaceFrame_QueryInterface,
1293 InPlaceFrame_AddRef,
1294 InPlaceFrame_Release,
1295 InPlaceFrame_GetWindow,
1296 InPlaceFrame_ContextSensitiveHelp,
1297 InPlaceFrame_GetBorder,
1298 InPlaceFrame_RequestBorderSpace,
1299 InPlaceFrame_SetBorderSpace,
1300 InPlaceFrame_SetActiveObject,
1301 InPlaceFrame_InsertMenus,
1302 InPlaceFrame_SetMenu,
1303 InPlaceFrame_RemoveMenus,
1304 InPlaceFrame_SetStatusText,
1305 InPlaceFrame_EnableModeless,
1306 InPlaceFrame_TranslateAccelerator
1307 };
1308
1309 static HRESULT create_ip_frame(IOleInPlaceFrame **ret)
1310 {
1311 InPlaceFrame *frame;
1312
1313 frame = heap_alloc_zero(sizeof(*frame));
1314 if(!frame)
1315 return E_OUTOFMEMORY;
1316
1317 frame->IOleInPlaceFrame_iface.lpVtbl = &OleInPlaceFrameVtbl;
1318 frame->ref = 1;
1319
1320 *ret = &frame->IOleInPlaceFrame_iface;
1321 return S_OK;
1322 }
1323
1324 typedef struct {
1325 IOleInPlaceUIWindow IOleInPlaceUIWindow_iface;
1326 LONG ref;
1327 } InPlaceUIWindow;
1328
1329 static inline InPlaceUIWindow *impl_from_IOleInPlaceUIWindow(IOleInPlaceUIWindow *iface)
1330 {
1331 return CONTAINING_RECORD(iface, InPlaceUIWindow, IOleInPlaceUIWindow_iface);
1332 }
1333
1334 static HRESULT WINAPI InPlaceUIWindow_QueryInterface(IOleInPlaceUIWindow *iface, REFIID riid, void **ppv)
1335 {
1336 InPlaceUIWindow *This = impl_from_IOleInPlaceUIWindow(iface);
1337
1338 TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1339
1340 if(IsEqualGUID(&IID_IUnknown, riid)) {
1341 *ppv = &This->IOleInPlaceUIWindow_iface;
1342 }else if(IsEqualGUID(&IID_IOleWindow, riid)) {
1343 *ppv = &This->IOleInPlaceUIWindow_iface;
1344 }else if(IsEqualGUID(&IID_IOleInPlaceUIWindow, riid)) {
1345 *ppv = &This->IOleInPlaceUIWindow_iface;
1346 }else {
1347 WARN("Unsopported interface %s\n", debugstr_mshtml_guid(riid));
1348 *ppv = NULL;
1349 return E_NOINTERFACE;
1350 }
1351
1352 IUnknown_AddRef((IUnknown*)*ppv);
1353 return S_OK;
1354 }
1355
1356 static ULONG WINAPI InPlaceUIWindow_AddRef(IOleInPlaceUIWindow *iface)
1357 {
1358 InPlaceUIWindow *This = impl_from_IOleInPlaceUIWindow(iface);
1359 LONG ref = InterlockedIncrement(&This->ref);
1360
1361 TRACE("(%p) ref=%d\n", This, ref);
1362
1363 return ref;
1364 }
1365
1366 static ULONG WINAPI InPlaceUIWindow_Release(IOleInPlaceUIWindow *iface)
1367 {
1368 InPlaceUIWindow *This = impl_from_IOleInPlaceUIWindow(iface);
1369 LONG ref = InterlockedDecrement(&This->ref);
1370
1371 TRACE("(%p) ref=%d\n", This, ref);
1372
1373 if(!ref)
1374 heap_free(This);
1375
1376 return ref;
1377 }
1378
1379 static HRESULT WINAPI InPlaceUIWindow_GetWindow(IOleInPlaceUIWindow *iface, HWND *phwnd)
1380 {
1381 InPlaceUIWindow *This = impl_from_IOleInPlaceUIWindow(iface);
1382 FIXME("(%p)->(%p)\n", This, phwnd);
1383 return E_NOTIMPL;
1384 }
1385
1386 static HRESULT WINAPI InPlaceUIWindow_ContextSensitiveHelp(IOleInPlaceUIWindow *iface,
1387 BOOL fEnterMode)
1388 {
1389 InPlaceUIWindow *This = impl_from_IOleInPlaceUIWindow(iface);
1390 FIXME("(%p)->(%x)\n", This, fEnterMode);
1391 return E_NOTIMPL;
1392 }
1393
1394 static HRESULT WINAPI InPlaceUIWindow_GetBorder(IOleInPlaceUIWindow *iface, LPRECT lprectBorder)
1395 {
1396 InPlaceUIWindow *This = impl_from_IOleInPlaceUIWindow(iface);
1397 FIXME("(%p)->(%p)\n", This, lprectBorder);
1398 return E_NOTIMPL;
1399 }
1400
1401 static HRESULT WINAPI InPlaceUIWindow_RequestBorderSpace(IOleInPlaceUIWindow *iface,
1402 LPCBORDERWIDTHS pborderwidths)
1403 {
1404 InPlaceUIWindow *This = impl_from_IOleInPlaceUIWindow(iface);
1405 FIXME("(%p)->(%p)\n", This, pborderwidths);
1406 return E_NOTIMPL;
1407 }
1408
1409 static HRESULT WINAPI InPlaceUIWindow_SetBorderSpace(IOleInPlaceUIWindow *iface,
1410 LPCBORDERWIDTHS pborderwidths)
1411 {
1412 InPlaceUIWindow *This = impl_from_IOleInPlaceUIWindow(iface);
1413 FIXME("(%p)->(%p)\n", This, pborderwidths);
1414 return E_NOTIMPL;
1415 }
1416
1417 static HRESULT WINAPI InPlaceUIWindow_SetActiveObject(IOleInPlaceUIWindow *iface,
1418 IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1419 {
1420 InPlaceUIWindow *This = impl_from_IOleInPlaceUIWindow(iface);
1421 FIXME("(%p)->(%p %s)\n", This, pActiveObject, debugstr_w(pszObjName));
1422 return E_NOTIMPL;
1423 }
1424
1425 static const IOleInPlaceUIWindowVtbl OleInPlaceUIWindowVtbl = {
1426 InPlaceUIWindow_QueryInterface,
1427 InPlaceUIWindow_AddRef,
1428 InPlaceUIWindow_Release,
1429 InPlaceUIWindow_GetWindow,
1430 InPlaceUIWindow_ContextSensitiveHelp,
1431 InPlaceUIWindow_GetBorder,
1432 InPlaceUIWindow_RequestBorderSpace,
1433 InPlaceUIWindow_SetBorderSpace,
1434 InPlaceUIWindow_SetActiveObject,
1435 };
1436
1437 static HRESULT create_ip_window(IOleInPlaceUIWindow **ret)
1438 {
1439 InPlaceUIWindow *uiwindow;
1440
1441 uiwindow = heap_alloc_zero(sizeof(*uiwindow));
1442 if(!uiwindow)
1443 return E_OUTOFMEMORY;
1444
1445 uiwindow->IOleInPlaceUIWindow_iface.lpVtbl = &OleInPlaceUIWindowVtbl;
1446 uiwindow->ref = 1;
1447
1448 *ret = &uiwindow->IOleInPlaceUIWindow_iface;
1449 return S_OK;
1450 }
1451
1452 static inline PluginHost *impl_from_IOleClientSite(IOleClientSite *iface)
1453 {
1454 return CONTAINING_RECORD(iface, PluginHost, IOleClientSite_iface);
1455 }
1456
1457 static HRESULT WINAPI PHClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
1458 {
1459 PluginHost *This = impl_from_IOleClientSite(iface);
1460
1461 if(IsEqualGUID(&IID_IUnknown, riid)) {
1462 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
1463 *ppv = &This->IOleClientSite_iface;
1464 }else if(IsEqualGUID(&IID_IOleClientSite, riid)) {
1465 TRACE("(%p)->(IID_IOleClientSite %p)\n", This, ppv);
1466 *ppv = &This->IOleClientSite_iface;
1467 }else if(IsEqualGUID(&IID_IAdviseSink, riid)) {
1468 TRACE("(%p)->(IID_IAdviseSink %p)\n", This, ppv);
1469 *ppv = &This->IAdviseSinkEx_iface;
1470 }else if(IsEqualGUID(&IID_IAdviseSinkEx, riid)) {
1471 TRACE("(%p)->(IID_IAdviseSinkEx %p)\n", This, ppv);
1472 *ppv = &This->IAdviseSinkEx_iface;
1473 }else if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
1474 TRACE("(%p)->(IID_IPropertyNotifySink %p)\n", This, ppv);
1475 *ppv = &This->IPropertyNotifySink_iface;
1476 }else if(IsEqualGUID(&IID_IDispatch, riid)) {
1477 TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
1478 *ppv = &This->IDispatch_iface;
1479 }else if(IsEqualGUID(&IID_IOleWindow, riid)) {
1480 TRACE("(%p)->(IID_IOleWindow %p)\n", This, ppv);
1481 *ppv = &This->IOleInPlaceSiteEx_iface;
1482 }else if(IsEqualGUID(&IID_IOleInPlaceSite, riid)) {
1483 TRACE("(%p)->(IID_IOleInPlaceSite %p)\n", This, ppv);
1484 *ppv = &This->IOleInPlaceSiteEx_iface;
1485 }else if(IsEqualGUID(&IID_IOleInPlaceSiteEx, riid)) {
1486 TRACE("(%p)->(IID_IOleInPlaceSiteEx %p)\n", This, ppv);
1487 *ppv = &This->IOleInPlaceSiteEx_iface;
1488 }else if(IsEqualGUID(&IID_IOleControlSite, riid)) {
1489 TRACE("(%p)->(IID_IOleControlSite %p)\n", This, ppv);
1490 *ppv = &This->IOleControlSite_iface;
1491 }else if(IsEqualGUID(&IID_IBindHost, riid)) {
1492 TRACE("(%p)->(IID_IBindHost %p)\n", This, ppv);
1493 *ppv = &This->IBindHost_iface;
1494 }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
1495 TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv);
1496 *ppv = &This->IServiceProvider_iface;
1497 }else {
1498 WARN("Unsupported interface %s\n", debugstr_guid(riid));
1499 *ppv = NULL;
1500 return E_NOINTERFACE;
1501 }
1502
1503 IUnknown_AddRef((IUnknown*)*ppv);
1504 return S_OK;
1505 }
1506
1507 static ULONG WINAPI PHClientSite_AddRef(IOleClientSite *iface)
1508 {
1509 PluginHost *This = impl_from_IOleClientSite(iface);
1510 LONG ref = InterlockedIncrement(&This->ref);
1511
1512 TRACE("(%p) ref=%d\n", This, ref);
1513
1514 return ref;
1515 }
1516
1517 static void release_plugin_ifaces(PluginHost *This)
1518 {
1519 if(This->disp) {
1520 IDispatch_Release(This->disp);
1521 This->disp = NULL;
1522 }
1523
1524 if(This->ip_object) {
1525 IOleInPlaceObject_Release(This->ip_object);
1526 This->ip_object = NULL;
1527 }
1528
1529 if(This->plugin_unk) {
1530 IUnknown *unk = This->plugin_unk;
1531 LONG ref;
1532
1533 This->plugin_unk = NULL;
1534 ref = IUnknown_Release(unk);
1535
1536 TRACE("plugin ref = %d\n", ref);
1537 }
1538 }
1539
1540 static ULONG WINAPI PHClientSite_Release(IOleClientSite *iface)
1541 {
1542 PluginHost *This = impl_from_IOleClientSite(iface);
1543 LONG ref = InterlockedDecrement(&This->ref);
1544
1545 TRACE("(%p) ref=%d\n", This, ref);
1546
1547 if(!ref) {
1548 release_plugin_ifaces(This);
1549 if(This->sink) {
1550 This->sink->host = NULL;
1551 IDispatch_Release(&This->sink->IDispatch_iface);
1552 This->sink = NULL;
1553 }
1554 list_remove(&This->entry);
1555 if(This->element)
1556 This->element->plugin_host = NULL;
1557 heap_free(This);
1558 }
1559
1560 return ref;
1561 }
1562
1563 static HRESULT WINAPI PHClientSite_SaveObject(IOleClientSite *iface)
1564 {
1565 PluginHost *This = impl_from_IOleClientSite(iface);
1566 FIXME("(%p)\n", This);
1567 return E_NOTIMPL;
1568 }
1569
1570 static HRESULT WINAPI PHClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign,
1571 DWORD dwWhichMoniker, IMoniker **ppmk)
1572 {
1573 PluginHost *This = impl_from_IOleClientSite(iface);
1574
1575 TRACE("(%p)->(%d %d %p)\n", This, dwAssign, dwWhichMoniker, ppmk);
1576
1577 switch(dwWhichMoniker) {
1578 case OLEWHICHMK_CONTAINER:
1579 if(!This->doc || !This->doc->window || !This->doc->window->mon) {
1580 FIXME("no moniker\n");
1581 return E_UNEXPECTED;
1582 }
1583
1584 *ppmk = This->doc->window->mon;
1585 IMoniker_AddRef(*ppmk);
1586 break;
1587 default:
1588 FIXME("which %d\n", dwWhichMoniker);
1589 return E_NOTIMPL;
1590 }
1591
1592 return S_OK;
1593 }
1594
1595 static HRESULT WINAPI PHClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
1596 {
1597 PluginHost *This = impl_from_IOleClientSite(iface);
1598
1599 TRACE("(%p)->(%p)\n", This, ppContainer);
1600
1601 if(!This->doc) {
1602 ERR("Called on detached object\n");
1603 return E_UNEXPECTED;
1604 }
1605
1606 *ppContainer = &This->doc->basedoc.IOleContainer_iface;
1607 IOleContainer_AddRef(*ppContainer);
1608 return S_OK;
1609 }
1610
1611 static HRESULT WINAPI PHClientSite_ShowObject(IOleClientSite *iface)
1612 {
1613 PluginHost *This = impl_from_IOleClientSite(iface);
1614
1615 TRACE("(%p)\n", This);
1616
1617 return S_OK;
1618 }
1619
1620 static HRESULT WINAPI PHClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
1621 {
1622 PluginHost *This = impl_from_IOleClientSite(iface);
1623 FIXME("(%p)->(%x)\n", This, fShow);
1624 return E_NOTIMPL;
1625 }
1626
1627 static HRESULT WINAPI PHClientSite_RequestNewObjectLayout(IOleClientSite *iface)
1628 {
1629 PluginHost *This = impl_from_IOleClientSite(iface);
1630 FIXME("(%p)\n", This);
1631 return E_NOTIMPL;
1632 }
1633
1634 static const IOleClientSiteVtbl OleClientSiteVtbl = {
1635 PHClientSite_QueryInterface,
1636 PHClientSite_AddRef,
1637 PHClientSite_Release,
1638 PHClientSite_SaveObject,
1639 PHClientSite_GetMoniker,
1640 PHClientSite_GetContainer,
1641 PHClientSite_ShowObject,
1642 PHClientSite_OnShowWindow,
1643 PHClientSite_RequestNewObjectLayout
1644 };
1645
1646 static inline PluginHost *impl_from_IAdviseSinkEx(IAdviseSinkEx *iface)
1647 {
1648 return CONTAINING_RECORD(iface, PluginHost, IAdviseSinkEx_iface);
1649 }
1650
1651 static HRESULT WINAPI PHAdviseSinkEx_QueryInterface(IAdviseSinkEx *iface, REFIID riid, void **ppv)
1652 {
1653 PluginHost *This = impl_from_IAdviseSinkEx(iface);
1654 return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv);
1655 }
1656
1657 static ULONG WINAPI PHAdviseSinkEx_AddRef(IAdviseSinkEx *iface)
1658 {
1659 PluginHost *This = impl_from_IAdviseSinkEx(iface);
1660 return IOleClientSite_AddRef(&This->IOleClientSite_iface);
1661 }
1662
1663 static ULONG WINAPI PHAdviseSinkEx_Release(IAdviseSinkEx *iface)
1664 {
1665 PluginHost *This = impl_from_IAdviseSinkEx(iface);
1666 return IOleClientSite_Release(&This->IOleClientSite_iface);
1667 }
1668
1669 static void WINAPI PHAdviseSinkEx_OnDataChange(IAdviseSinkEx *iface, FORMATETC *pFormatetc, STGMEDIUM *pStgMedium)
1670 {
1671 PluginHost *This = impl_from_IAdviseSinkEx(iface);
1672 FIXME("(%p)->(%p %p)\n", This, pFormatetc, pStgMedium);
1673 }
1674
1675 static void WINAPI PHAdviseSinkEx_OnViewChange(IAdviseSinkEx *iface, DWORD dwAspect, LONG lindex)
1676 {
1677 PluginHost *This = impl_from_IAdviseSinkEx(iface);
1678 FIXME("(%p)->(%d %d)\n", This, dwAspect, lindex);
1679 }
1680
1681 static void WINAPI PHAdviseSinkEx_OnRename(IAdviseSinkEx *iface, IMoniker *pmk)
1682 {
1683 PluginHost *This = impl_from_IAdviseSinkEx(iface);
1684 FIXME("(%p)->(%p)\n", This, pmk);
1685 }
1686
1687 static void WINAPI PHAdviseSinkEx_OnSave(IAdviseSinkEx *iface)
1688 {
1689 PluginHost *This = impl_from_IAdviseSinkEx(iface);
1690 FIXME("(%p)\n", This);
1691 }
1692
1693 static void WINAPI PHAdviseSinkEx_OnClose(IAdviseSinkEx *iface)
1694 {
1695 PluginHost *This = impl_from_IAdviseSinkEx(iface);
1696 FIXME("(%p)\n", This);
1697 }
1698
1699 static void WINAPI PHAdviseSinkEx_OnViewStatusChange(IAdviseSinkEx *iface, DWORD dwViewStatus)
1700 {
1701 PluginHost *This = impl_from_IAdviseSinkEx(iface);
1702 FIXME("(%p)->(%d)\n", This, dwViewStatus);
1703 }
1704
1705 static const IAdviseSinkExVtbl AdviseSinkExVtbl = {
1706 PHAdviseSinkEx_QueryInterface,
1707 PHAdviseSinkEx_AddRef,
1708 PHAdviseSinkEx_Release,
1709 PHAdviseSinkEx_OnDataChange,
1710 PHAdviseSinkEx_OnViewChange,
1711 PHAdviseSinkEx_OnRename,
1712 PHAdviseSinkEx_OnSave,
1713 PHAdviseSinkEx_OnClose,
1714 PHAdviseSinkEx_OnViewStatusChange
1715 };
1716
1717 static inline PluginHost *impl_from_IPropertyNotifySink(IPropertyNotifySink *iface)
1718 {
1719 return CONTAINING_RECORD(iface, PluginHost, IPropertyNotifySink_iface);
1720 }
1721
1722 static HRESULT WINAPI PHPropertyNotifySink_QueryInterface(IPropertyNotifySink *iface, REFIID riid, void **ppv)
1723 {
1724 PluginHost *This = impl_from_IPropertyNotifySink(iface);
1725 return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv);
1726 }
1727
1728 static ULONG WINAPI PHPropertyNotifySink_AddRef(IPropertyNotifySink *iface)
1729 {
1730 PluginHost *This = impl_from_IPropertyNotifySink(iface);
1731 return IOleClientSite_AddRef(&This->IOleClientSite_iface);
1732 }
1733
1734 static ULONG WINAPI PHPropertyNotifySink_Release(IPropertyNotifySink *iface)
1735 {
1736 PluginHost *This = impl_from_IPropertyNotifySink(iface);
1737 return IOleClientSite_Release(&This->IOleClientSite_iface);
1738 }
1739
1740 static HRESULT WINAPI PHPropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
1741 {
1742 PluginHost *This = impl_from_IPropertyNotifySink(iface);
1743
1744 TRACE("(%p)->(%d)\n", This, dispID);
1745
1746 switch(dispID) {
1747 case DISPID_READYSTATE:
1748 update_readystate(This);
1749 break;
1750 default :
1751 FIXME("Unimplemented dispID %d\n", dispID);
1752 return E_NOTIMPL;
1753 }
1754
1755 return S_OK;
1756 }
1757
1758 static HRESULT WINAPI PHPropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
1759 {
1760 PluginHost *This = impl_from_IPropertyNotifySink(iface);
1761 FIXME("(%p)->(%d)\n", This, dispID);
1762 return E_NOTIMPL;
1763 }
1764
1765 static const IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
1766 PHPropertyNotifySink_QueryInterface,
1767 PHPropertyNotifySink_AddRef,
1768 PHPropertyNotifySink_Release,
1769 PHPropertyNotifySink_OnChanged,
1770 PHPropertyNotifySink_OnRequestEdit
1771 };
1772
1773 static inline PluginHost *impl_from_IDispatch(IDispatch *iface)
1774 {
1775 return CONTAINING_RECORD(iface, PluginHost, IDispatch_iface);
1776 }
1777
1778 static HRESULT WINAPI PHDispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
1779 {
1780 PluginHost *This = impl_from_IDispatch(iface);
1781 return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv);
1782 }
1783
1784 static ULONG WINAPI PHDispatch_AddRef(IDispatch *iface)
1785 {
1786 PluginHost *This = impl_from_IDispatch(iface);
1787 return IOleClientSite_AddRef(&This->IOleClientSite_iface);
1788 }
1789
1790 static ULONG WINAPI PHDispatch_Release(IDispatch *iface)
1791 {
1792 PluginHost *This = impl_from_IDispatch(iface);
1793 return IOleClientSite_Release(&This->IOleClientSite_iface);
1794 }
1795
1796 static HRESULT WINAPI PHDispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
1797 {
1798 PluginHost *This = impl_from_IDispatch(iface);
1799 FIXME("(%p)->(%p)\n", This, pctinfo);
1800 return E_NOTIMPL;
1801 }
1802
1803 static HRESULT WINAPI PHDispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo,
1804 LCID lcid, ITypeInfo **ppTInfo)
1805 {
1806 PluginHost *This = impl_from_IDispatch(iface);
1807 FIXME("(%p)->(%d %d %p)\n", This, iTInfo, lcid, ppTInfo);
1808 return E_NOTIMPL;
1809 }
1810
1811 static HRESULT WINAPI PHDispatch_GetIDsOfNames(IDispatch *iface, REFIID riid,
1812 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1813 {
1814 PluginHost *This = impl_from_IDispatch(iface);
1815 FIXME("(%p)->(%s %p %d %d %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
1816 return E_NOTIMPL;
1817 }
1818
1819 static HRESULT WINAPI PHDispatch_Invoke(IDispatch *iface, DISPID dispid, REFIID riid, LCID lcid,
1820 WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1821 {
1822 PluginHost *This = impl_from_IDispatch(iface);
1823 FIXME("(%p)->(%d %x %p %p)\n", This, dispid, wFlags, pDispParams, pVarResult);
1824 return E_NOTIMPL;
1825 }
1826
1827 static const IDispatchVtbl DispatchVtbl = {
1828 PHDispatch_QueryInterface,
1829 PHDispatch_AddRef,
1830 PHDispatch_Release,
1831 PHDispatch_GetTypeInfoCount,
1832 PHDispatch_GetTypeInfo,
1833 PHDispatch_GetIDsOfNames,
1834 PHDispatch_Invoke
1835 };
1836
1837 static inline PluginHost *impl_from_IOleInPlaceSiteEx(IOleInPlaceSiteEx *iface)
1838 {
1839 return CONTAINING_RECORD(iface, PluginHost, IOleInPlaceSiteEx_iface);
1840 }
1841
1842 static HRESULT WINAPI PHInPlaceSite_QueryInterface(IOleInPlaceSiteEx *iface, REFIID riid, void **ppv)
1843 {
1844 PluginHost *This = impl_from_IOleInPlaceSiteEx(iface);
1845 return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv);
1846 }
1847
1848 static ULONG WINAPI PHInPlaceSite_AddRef(IOleInPlaceSiteEx *iface)
1849 {
1850 PluginHost *This = impl_from_IOleInPlaceSiteEx(iface);
1851 return IOleClientSite_AddRef(&This->IOleClientSite_iface);
1852 }
1853
1854 static ULONG WINAPI PHInPlaceSite_Release(IOleInPlaceSiteEx *iface)
1855 {
1856 PluginHost *This = impl_from_IOleInPlaceSiteEx(iface);
1857 return IOleClientSite_Release(&This->IOleClientSite_iface);
1858 }
1859
1860 static HRESULT WINAPI PHInPlaceSite_GetWindow(IOleInPlaceSiteEx *iface, HWND *phwnd)
1861 {
1862 PluginHost *This = impl_from_IOleInPlaceSiteEx(iface);
1863
1864 TRACE("(%p)->(%p)\n", This, phwnd);
1865
1866 *phwnd = This->hwnd;
1867 return S_OK;
1868 }
1869
1870 static HRESULT WINAPI PHInPlaceSite_ContextSensitiveHelp(IOleInPlaceSiteEx *iface, BOOL fEnterMode)
1871 {
1872 PluginHost *This = impl_from_IOleInPlaceSiteEx(iface);
1873 FIXME("(%p)->(%x)\n", This, fEnterMode);
1874 return E_NOTIMPL;
1875 }
1876
1877 static HRESULT WINAPI PHInPlaceSite_CanInPlaceActivate(IOleInPlaceSiteEx *iface)
1878 {
1879 PluginHost *This = impl_from_IOleInPlaceSiteEx(iface);
1880
1881 TRACE("(%p)\n", This);
1882
1883 return S_OK;
1884 }
1885
1886 static HRESULT WINAPI PHInPlaceSite_OnInPlaceActivate(IOleInPlaceSiteEx *iface)
1887 {
1888 PluginHost *This = impl_from_IOleInPlaceSiteEx(iface);
1889 FIXME("(%p)\n", This);
1890 return E_NOTIMPL;
1891 }
1892
1893 static HRESULT WINAPI PHInPlaceSite_OnUIActivate(IOleInPlaceSiteEx *iface)
1894 {
1895 PluginHost *This = impl_from_IOleInPlaceSiteEx(iface);
1896
1897 TRACE("(%p)\n", This);
1898
1899 if(!This->plugin_unk) {
1900 ERR("No plugin object\n");
1901 return E_UNEXPECTED;
1902 }
1903
1904 This->ui_active = TRUE;
1905
1906 notif_enabled(This);
1907 return S_OK;
1908 }
1909
1910 static HRESULT WINAPI PHInPlaceSite_GetWindowContext(IOleInPlaceSiteEx *iface,
1911 IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, RECT *lprcPosRect,
1912 RECT *lprcClipRect, OLEINPLACEFRAMEINFO *frame_info)
1913 {
1914 PluginHost *This = impl_from_IOleInPlaceSiteEx(iface);
1915 IOleInPlaceUIWindow *ip_window;
1916 IOleInPlaceFrame *ip_frame;
1917 RECT pr, cr;
1918 HRESULT hres;
1919
1920 TRACE("(%p)->(%p %p %p %p %p)\n", This, ppFrame, ppDoc, lprcPosRect, lprcClipRect, frame_info);
1921
1922 if(!This->doc || !This->doc->basedoc.doc_obj || !This->doc->basedoc.doc_obj->ipsite) {
1923 FIXME("No ipsite\n");
1924 return E_UNEXPECTED;
1925 }
1926
1927 hres = IOleInPlaceSite_GetWindowContext(This->doc->basedoc.doc_obj->ipsite, &ip_frame, &ip_window, &pr, &cr, frame_info);
1928 if(FAILED(hres)) {
1929 WARN("GetWindowContext failed: %08x\n", hres);
1930 return hres;
1931 }
1932
1933 if(ip_window)
1934 IOleInPlaceUIWindow_Release(ip_window);
1935 if(ip_frame)
1936 IOleInPlaceFrame_Release(ip_frame);
1937
1938 hres = create_ip_frame(&ip_frame);
1939 if(FAILED(hres))
1940 return hres;
1941
1942 hres = create_ip_window(ppDoc);
1943 if(FAILED(hres)) {
1944 IOleInPlaceFrame_Release(ip_frame);
1945 return hres;
1946 }
1947
1948 *ppFrame = ip_frame;
1949 *lprcPosRect = This->rect;
1950 *lprcClipRect = This->rect;
1951 return S_OK;
1952 }
1953
1954 static HRESULT WINAPI PHInPlaceSite_Scroll(IOleInPlaceSiteEx *iface, SIZE scrollExtent)
1955 {
1956 PluginHost *This = impl_from_IOleInPlaceSiteEx(iface);
1957 FIXME("(%p)->({%d %d})\n", This, scrollExtent.cx, scrollExtent.cy);
1958 return E_NOTIMPL;
1959 }
1960
1961 static HRESULT WINAPI PHInPlaceSite_OnUIDeactivate(IOleInPlaceSiteEx *iface, BOOL fUndoable)
1962 {
1963 PluginHost *This = impl_from_IOleInPlaceSiteEx(iface);
1964 FIXME("(%p)->(%x)\n", This, fUndoable);
1965 return E_NOTIMPL;
1966 }
1967
1968 static HRESULT WINAPI PHInPlaceSite_OnInPlaceDeactivate(IOleInPlaceSiteEx *iface)
1969 {
1970 PluginHost *This = impl_from_IOleInPlaceSiteEx(iface);
1971
1972 TRACE("(%p)\n", This);
1973
1974 if(This->ip_object) {
1975 IOleInPlaceObject_Release(This->ip_object);
1976 This->ip_object = NULL;
1977 }
1978
1979 return S_OK;
1980 }
1981
1982 static HRESULT WINAPI PHInPlaceSite_DiscardUndoState(IOleInPlaceSiteEx *iface)
1983 {
1984 PluginHost *This = impl_from_IOleInPlaceSiteEx(iface);
1985 FIXME("(%p)\n", This);
1986 return E_NOTIMPL;
1987 }
1988
1989 static HRESULT WINAPI PHInPlaceSite_DeactivateAndUndo(IOleInPlaceSiteEx *iface)
1990 {
1991 PluginHost *This = impl_from_IOleInPlaceSiteEx(iface);
1992 FIXME("(%p)\n", This);
1993 return E_NOTIMPL;
1994 }
1995
1996 static HRESULT WINAPI PHInPlaceSite_OnPosRectChange(IOleInPlaceSiteEx *iface, LPCRECT lprcPosRect)
1997 {
1998 PluginHost *This = impl_from_IOleInPlaceSiteEx(iface);
1999 FIXME("(%p)->(%p)\n", This, lprcPosRect);
2000 return E_NOTIMPL;
2001 }
2002
2003 static HRESULT WINAPI PHInPlaceSiteEx_OnInPlaceActivateEx(IOleInPlaceSiteEx *iface, BOOL *pfNoRedraw, DWORD dwFlags)
2004 {
2005 PluginHost *This = impl_from_IOleInPlaceSiteEx(iface);
2006 HWND hwnd;
2007 HRESULT hres;
2008
2009 TRACE("(%p)->(%p %x)\n", This, pfNoRedraw, dwFlags);
2010
2011 if(This->ip_object)
2012 return S_OK;
2013
2014 hres = IUnknown_QueryInterface(This->plugin_unk, &IID_IOleInPlaceObject, (void**)&This->ip_object);
2015 if(FAILED(hres))
2016 return hres;
2017
2018 hres = IOleInPlaceObject_GetWindow(This->ip_object, &hwnd);
2019 if(SUCCEEDED(hres))
2020 FIXME("Use hwnd %p\n", hwnd);
2021
2022 *pfNoRedraw = FALSE;
2023 return S_OK;
2024 }
2025
2026 static HRESULT WINAPI PHInPlaceSiteEx_OnInPlaceDeactivateEx(IOleInPlaceSiteEx *iface, BOOL fNoRedraw)
2027 {
2028 PluginHost *This = impl_from_IOleInPlaceSiteEx(iface);
2029 FIXME("(%p)->(%x)\n", This, fNoRedraw);
2030 return E_NOTIMPL;
2031 }
2032
2033 static HRESULT WINAPI PHInPlaceSiteEx_RequestUIActivate(IOleInPlaceSiteEx *iface)
2034 {
2035 PluginHost *This = impl_from_IOleInPlaceSiteEx(iface);
2036 FIXME("(%p)\n", This);
2037 return E_NOTIMPL;
2038 }
2039
2040 static const IOleInPlaceSiteExVtbl OleInPlaceSiteExVtbl = {
2041 PHInPlaceSite_QueryInterface,
2042 PHInPlaceSite_AddRef,
2043 PHInPlaceSite_Release,
2044 PHInPlaceSite_GetWindow,
2045 PHInPlaceSite_ContextSensitiveHelp,
2046 PHInPlaceSite_CanInPlaceActivate,
2047 PHInPlaceSite_OnInPlaceActivate,
2048 PHInPlaceSite_OnUIActivate,
2049 PHInPlaceSite_GetWindowContext,
2050 PHInPlaceSite_Scroll,
2051 PHInPlaceSite_OnUIDeactivate,
2052 PHInPlaceSite_OnInPlaceDeactivate,
2053 PHInPlaceSite_DiscardUndoState,
2054 PHInPlaceSite_DeactivateAndUndo,
2055 PHInPlaceSite_OnPosRectChange,
2056 PHInPlaceSiteEx_OnInPlaceActivateEx,
2057 PHInPlaceSiteEx_OnInPlaceDeactivateEx,
2058 PHInPlaceSiteEx_RequestUIActivate
2059 };
2060
2061 static inline PluginHost *impl_from_IOleControlSite(IOleControlSite *iface)
2062 {
2063 return CONTAINING_RECORD(iface, PluginHost, IOleControlSite_iface);
2064 }
2065
2066 static HRESULT WINAPI PHControlSite_QueryInterface(IOleControlSite *iface, REFIID riid, void **ppv)
2067 {
2068 PluginHost *This = impl_from_IOleControlSite(iface);
2069 return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv);
2070 }
2071
2072 static ULONG WINAPI PHControlSite_AddRef(IOleControlSite *iface)
2073 {
2074 PluginHost *This = impl_from_IOleControlSite(iface);
2075 return IOleClientSite_AddRef(&This->IOleClientSite_iface);
2076 }
2077
2078 static ULONG WINAPI PHControlSite_Release(IOleControlSite *iface)
2079 {
2080 PluginHost *This = impl_from_IOleControlSite(iface);
2081 return IOleClientSite_Release(&This->IOleClientSite_iface);
2082 }
2083
2084 static HRESULT WINAPI PHControlSite_OnControlInfoChanged(IOleControlSite *iface)
2085 {
2086 PluginHost *This = impl_from_IOleControlSite(iface);
2087 FIXME("(%p)\n", This);
2088 return E_NOTIMPL;
2089 }
2090
2091 static HRESULT WINAPI PHControlSite_LockInPlaceActive(IOleControlSite *iface, BOOL fLock)
2092 {
2093 PluginHost *This = impl_from_IOleControlSite(iface);
2094 FIXME("(%p)->(%x)\n", This, fLock);
2095 return E_NOTIMPL;
2096 }
2097
2098 static HRESULT WINAPI PHControlSite_GetExtendedControl(IOleControlSite *iface, IDispatch **ppDisp)
2099 {
2100 PluginHost *This = impl_from_IOleControlSite(iface);
2101 FIXME("(%p)->(%p)\n", This, ppDisp);
2102 return E_NOTIMPL;
2103 }
2104
2105 static HRESULT WINAPI PHControlSite_TransformCoords(IOleControlSite *iface, POINTL *pPtlHimetric, POINTF *pPtfContainer, DWORD dwFlags)
2106 {
2107 PluginHost *This = impl_from_IOleControlSite(iface);
2108 FIXME("(%p)->(%p %p %x)\n", This, pPtlHimetric, pPtfContainer, dwFlags);
2109 return E_NOTIMPL;
2110 }
2111
2112 static HRESULT WINAPI PHControlSite_TranslateAccelerator(IOleControlSite *iface, MSG *pMsg, DWORD grfModifiers)
2113 {
2114 PluginHost *This = impl_from_IOleControlSite(iface);
2115 FIXME("(%p)->(%x)\n", This, grfModifiers);
2116 return E_NOTIMPL;
2117 }
2118
2119 static HRESULT WINAPI PHControlSite_OnFocus(IOleControlSite *iface, BOOL fGotFocus)
2120 {
2121 PluginHost *This = impl_from_IOleControlSite(iface);
2122 FIXME("(%p)->(%x)\n", This, fGotFocus);
2123 return E_NOTIMPL;
2124 }
2125
2126 static HRESULT WINAPI PHControlSite_ShowPropertyFrame(IOleControlSite *iface)
2127 {
2128 PluginHost *This = impl_from_IOleControlSite(iface);
2129 FIXME("(%p)\n", This);
2130 return E_NOTIMPL;
2131 }
2132
2133 static const IOleControlSiteVtbl OleControlSiteVtbl = {
2134 PHControlSite_QueryInterface,
2135 PHControlSite_AddRef,
2136 PHControlSite_Release,
2137 PHControlSite_OnControlInfoChanged,
2138 PHControlSite_LockInPlaceActive,
2139 PHControlSite_GetExtendedControl,
2140 PHControlSite_TransformCoords,
2141 PHControlSite_TranslateAccelerator,
2142 PHControlSite_OnFocus,
2143 PHControlSite_ShowPropertyFrame
2144 };
2145
2146 static inline PluginHost *impl_from_IBindHost(IBindHost *iface)
2147 {
2148 return CONTAINING_RECORD(iface, PluginHost, IBindHost_iface);
2149 }
2150
2151 static HRESULT WINAPI PHBindHost_QueryInterface(IBindHost *iface, REFIID riid, void **ppv)
2152 {
2153 PluginHost *This = impl_from_IBindHost(iface);
2154 return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv);
2155 }
2156
2157 static ULONG WINAPI PHBindHost_AddRef(IBindHost *iface)
2158 {
2159 PluginHost *This = impl_from_IBindHost(iface);
2160 return IOleClientSite_AddRef(&This->IOleClientSite_iface);
2161 }
2162
2163 static ULONG WINAPI PHBindHost_Release(IBindHost *iface)
2164 {
2165 PluginHost *This = impl_from_IBindHost(iface);
2166 return IOleClientSite_Release(&This->IOleClientSite_iface);
2167 }
2168
2169 static HRESULT WINAPI PHBindHost_CreateMoniker(IBindHost *iface, LPOLESTR szName, IBindCtx *pBC, IMoniker **ppmk, DWORD dwReserved)
2170 {
2171 PluginHost *This = impl_from_IBindHost(iface);
2172
2173 TRACE("(%p)->(%s %p %p %x)\n", This, debugstr_w(szName), pBC, ppmk, dwReserved);
2174
2175 if(!This->doc || !This->doc->window || !This->doc->window->mon) {
2176 FIXME("no moniker\n");
2177 return E_UNEXPECTED;
2178 }
2179
2180 return CreateURLMoniker(This->doc->window->mon, szName, ppmk);
2181 }
2182
2183 static HRESULT WINAPI PHBindHost_MonikerBindToStorage(IBindHost *iface, IMoniker *pMk, IBindCtx *pBC,
2184 IBindStatusCallback *pBSC, REFIID riid, void **ppvObj)
2185 {
2186 PluginHost *This = impl_from_IBindHost(iface);
2187 FIXME("(%p)->(%p %p %p %s %p)\n", This, pMk, pBC, pBSC, debugstr_guid(riid), ppvObj);
2188 return E_NOTIMPL;
2189 }
2190
2191 static HRESULT WINAPI PHBindHost_MonikerBindToObject(IBindHost *iface, IMoniker *pMk, IBindCtx *pBC,
2192 IBindStatusCallback *pBSC, REFIID riid, void **ppvObj)
2193 {
2194 PluginHost *This = impl_from_IBindHost(iface);
2195 FIXME("(%p)->(%p %p %p %s %p)\n", This, pMk, pBC, pBSC, debugstr_guid(riid), ppvObj);
2196 return E_NOTIMPL;
2197 }
2198
2199 static const IBindHostVtbl BindHostVtbl = {
2200 PHBindHost_QueryInterface,
2201 PHBindHost_AddRef,
2202 PHBindHost_Release,
2203 PHBindHost_CreateMoniker,
2204 PHBindHost_MonikerBindToStorage,
2205 PHBindHost_MonikerBindToObject
2206 };
2207
2208 static inline PluginHost *impl_from_IServiceProvider(IServiceProvider *iface)
2209 {
2210 return CONTAINING_RECORD(iface, PluginHost, IServiceProvider_iface);
2211 }
2212
2213 static HRESULT WINAPI PHServiceProvider_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppv)
2214 {
2215 PluginHost *This = impl_from_IServiceProvider(iface);
2216 return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv);
2217 }
2218
2219 static ULONG WINAPI PHServiceProvider_AddRef(IServiceProvider *iface)
2220 {
2221 PluginHost *This = impl_from_IServiceProvider(iface);
2222 return IOleClientSite_AddRef(&This->IOleClientSite_iface);
2223 }
2224
2225 static ULONG WINAPI PHServiceProvider_Release(IServiceProvider *iface)
2226 {
2227 PluginHost *This = impl_from_IServiceProvider(iface);
2228 return IOleClientSite_Release(&This->IOleClientSite_iface);
2229 }
2230
2231 static HRESULT WINAPI PHServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService, REFIID riid, void **ppv)
2232 {
2233 PluginHost *This = impl_from_IServiceProvider(iface);
2234
2235 if(IsEqualGUID(guidService, &SID_SBindHost)) {
2236 TRACE("SID_SBindHost service\n");
2237 return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv);
2238 }
2239
2240 TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
2241
2242 if(!This->doc || !This->doc->basedoc.window) {
2243 *ppv = NULL;
2244 return E_NOINTERFACE;
2245 }
2246
2247 return IServiceProvider_QueryService(&This->doc->basedoc.window->base.IServiceProvider_iface,
2248 guidService, riid, ppv);
2249 }
2250
2251 static const IServiceProviderVtbl ServiceProviderVtbl = {
2252 PHServiceProvider_QueryInterface,
2253 PHServiceProvider_AddRef,
2254 PHServiceProvider_Release,
2255 PHServiceProvider_QueryService
2256 };
2257
2258 static BOOL parse_classid(const PRUnichar *classid, CLSID *clsid)
2259 {
2260 const WCHAR *ptr;
2261 unsigned len;
2262 HRESULT hres;
2263
2264 static const PRUnichar clsidW[] = {'c','l','s','i','d',':'};
2265
2266 if(wcsnicmp(classid, clsidW, ARRAY_SIZE(clsidW)))
2267 return FALSE;
2268
2269 ptr = classid + ARRAY_SIZE(clsidW);
2270 len = lstrlenW(ptr);
2271
2272 if(len == 38) {
2273 hres = CLSIDFromString(ptr, clsid);
2274 }else if(len == 36) {
2275 WCHAR buf[39];
2276
2277 buf[0] = '{';
2278 memcpy(buf+1, ptr, len*sizeof(WCHAR));
2279 buf[37] = '}';
2280 buf[38] = 0;
2281 hres = CLSIDFromString(buf, clsid);
2282 }else {
2283 return FALSE;
2284 }
2285
2286 return SUCCEEDED(hres);
2287 }
2288
2289 static BOOL get_elem_clsid(nsIDOMElement *elem, CLSID *clsid)
2290 {
2291 const PRUnichar *val;
2292 nsAString val_str;
2293 nsresult nsres;
2294 BOOL ret = FALSE;
2295
2296 nsres = get_elem_attr_value(elem, L"classid", &val_str, &val);
2297 if(NS_SUCCEEDED(nsres)) {
2298 if(*val)
2299 ret = parse_classid(val, clsid);
2300 nsAString_Finish(&val_str);
2301 }
2302
2303 return ret;
2304 }
2305
2306 typedef struct {
2307 IBindStatusCallback IBindStatusCallback_iface;
2308 IWindowForBindingUI IWindowForBindingUI_iface;
2309 LONG ref;
2310 } InstallCallback;
2311
2312 static inline InstallCallback *impl_from_IBindStatusCallback(IBindStatusCallback *iface)
2313 {
2314 return CONTAINING_RECORD(iface, InstallCallback, IBindStatusCallback_iface);
2315 }
2316
2317 static HRESULT WINAPI InstallCallback_QueryInterface(IBindStatusCallback *iface,
2318 REFIID riid, void **ppv)
2319 {
2320 InstallCallback *This = impl_from_IBindStatusCallback(iface);
2321
2322 if(IsEqualGUID(&IID_IUnknown, riid)) {
2323 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
2324 *ppv = &This->IBindStatusCallback_iface;
2325 }else if(IsEqualGUID(&IID_IBindStatusCallback, riid)) {
2326 TRACE("(%p)->(IID_IBindStatusCallback %p)\n", This, ppv);
2327 *ppv = &This->IBindStatusCallback_iface;
2328 }else if(IsEqualGUID(&IID_IWindowForBindingUI, riid)) {
2329 TRACE("(%p)->(IID_IWindowForBindingUI %p)\n", This, ppv);
2330 *ppv = &This->IWindowForBindingUI_iface;
2331 }else {
2332 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
2333 *ppv = NULL;
2334 return E_NOINTERFACE;
2335 }
2336
2337 IUnknown_AddRef((IUnknown*)*ppv);
2338 return S_OK;
2339 }
2340
2341 static ULONG WINAPI InstallCallback_AddRef(IBindStatusCallback *iface)
2342 {
2343 InstallCallback *This = impl_from_IBindStatusCallback(iface);
2344 LONG ref = InterlockedIncrement(&This->ref);
2345
2346 TRACE("(%p) ref=%d\n", This, ref);
2347
2348 return ref;
2349 }
2350
2351 static ULONG WINAPI InstallCallback_Release(IBindStatusCallback *iface)
2352 {
2353 InstallCallback *This = impl_from_IBindStatusCallback(iface);
2354 LONG ref = InterlockedIncrement(&This->ref);
2355
2356 TRACE("(%p) ref=%d\n", This, ref);
2357
2358 if(!ref)
2359 heap_free(This);
2360
2361 return ref;
2362 }
2363
2364 static HRESULT WINAPI InstallCallback_OnStartBinding(IBindStatusCallback *iface,
2365 DWORD dwReserved, IBinding *pib)
2366 {
2367 InstallCallback *This = impl_from_IBindStatusCallback(iface);
2368 TRACE("(%p)->(%x %p)\n", This, dwReserved, pib);
2369 return S_OK;
2370 }
2371
2372 static HRESULT WINAPI InstallCallback_GetPriority(IBindStatusCallback *iface, LONG *pnPriority)
2373 {
2374 InstallCallback *This = impl_from_IBindStatusCallback(iface);
2375 TRACE("(%p)->(%p)\n", This, pnPriority);
2376 return E_NOTIMPL;
2377 }
2378
2379 static HRESULT WINAPI InstallCallback_OnLowResource(IBindStatusCallback *iface, DWORD dwReserved)
2380 {
2381 InstallCallback *This = impl_from_IBindStatusCallback(iface);
2382 TRACE("(%p)->(%x)\n", This, dwReserved);
2383 return S_OK;
2384 }
2385
2386 static HRESULT WINAPI InstallCallback_OnProgress(IBindStatusCallback *iface, ULONG ulProgress,
2387 ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
2388 {
2389 InstallCallback *This = impl_from_IBindStatusCallback(iface);
2390 TRACE("(%p)->(%u %u %u %s)\n", This, ulProgress, ulProgressMax, ulStatusCode, debugstr_w(szStatusText));
2391 return S_OK;
2392 }
2393
2394 static HRESULT WINAPI InstallCallback_OnStopBinding(IBindStatusCallback *iface,
2395 HRESULT hresult, LPCWSTR szError)
2396 {
2397 InstallCallback *This = impl_from_IBindStatusCallback(iface);
2398 TRACE("(%p)->(%08x %s)\n", This, hresult, debugstr_w(szError));
2399 return S_OK;
2400 }
2401
2402 static HRESULT WINAPI InstallCallback_GetBindInfo(IBindStatusCallback *iface,
2403 DWORD* grfBINDF, BINDINFO* pbindinfo)
2404 {
2405 InstallCallback *This = impl_from_IBindStatusCallback(iface);
2406
2407 TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
2408
2409 *grfBINDF = BINDF_ASYNCHRONOUS;
2410 return S_OK;
2411 }
2412
2413 static HRESULT WINAPI InstallCallback_OnDataAvailable(IBindStatusCallback *iface, DWORD grfBSCF,
2414 DWORD dwSize, FORMATETC* pformatetc, STGMEDIUM* pstgmed)
2415 {
2416 InstallCallback *This = impl_from_IBindStatusCallback(iface);
2417 ERR("(%p)\n", This);
2418 return E_NOTIMPL;
2419 }
2420
2421 static HRESULT WINAPI InstallCallback_OnObjectAvailable(IBindStatusCallback *iface,
2422 REFIID riid, IUnknown* punk)
2423 {
2424 InstallCallback *This = impl_from_IBindStatusCallback(iface);
2425 ERR("(%p)\n", This);
2426 return E_NOTIMPL;
2427 }
2428
2429 static IBindStatusCallbackVtbl InstallCallbackVtbl = {
2430 InstallCallback_QueryInterface,
2431 InstallCallback_AddRef,
2432 InstallCallback_Release,
2433 InstallCallback_OnStartBinding,
2434 InstallCallback_GetPriority,
2435 InstallCallback_OnLowResource,
2436 InstallCallback_OnProgress,
2437 InstallCallback_OnStopBinding,
2438 InstallCallback_GetBindInfo,
2439 InstallCallback_OnDataAvailable,
2440 InstallCallback_OnObjectAvailable
2441 };
2442
2443 static inline InstallCallback *impl_from_IWindowForBindingUI(IWindowForBindingUI *iface)
2444 {
2445 return CONTAINING_RECORD(iface, InstallCallback, IWindowForBindingUI_iface);
2446 }
2447
2448 static HRESULT WINAPI WindowForBindingUI_QueryInterface(IWindowForBindingUI *iface, REFIID riid, void **ppv)
2449 {
2450 InstallCallback *This = impl_from_IWindowForBindingUI(iface);
2451 return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
2452 }
2453
2454 static ULONG WINAPI WindowForBindingUI_AddRef(IWindowForBindingUI *iface)
2455 {
2456 InstallCallback *This = impl_from_IWindowForBindingUI(iface);
2457 return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
2458 }
2459
2460 static ULONG WINAPI WindowForBindingUI_Release(IWindowForBindingUI *iface)
2461 {
2462 InstallCallback *This = impl_from_IWindowForBindingUI(iface);
2463 return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
2464 }
2465
2466 static HRESULT WINAPI WindowForBindingUI_GetWindow(IWindowForBindingUI *iface, REFGUID rguidReason, HWND *phwnd)
2467 {
2468 InstallCallback *This = impl_from_IWindowForBindingUI(iface);
2469 FIXME("(%p)->(%s %p)\n", This, debugstr_guid(rguidReason), phwnd);
2470 *phwnd = NULL;
2471 return S_OK;
2472 }
2473
2474 static const IWindowForBindingUIVtbl WindowForBindingUIVtbl = {
2475 WindowForBindingUI_QueryInterface,
2476 WindowForBindingUI_AddRef,
2477 WindowForBindingUI_Release,
2478 WindowForBindingUI_GetWindow
2479 };
2480
2481 typedef struct {
2482 struct list entry;
2483 IUri *uri;
2484 } install_entry_t;
2485
2486 static struct list install_list = LIST_INIT(install_list);
2487
2488 static CRITICAL_SECTION cs_install_list;
2489 static CRITICAL_SECTION_DEBUG cs_install_list_dbg =
2490 {
2491 0, 0, &cs_install_list,
2492 { &cs_install_list_dbg.ProcessLocksList, &cs_install_list_dbg.ProcessLocksList },
2493 0, 0, { (DWORD_PTR)(__FILE__ ": install_list") }
2494 };
2495 static CRITICAL_SECTION cs_install_list = { &cs_install_list_dbg, -1, 0, 0, 0, 0 };
2496
2497 static void install_codebase(const WCHAR *url)
2498 {
2499 InstallCallback *callback;
2500 IBindCtx *bctx;
2501 HRESULT hres;
2502
2503 callback = heap_alloc(sizeof(*callback));
2504 if(!callback)
2505 return;
2506
2507 callback->IBindStatusCallback_iface.lpVtbl = &InstallCallbackVtbl;
2508 callback->IWindowForBindingUI_iface.lpVtbl = &WindowForBindingUIVtbl;
2509 callback->ref = 1;
2510
2511 hres = CreateAsyncBindCtx(0, &callback->IBindStatusCallback_iface, NULL, &bctx);
2512 IBindStatusCallback_Release(&callback->IBindStatusCallback_iface);
2513 if(FAILED(hres))
2514 return;
2515
2516 hres = AsyncInstallDistributionUnit(NULL, NULL, NULL, 0, 0, url, bctx, NULL, 0);
2517 IBindCtx_Release(bctx);
2518 if(FAILED(hres))
2519 WARN("FAILED: %08x\n", hres);
2520 }
2521
2522 static void check_codebase(HTMLInnerWindow *window, nsIDOMElement *nselem)
2523 {
2524 BOOL is_on_list = FALSE;
2525 install_entry_t *iter;
2526 const PRUnichar *val;
2527 nsAString val_str;
2528 IUri *uri = NULL;
2529 nsresult nsres;
2530 HRESULT hres;
2531
2532 nsres = get_elem_attr_value(nselem, L"codebase", &val_str, &val);
2533 if(NS_SUCCEEDED(nsres)) {
2534 if(*val) {
2535 hres = CoInternetCombineUrlEx(window->base.outer_window->uri, val, 0, &uri, 0);
2536 if(FAILED(hres))
2537 uri = NULL;
2538 }
2539 nsAString_Finish(&val_str);
2540 }
2541
2542 if(!uri)
2543 return;
2544
2545 EnterCriticalSection(&cs_install_list);
2546
2547 LIST_FOR_EACH_ENTRY(iter, &install_list, install_entry_t, entry) {
2548 BOOL eq;
2549
2550 hres = IUri_IsEqual(uri, iter->uri, &eq);
2551 if(SUCCEEDED(hres) && eq) {
2552 TRACE("already proceeded\n");
2553 is_on_list = TRUE;
2554 break;
2555 }
2556 }
2557
2558 if(!is_on_list) {
2559 iter = heap_alloc(sizeof(*iter));
2560 if(iter) {
2561 IUri_AddRef(uri);
2562 iter->uri = uri;
2563
2564 list_add_tail(&install_list, &iter->entry);
2565 }
2566 }
2567
2568 LeaveCriticalSection(&cs_install_list);
2569
2570 if(!is_on_list) {
2571 BSTR display_uri;
2572
2573 hres = IUri_GetDisplayUri(uri, &display_uri);
2574 if(SUCCEEDED(hres)) {
2575 install_codebase(display_uri);
2576 SysFreeString(display_uri);
2577 }
2578 }
2579
2580 IUri_Release(uri);
2581 }
2582
2583 static IUnknown *create_activex_object(HTMLDocumentNode *doc, nsIDOMElement *nselem, CLSID *clsid)
2584 {
2585 IClassFactoryEx *cfex;
2586 IClassFactory *cf;
2587 IUnknown *obj;
2588 DWORD policy;
2589 HRESULT hres;
2590
2591 if(!get_elem_clsid(nselem, clsid)) {
2592 WARN("Could not determine element CLSID\n");
2593 return NULL;
2594 }
2595
2596 TRACE("clsid %s\n", debugstr_guid(clsid));
2597
2598 policy = 0;
2599 hres = IInternetHostSecurityManager_ProcessUrlAction(&doc->IInternetHostSecurityManager_iface,
2600 URLACTION_ACTIVEX_RUN, (BYTE*)&policy, sizeof(policy), (BYTE*)clsid, sizeof(GUID), 0, 0);
2601 if(FAILED(hres) || policy != URLPOLICY_ALLOW) {
2602 WARN("ProcessUrlAction returned %08x %x\n", hres, policy);
2603 return NULL;
2604 }
2605
2606 hres = CoGetClassObject(clsid, CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER, NULL, &IID_IClassFactory, (void**)&cf);
2607 if(hres == REGDB_E_CLASSNOTREG)
2608 check_codebase(doc->window, nselem);
2609 if(FAILED(hres))
2610 return NULL;
2611
2612 hres = IClassFactory_QueryInterface(cf, &IID_IClassFactoryEx, (void**)&cfex);
2613 if(SUCCEEDED(hres)) {
2614 FIXME("Use IClassFactoryEx\n");
2615 IClassFactoryEx_Release(cfex);
2616 }
2617
2618 hres = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (void**)&obj);
2619 IClassFactory_Release(cf);
2620 if(FAILED(hres))
2621 return NULL;
2622
2623 return obj;
2624 }
2625
2626 void detach_plugin_host(PluginHost *host)
2627 {
2628 HRESULT hres;
2629
2630 TRACE("%p\n", host);
2631
2632 if(!host->doc)
2633 return;
2634
2635 if(host->ip_object) {
2636 if(host->ui_active)
2637 IOleInPlaceObject_UIDeactivate(host->ip_object);
2638 IOleInPlaceObject_InPlaceDeactivate(host->ip_object);
2639 }
2640
2641 if(host->plugin_unk) {
2642 IOleObject *ole_obj;
2643
2644 hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IOleObject, (void**)&ole_obj);
2645 if(SUCCEEDED(hres)) {
2646 if(!host->ip_object)
2647 IOleObject_Close(ole_obj, OLECLOSE_NOSAVE);
2648 IOleObject_SetClientSite(ole_obj, NULL);
2649 IOleObject_Release(ole_obj);
2650 }
2651 }
2652
2653 if(host->sink) {
2654 IConnectionPointContainer *cp_container;
2655 IConnectionPoint *cp;
2656
2657 assert(host->plugin_unk != NULL);
2658
2659 hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IConnectionPointContainer, (void**)&cp_container);
2660 if(SUCCEEDED(hres)) {
2661 hres = IConnectionPointContainer_FindConnectionPoint(cp_container, &host->sink->iid, &cp);
2662 IConnectionPointContainer_Release(cp_container);
2663 if(SUCCEEDED(hres)) {
2664 IConnectionPoint_Unadvise(cp, host->sink->cookie);
2665 IConnectionPoint_Release(cp);
2666 }
2667 }
2668
2669 host->sink->host = NULL;
2670 IDispatch_Release(&host->sink->IDispatch_iface);
2671 host->sink = NULL;
2672 }
2673
2674 release_plugin_ifaces(host);
2675
2676 if(host->element) {
2677 host->element->plugin_host = NULL;
2678 host->element = NULL;
2679 }
2680
2681 list_remove(&host->entry);
2682 list_init(&host->entry);
2683 host->doc = NULL;
2684 }
2685
2686 HRESULT create_plugin_host(HTMLDocumentNode *doc, HTMLPluginContainer *container)
2687 {
2688 PluginHost *host;
2689 IUnknown *unk;
2690 CLSID clsid;
2691
2692 assert(!container->plugin_host);
2693
2694 unk = create_activex_object(doc, container->element.dom_element, &clsid);
2695 if(!unk)
2696 return E_FAIL;
2697
2698 host = heap_alloc_zero(sizeof(*host));
2699 if(!host) {
2700 IUnknown_Release(unk);
2701 return E_OUTOFMEMORY;
2702 }
2703
2704 host->IOleClientSite_iface.lpVtbl = &OleClientSiteVtbl;
2705 host->IAdviseSinkEx_iface.lpVtbl = &AdviseSinkExVtbl;
2706 host->IPropertyNotifySink_iface.lpVtbl = &PropertyNotifySinkVtbl;
2707 host->IDispatch_iface.lpVtbl = &DispatchVtbl;
2708 host->IOleInPlaceSiteEx_iface.lpVtbl = &OleInPlaceSiteExVtbl;
2709 host->IOleControlSite_iface.lpVtbl = &OleControlSiteVtbl;
2710 host->IBindHost_iface.lpVtbl = &BindHostVtbl;
2711 host->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl;
2712
2713 host->ref = 1;
2714
2715 host->plugin_unk = unk;
2716 host->clsid = clsid;
2717
2718 host->doc = doc;
2719 list_add_tail(&doc->plugin_hosts, &host->entry);
2720
2721 container->plugin_host = host;
2722 host->element = container;
2723
2724 initialize_plugin_object(host);
2725
2726 return S_OK;
2727 }
Windows API implementation