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