dlls/mshtml/pluginhost.c

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