dlls/mshtml/oleobj.c

   1 /*
   2  * Copyright 2005 Jacek Caban
   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 "config.h"
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23 #include <assert.h>
  24
  25 #define COBJMACROS
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winuser.h"
  30 #include "ole2.h"
  31 #include "shlguid.h"
  32 #include "shdeprecated.h"
  33 #include "mshtmdid.h"
  34 #include "idispids.h"
  35
  36 #include "wine/debug.h"
  37
  38 #include "mshtml_private.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  41
  42 #define DOCHOST_DOCCANNAVIGATE  0
  43
  44 typedef struct {
  45     IEnumUnknown IEnumUnknown_iface;
  46     LONG ref;
  47 } EnumUnknown;
  48
  49 static inline EnumUnknown *impl_from_IEnumUnknown(IEnumUnknown *iface)
  50 {
  51     return CONTAINING_RECORD(iface, EnumUnknown, IEnumUnknown_iface);
  52 }
  53
  54 static HRESULT WINAPI EnumUnknown_QueryInterface(IEnumUnknown *iface, REFIID riid, void **ppv)
  55 {
  56     EnumUnknown *This = impl_from_IEnumUnknown(iface);
  57
  58     if(IsEqualGUID(&IID_IUnknown, riid)) {
  59         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
  60         *ppv = &This->IEnumUnknown_iface;
  61     }else if(IsEqualGUID(&IID_IEnumUnknown, riid)) {
  62         TRACE("(%p)->(IID_IEnumUnknown %p)\n", This, ppv);
  63         *ppv = &This->IEnumUnknown_iface;
  64     }else {
  65         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
  66         *ppv = NULL;
  67         return E_NOINTERFACE;
  68     }
  69
  70     IUnknown_AddRef((IUnknown*)*ppv);
  71     return S_OK;
  72 }
  73
  74 static ULONG WINAPI EnumUnknown_AddRef(IEnumUnknown *iface)
  75 {
  76     EnumUnknown *This = impl_from_IEnumUnknown(iface);
  77     LONG ref = InterlockedIncrement(&This->ref);
  78
  79     TRACE("(%p) ref=%d\n", This, ref);
  80
  81     return ref;
  82 }
  83
  84 static ULONG WINAPI EnumUnknown_Release(IEnumUnknown *iface)
  85 {
  86     EnumUnknown *This = impl_from_IEnumUnknown(iface);
  87     LONG ref = InterlockedDecrement(&This->ref);
  88
  89     TRACE("(%p) ref=%d\n", This, ref);
  90
  91     if(!ref)
  92         heap_free(This);
  93
  94     return ref;
  95 }
  96
  97 static HRESULT WINAPI EnumUnknown_Next(IEnumUnknown *iface, ULONG celt, IUnknown **rgelt, ULONG *pceltFetched)
  98 {
  99     EnumUnknown *This = impl_from_IEnumUnknown(iface);
 100
 101     TRACE("(%p)->(%u %p %p)\n", This, celt, rgelt, pceltFetched);
 102
 103     /* FIXME: It's not clear if we should ever return something here */
 104     if(pceltFetched)
 105         *pceltFetched = 0;
 106     return S_FALSE;
 107 }
 108
 109 static HRESULT WINAPI EnumUnknown_Skip(IEnumUnknown *iface, ULONG celt)
 110 {
 111     EnumUnknown *This = impl_from_IEnumUnknown(iface);
 112     FIXME("(%p)->(%u)\n", This, celt);
 113     return E_NOTIMPL;
 114 }
 115
 116 static HRESULT WINAPI EnumUnknown_Reset(IEnumUnknown *iface)
 117 {
 118     EnumUnknown *This = impl_from_IEnumUnknown(iface);
 119     FIXME("(%p)\n", This);
 120     return E_NOTIMPL;
 121 }
 122
 123 static HRESULT WINAPI EnumUnknown_Clone(IEnumUnknown *iface, IEnumUnknown **ppenum)
 124 {
 125     EnumUnknown *This = impl_from_IEnumUnknown(iface);
 126     FIXME("(%p)->(%p)\n", This, ppenum);
 127     return E_NOTIMPL;
 128 }
 129
 130 static const IEnumUnknownVtbl EnumUnknownVtbl = {
 131     EnumUnknown_QueryInterface,
 132     EnumUnknown_AddRef,
 133     EnumUnknown_Release,
 134     EnumUnknown_Next,
 135     EnumUnknown_Skip,
 136     EnumUnknown_Reset,
 137     EnumUnknown_Clone
 138 };
 139
 140 /**********************************************************
 141  * IOleObject implementation
 142  */
 143
 144 static inline HTMLDocument *impl_from_IOleObject(IOleObject *iface)
 145 {
 146     return CONTAINING_RECORD(iface, HTMLDocument, IOleObject_iface);
 147 }
 148
 149 static HRESULT WINAPI OleObject_QueryInterface(IOleObject *iface, REFIID riid, void **ppv)
 150 {
 151     HTMLDocument *This = impl_from_IOleObject(iface);
 152     return htmldoc_query_interface(This, riid, ppv);
 153 }
 154
 155 static ULONG WINAPI OleObject_AddRef(IOleObject *iface)
 156 {
 157     HTMLDocument *This = impl_from_IOleObject(iface);
 158     return htmldoc_addref(This);
 159 }
 160
 161 static ULONG WINAPI OleObject_Release(IOleObject *iface)
 162 {
 163     HTMLDocument *This = impl_from_IOleObject(iface);
 164     return htmldoc_release(This);
 165 }
 166
 167 static void update_hostinfo(HTMLDocumentObj *This, DOCHOSTUIINFO *hostinfo)
 168 {
 169     nsIScrollable *scrollable;
 170     nsresult nsres;
 171
 172     if(!This->nscontainer)
 173         return;
 174
 175     nsres = nsIWebBrowser_QueryInterface(This->nscontainer->webbrowser, &IID_nsIScrollable, (void**)&scrollable);
 176     if(NS_SUCCEEDED(nsres)) {
 177         nsres = nsIScrollable_SetDefaultScrollbarPreferences(scrollable, ScrollOrientation_Y,
 178                 (hostinfo->dwFlags & DOCHOSTUIFLAG_SCROLL_NO) ? Scrollbar_Never : Scrollbar_Always);
 179         if(NS_FAILED(nsres))
 180             ERR("Could not set default Y scrollbar prefs: %08x\n", nsres);
 181
 182         nsres = nsIScrollable_SetDefaultScrollbarPreferences(scrollable, ScrollOrientation_X,
 183                 hostinfo->dwFlags & DOCHOSTUIFLAG_SCROLL_NO ? Scrollbar_Never : Scrollbar_Auto);
 184         if(NS_FAILED(nsres))
 185             ERR("Could not set default X scrollbar prefs: %08x\n", nsres);
 186
 187         nsIScrollable_Release(scrollable);
 188     }else {
 189         ERR("Could not get nsIScrollable: %08x\n", nsres);
 190     }
 191 }
 192
 193 /* Calls undocumented 84 cmd of CGID_ShellDocView */
 194 void call_docview_84(HTMLDocumentObj *doc)
 195 {
 196     IOleCommandTarget *olecmd;
 197     VARIANT var;
 198     HRESULT hres;
 199
 200     if(!doc->client)
 201         return;
 202
 203     hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd);
 204     if(FAILED(hres))
 205         return;
 206
 207     VariantInit(&var);
 208     hres = IOleCommandTarget_Exec(olecmd, &CGID_ShellDocView, 84, 0, NULL, &var);
 209     IOleCommandTarget_Release(olecmd);
 210     if(SUCCEEDED(hres) && V_VT(&var) != VT_NULL)
 211         FIXME("handle result\n");
 212 }
 213
 214 void set_document_navigation(HTMLDocumentObj *doc, BOOL doc_can_navigate)
 215 {
 216     VARIANT var;
 217
 218     if(!doc->client_cmdtrg)
 219         return;
 220
 221     if(doc_can_navigate) {
 222         V_VT(&var) = VT_UNKNOWN;
 223         V_UNKNOWN(&var) = (IUnknown*)&doc->basedoc.window->base.IHTMLWindow2_iface;
 224     }
 225
 226     IOleCommandTarget_Exec(doc->client_cmdtrg, &CGID_DocHostCmdPriv, DOCHOST_DOCCANNAVIGATE, 0,
 227             doc_can_navigate ? &var : NULL, NULL);
 228 }
 229
 230 static void load_settings(HTMLDocumentObj *doc)
 231 {
 232     nsIContentViewer *content_viewer;
 233     nsIDocShell *doc_shell;
 234     HKEY settings_key;
 235     DWORD val, size;
 236     LONG res;
 237     nsresult nsres;
 238
 239     static const WCHAR ie_keyW[] = {
 240         'S','O','F','T','W','A','R','E','\\',
 241         'M','i','c','r','o','s','o','f','t','\\',
 242         'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r',0};
 243     static const WCHAR zoomW[] = {'Z','o','o','m',0};
 244     static const WCHAR zoom_factorW[] = {'Z','o','o','m','F','a','c','t','o','r',0};
 245
 246     res = RegOpenKeyW(HKEY_CURRENT_USER, ie_keyW, &settings_key);
 247     if(res != ERROR_SUCCESS)
 248         return;
 249
 250     size = sizeof(val);
 251     res = RegGetValueW(settings_key, zoomW, zoom_factorW, RRF_RT_REG_DWORD, NULL, &val, &size);
 252     RegCloseKey(settings_key);
 253     if(res != ERROR_SUCCESS)
 254         return;
 255
 256     TRACE("Setting ZoomFactor to %u\n", val);
 257
 258     nsres = get_nsinterface((nsISupports*)doc->nscontainer->navigation, &IID_nsIDocShell, (void**)&doc_shell);
 259     assert(nsres == NS_OK);
 260
 261     nsres = nsIDocShell_GetContentViewer(doc_shell, &content_viewer);
 262     assert(nsres == NS_OK && content_viewer);
 263     nsIDocShell_Release(doc_shell);
 264
 265     nsres = nsIContentViewer_SetFullZoom(content_viewer, (float)val/100000);
 266     if(NS_FAILED(nsres))
 267         ERR("SetFullZoom failed: %08x\n", nsres);
 268
 269     nsIContentViewer_Release(content_viewer);
 270 }
 271
 272 static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite *pClientSite)
 273 {
 274     HTMLDocument *This = impl_from_IOleObject(iface);
 275     IOleCommandTarget *cmdtrg = NULL;
 276     IOleWindow *ole_window;
 277     IBrowserService *browser_service;
 278     BOOL hostui_setup;
 279     VARIANT silent;
 280     HWND hwnd;
 281     HRESULT hres;
 282
 283     TRACE("(%p)->(%p)\n", This, pClientSite);
 284
 285     if(pClientSite == This->doc_obj->client)
 286         return S_OK;
 287
 288     if(This->doc_obj->client) {
 289         IOleClientSite_Release(This->doc_obj->client);
 290         This->doc_obj->client = NULL;
 291         This->doc_obj->usermode = UNKNOWN_USERMODE;
 292     }
 293
 294     if(This->doc_obj->client_cmdtrg) {
 295         IOleCommandTarget_Release(This->doc_obj->client_cmdtrg);
 296         This->doc_obj->client_cmdtrg = NULL;
 297     }
 298
 299     if(This->doc_obj->hostui && !This->doc_obj->custom_hostui) {
 300         IDocHostUIHandler_Release(This->doc_obj->hostui);
 301         This->doc_obj->hostui = NULL;
 302     }
 303
 304     if(This->doc_obj->doc_object_service) {
 305         IDocObjectService_Release(This->doc_obj->doc_object_service);
 306         This->doc_obj->doc_object_service = NULL;
 307     }
 308
 309     if(This->doc_obj->webbrowser) {
 310         IUnknown_Release(This->doc_obj->webbrowser);
 311         This->doc_obj->webbrowser = NULL;
 312     }
 313
 314     if(This->doc_obj->browser_service) {
 315         IUnknown_Release(This->doc_obj->browser_service);
 316         This->doc_obj->browser_service = NULL;
 317     }
 318
 319     if(This->doc_obj->travel_log) {
 320         ITravelLog_Release(This->doc_obj->travel_log);
 321         This->doc_obj->travel_log = NULL;
 322     }
 323
 324     memset(&This->doc_obj->hostinfo, 0, sizeof(DOCHOSTUIINFO));
 325
 326     if(!pClientSite)
 327         return S_OK;
 328
 329     IOleClientSite_AddRef(pClientSite);
 330     This->doc_obj->client = pClientSite;
 331
 332     hostui_setup = This->doc_obj->hostui_setup;
 333
 334     if(!This->doc_obj->hostui) {
 335         IDocHostUIHandler *uihandler;
 336
 337         This->doc_obj->custom_hostui = FALSE;
 338
 339         hres = IOleClientSite_QueryInterface(pClientSite, &IID_IDocHostUIHandler, (void**)&uihandler);
 340         if(SUCCEEDED(hres))
 341             This->doc_obj->hostui = uihandler;
 342     }
 343
 344     if(This->doc_obj->hostui) {
 345         DOCHOSTUIINFO hostinfo;
 346         LPOLESTR key_path = NULL, override_key_path = NULL;
 347         IDocHostUIHandler2 *uihandler2;
 348
 349         memset(&hostinfo, 0, sizeof(DOCHOSTUIINFO));
 350         hostinfo.cbSize = sizeof(DOCHOSTUIINFO);
 351         hres = IDocHostUIHandler_GetHostInfo(This->doc_obj->hostui, &hostinfo);
 352         if(SUCCEEDED(hres)) {
 353             TRACE("hostinfo = {%u %08x %08x %s %s}\n",
 354                     hostinfo.cbSize, hostinfo.dwFlags, hostinfo.dwDoubleClick,
 355                     debugstr_w(hostinfo.pchHostCss), debugstr_w(hostinfo.pchHostNS));
 356             update_hostinfo(This->doc_obj, &hostinfo);
 357             This->doc_obj->hostinfo = hostinfo;
 358         }
 359
 360         if(!hostui_setup) {
 361             hres = IDocHostUIHandler_GetOptionKeyPath(This->doc_obj->hostui, &key_path, 0);
 362             if(hres == S_OK && key_path) {
 363                 if(key_path[0]) {
 364                     /* FIXME: use key_path */
 365                     FIXME("key_path = %s\n", debugstr_w(key_path));
 366                 }
 367                 CoTaskMemFree(key_path);
 368             }
 369
 370             hres = IDocHostUIHandler_QueryInterface(This->doc_obj->hostui, &IID_IDocHostUIHandler2,
 371                     (void**)&uihandler2);
 372             if(SUCCEEDED(hres)) {
 373                 hres = IDocHostUIHandler2_GetOverrideKeyPath(uihandler2, &override_key_path, 0);
 374                 if(hres == S_OK && override_key_path) {
 375                     if(override_key_path[0]) {
 376                         /*FIXME: use override_key_path */
 377                         FIXME("override_key_path = %s\n", debugstr_w(override_key_path));
 378                     }
 379                     CoTaskMemFree(override_key_path);
 380                 }
 381                 IDocHostUIHandler2_Release(uihandler2);
 382             }
 383
 384             This->doc_obj->hostui_setup = TRUE;
 385         }
 386     }
 387
 388     load_settings(This->doc_obj);
 389
 390     /* Native calls here GetWindow. What is it for?
 391      * We don't have anything to do with it here (yet). */
 392     hres = IOleClientSite_QueryInterface(pClientSite, &IID_IOleWindow, (void**)&ole_window);
 393     if(SUCCEEDED(hres)) {
 394         IOleWindow_GetWindow(ole_window, &hwnd);
 395         IOleWindow_Release(ole_window);
 396     }
 397
 398     hres = do_query_service((IUnknown*)pClientSite, &IID_IShellBrowser,
 399             &IID_IBrowserService, (void**)&browser_service);
 400     if(SUCCEEDED(hres)) {
 401         ITravelLog *travel_log;
 402
 403         This->doc_obj->browser_service = (IUnknown*)browser_service;
 404
 405         hres = IBrowserService_GetTravelLog(browser_service, &travel_log);
 406         if(SUCCEEDED(hres))
 407             This->doc_obj->travel_log = travel_log;
 408     }else {
 409         browser_service = NULL;
 410     }
 411
 412     hres = IOleClientSite_QueryInterface(pClientSite, &IID_IOleCommandTarget, (void**)&cmdtrg);
 413     if(SUCCEEDED(hres)) {
 414         VARIANT var;
 415         OLECMD cmd = {OLECMDID_SETPROGRESSTEXT, 0};
 416
 417         This->doc_obj->client_cmdtrg = cmdtrg;
 418
 419         if(!hostui_setup) {
 420             IDocObjectService *doc_object_service;
 421             IWebBrowser2 *wb;
 422
 423             set_document_navigation(This->doc_obj, TRUE);
 424
 425             if(browser_service) {
 426                 hres = IBrowserService_QueryInterface(browser_service,
 427                         &IID_IDocObjectService, (void**)&doc_object_service);
 428                 if(SUCCEEDED(hres)) {
 429                     This->doc_obj->doc_object_service = doc_object_service;
 430
 431                     /*
 432                      * Some embedding routines, esp. in regards to use of IDocObjectService, differ if
 433                      * embedder supports IWebBrowserApp.
 434                      */
 435                     hres = do_query_service((IUnknown*)pClientSite, &IID_IWebBrowserApp, &IID_IWebBrowser2, (void**)&wb);
 436                     if(SUCCEEDED(hres))
 437                         This->doc_obj->webbrowser = (IUnknown*)wb;
 438                 }
 439             }
 440         }
 441
 442         call_docview_84(This->doc_obj);
 443
 444         IOleCommandTarget_QueryStatus(cmdtrg, NULL, 1, &cmd, NULL);
 445
 446         V_VT(&var) = VT_I4;
 447         V_I4(&var) = 0;
 448         IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_SETPROGRESSMAX,
 449                 OLECMDEXECOPT_DONTPROMPTUSER, &var, NULL);
 450         IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_SETPROGRESSPOS,
 451                 OLECMDEXECOPT_DONTPROMPTUSER, &var, NULL);
 452     }
 453
 454     if(This->doc_obj->usermode == UNKNOWN_USERMODE)
 455         IOleControl_OnAmbientPropertyChange(&This->IOleControl_iface, DISPID_AMBIENT_USERMODE);
 456
 457     IOleControl_OnAmbientPropertyChange(&This->IOleControl_iface,
 458             DISPID_AMBIENT_OFFLINEIFNOTCONNECTED);
 459
 460     hres = get_client_disp_property(This->doc_obj->client, DISPID_AMBIENT_SILENT, &silent);
 461     if(SUCCEEDED(hres)) {
 462         if(V_VT(&silent) != VT_BOOL)
 463             WARN("silent = %s\n", debugstr_variant(&silent));
 464         else if(V_BOOL(&silent))
 465             FIXME("silent == true\n");
 466     }
 467
 468     IOleControl_OnAmbientPropertyChange(&This->IOleControl_iface, DISPID_AMBIENT_USERAGENT);
 469     IOleControl_OnAmbientPropertyChange(&This->IOleControl_iface, DISPID_AMBIENT_PALETTE);
 470
 471     return S_OK;
 472 }
 473
 474 static HRESULT WINAPI OleObject_GetClientSite(IOleObject *iface, IOleClientSite **ppClientSite)
 475 {
 476     HTMLDocument *This = impl_from_IOleObject(iface);
 477
 478     TRACE("(%p)->(%p)\n", This, ppClientSite);
 479
 480     if(!ppClientSite)
 481         return E_INVALIDARG;
 482
 483     if(This->doc_obj->client)
 484         IOleClientSite_AddRef(This->doc_obj->client);
 485     *ppClientSite = This->doc_obj->client;
 486
 487     return S_OK;
 488 }
 489
 490 static HRESULT WINAPI OleObject_SetHostNames(IOleObject *iface, LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
 491 {
 492     HTMLDocument *This = impl_from_IOleObject(iface);
 493     FIXME("(%p)->(%s %s)\n", This, debugstr_w(szContainerApp), debugstr_w(szContainerObj));
 494     return E_NOTIMPL;
 495 }
 496
 497 static HRESULT WINAPI OleObject_Close(IOleObject *iface, DWORD dwSaveOption)
 498 {
 499     HTMLDocument *This = impl_from_IOleObject(iface);
 500
 501     TRACE("(%p)->(%08x)\n", This, dwSaveOption);
 502
 503     if(dwSaveOption == OLECLOSE_PROMPTSAVE)
 504         FIXME("OLECLOSE_PROMPTSAVE not implemented\n");
 505
 506     if(This->doc_obj->in_place_active)
 507         IOleInPlaceObjectWindowless_InPlaceDeactivate(&This->IOleInPlaceObjectWindowless_iface);
 508
 509     HTMLDocument_LockContainer(This->doc_obj, FALSE);
 510
 511     if(This->advise_holder)
 512         IOleAdviseHolder_SendOnClose(This->advise_holder);
 513
 514     return S_OK;
 515 }
 516
 517 static HRESULT WINAPI OleObject_SetMoniker(IOleObject *iface, DWORD dwWhichMoniker, IMoniker *pmk)
 518 {
 519     HTMLDocument *This = impl_from_IOleObject(iface);
 520     FIXME("(%p %d %p)->()\n", This, dwWhichMoniker, pmk);
 521     return E_NOTIMPL;
 522 }
 523
 524 static HRESULT WINAPI OleObject_GetMoniker(IOleObject *iface, DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
 525 {
 526     HTMLDocument *This = impl_from_IOleObject(iface);
 527     FIXME("(%p)->(%d %d %p)\n", This, dwAssign, dwWhichMoniker, ppmk);
 528     return E_NOTIMPL;
 529 }
 530
 531 static HRESULT WINAPI OleObject_InitFromData(IOleObject *iface, IDataObject *pDataObject, BOOL fCreation,
 532                                         DWORD dwReserved)
 533 {
 534     HTMLDocument *This = impl_from_IOleObject(iface);
 535     FIXME("(%p)->(%p %x %d)\n", This, pDataObject, fCreation, dwReserved);
 536     return E_NOTIMPL;
 537 }
 538
 539 static HRESULT WINAPI OleObject_GetClipboardData(IOleObject *iface, DWORD dwReserved, IDataObject **ppDataObject)
 540 {
 541     HTMLDocument *This = impl_from_IOleObject(iface);
 542     FIXME("(%p)->(%d %p)\n", This, dwReserved, ppDataObject);
 543     return E_NOTIMPL;
 544 }
 545
 546 static HRESULT WINAPI OleObject_DoVerb(IOleObject *iface, LONG iVerb, LPMSG lpmsg, IOleClientSite *pActiveSite,
 547                                         LONG lindex, HWND hwndParent, LPCRECT lprcPosRect)
 548 {
 549     HTMLDocument *This = impl_from_IOleObject(iface);
 550     IOleDocumentSite *pDocSite;
 551     HRESULT hres;
 552
 553     TRACE("(%p)->(%d %p %p %d %p %p)\n", This, iVerb, lpmsg, pActiveSite, lindex, hwndParent, lprcPosRect);
 554
 555     if(iVerb != OLEIVERB_SHOW && iVerb != OLEIVERB_UIACTIVATE && iVerb != OLEIVERB_INPLACEACTIVATE) {
 556         FIXME("iVerb = %d not supported\n", iVerb);
 557         return E_NOTIMPL;
 558     }
 559
 560     if(!pActiveSite)
 561         pActiveSite = This->doc_obj->client;
 562
 563     hres = IOleClientSite_QueryInterface(pActiveSite, &IID_IOleDocumentSite, (void**)&pDocSite);
 564     if(SUCCEEDED(hres)) {
 565         HTMLDocument_LockContainer(This->doc_obj, TRUE);
 566
 567         /* FIXME: Create new IOleDocumentView. See CreateView for more info. */
 568         hres = IOleDocumentSite_ActivateMe(pDocSite, &This->IOleDocumentView_iface);
 569         IOleDocumentSite_Release(pDocSite);
 570     }else {
 571         hres = IOleDocumentView_UIActivate(&This->IOleDocumentView_iface, TRUE);
 572         if(SUCCEEDED(hres)) {
 573             if(lprcPosRect) {
 574                 RECT rect; /* We need to pass rect as not const pointer */
 575                 rect = *lprcPosRect;
 576                 IOleDocumentView_SetRect(&This->IOleDocumentView_iface, &rect);
 577             }
 578             IOleDocumentView_Show(&This->IOleDocumentView_iface, TRUE);
 579         }
 580     }
 581
 582     return hres;
 583 }
 584
 585 static HRESULT WINAPI OleObject_EnumVerbs(IOleObject *iface, IEnumOLEVERB **ppEnumOleVerb)
 586 {
 587     HTMLDocument *This = impl_from_IOleObject(iface);
 588     FIXME("(%p)->(%p)\n", This, ppEnumOleVerb);
 589     return E_NOTIMPL;
 590 }
 591
 592 static HRESULT WINAPI OleObject_Update(IOleObject *iface)
 593 {
 594     HTMLDocument *This = impl_from_IOleObject(iface);
 595     FIXME("(%p)\n", This);
 596     return E_NOTIMPL;
 597 }
 598
 599 static HRESULT WINAPI OleObject_IsUpToDate(IOleObject *iface)
 600 {
 601     HTMLDocument *This = impl_from_IOleObject(iface);
 602     FIXME("(%p)\n", This);
 603     return E_NOTIMPL;
 604 }
 605
 606 static HRESULT WINAPI OleObject_GetUserClassID(IOleObject *iface, CLSID *pClsid)
 607 {
 608     HTMLDocument *This = impl_from_IOleObject(iface);
 609
 610     TRACE("(%p)->(%p)\n", This, pClsid);
 611
 612     if(!pClsid)
 613         return E_INVALIDARG;
 614
 615     *pClsid = CLSID_HTMLDocument;
 616     return S_OK;
 617 }
 618
 619 static HRESULT WINAPI OleObject_GetUserType(IOleObject *iface, DWORD dwFormOfType, LPOLESTR *pszUserType)
 620 {
 621     HTMLDocument *This = impl_from_IOleObject(iface);
 622     FIXME("(%p)->(%d %p)\n", This, dwFormOfType, pszUserType);
 623     return E_NOTIMPL;
 624 }
 625
 626 static HRESULT WINAPI OleObject_SetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 627 {
 628     HTMLDocument *This = impl_from_IOleObject(iface);
 629     FIXME("(%p)->(%d %p)\n", This, dwDrawAspect, psizel);
 630     return E_NOTIMPL;
 631 }
 632
 633 static HRESULT WINAPI OleObject_GetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 634 {
 635     HTMLDocument *This = impl_from_IOleObject(iface);
 636     FIXME("(%p)->(%d %p)\n", This, dwDrawAspect, psizel);
 637     return E_NOTIMPL;
 638 }
 639
 640 static HRESULT WINAPI OleObject_Advise(IOleObject *iface, IAdviseSink *pAdvSink, DWORD *pdwConnection)
 641 {
 642     HTMLDocument *This = impl_from_IOleObject(iface);
 643     TRACE("(%p)->(%p %p)\n", This, pAdvSink, pdwConnection);
 644
 645     if(!pdwConnection)
 646         return E_INVALIDARG;
 647
 648     if(!pAdvSink) {
 649         *pdwConnection = 0;
 650         return E_INVALIDARG;
 651     }
 652
 653     if(!This->advise_holder) {
 654         CreateOleAdviseHolder(&This->advise_holder);
 655         if(!This->advise_holder)
 656             return E_OUTOFMEMORY;
 657     }
 658
 659     return IOleAdviseHolder_Advise(This->advise_holder, pAdvSink, pdwConnection);
 660 }
 661
 662 static HRESULT WINAPI OleObject_Unadvise(IOleObject *iface, DWORD dwConnection)
 663 {
 664     HTMLDocument *This = impl_from_IOleObject(iface);
 665     TRACE("(%p)->(%d)\n", This, dwConnection);
 666
 667     if(!This->advise_holder)
 668         return OLE_E_NOCONNECTION;
 669
 670     return IOleAdviseHolder_Unadvise(This->advise_holder, dwConnection);
 671 }
 672
 673 static HRESULT WINAPI OleObject_EnumAdvise(IOleObject *iface, IEnumSTATDATA **ppenumAdvise)
 674 {
 675     HTMLDocument *This = impl_from_IOleObject(iface);
 676
 677     if(!This->advise_holder) {
 678         *ppenumAdvise = NULL;
 679         return S_OK;
 680     }
 681
 682     return IOleAdviseHolder_EnumAdvise(This->advise_holder, ppenumAdvise);
 683 }
 684
 685 static HRESULT WINAPI OleObject_GetMiscStatus(IOleObject *iface, DWORD dwAspect, DWORD *pdwStatus)
 686 {
 687     HTMLDocument *This = impl_from_IOleObject(iface);
 688     FIXME("(%p)->(%d %p)\n", This, dwAspect, pdwStatus);
 689     return E_NOTIMPL;
 690 }
 691
 692 static HRESULT WINAPI OleObject_SetColorScheme(IOleObject *iface, LOGPALETTE *pLogpal)
 693 {
 694     HTMLDocument *This = impl_from_IOleObject(iface);
 695     FIXME("(%p)->(%p)\n", This, pLogpal);
 696     return E_NOTIMPL;
 697 }
 698
 699 static const IOleObjectVtbl OleObjectVtbl = {
 700     OleObject_QueryInterface,
 701     OleObject_AddRef,
 702     OleObject_Release,
 703     OleObject_SetClientSite,
 704     OleObject_GetClientSite,
 705     OleObject_SetHostNames,
 706     OleObject_Close,
 707     OleObject_SetMoniker,
 708     OleObject_GetMoniker,
 709     OleObject_InitFromData,
 710     OleObject_GetClipboardData,
 711     OleObject_DoVerb,
 712     OleObject_EnumVerbs,
 713     OleObject_Update,
 714     OleObject_IsUpToDate,
 715     OleObject_GetUserClassID,
 716     OleObject_GetUserType,
 717     OleObject_SetExtent,
 718     OleObject_GetExtent,
 719     OleObject_Advise,
 720     OleObject_Unadvise,
 721     OleObject_EnumAdvise,
 722     OleObject_GetMiscStatus,
 723     OleObject_SetColorScheme
 724 };
 725
 726 /**********************************************************
 727  * IOleDocument implementation
 728  */
 729
 730 static inline HTMLDocument *impl_from_IOleDocument(IOleDocument *iface)
 731 {
 732     return CONTAINING_RECORD(iface, HTMLDocument, IOleDocument_iface);
 733 }
 734
 735 static HRESULT WINAPI OleDocument_QueryInterface(IOleDocument *iface, REFIID riid, void **ppv)
 736 {
 737     HTMLDocument *This = impl_from_IOleDocument(iface);
 738     return htmldoc_query_interface(This, riid, ppv);
 739 }
 740
 741 static ULONG WINAPI OleDocument_AddRef(IOleDocument *iface)
 742 {
 743     HTMLDocument *This = impl_from_IOleDocument(iface);
 744     return htmldoc_addref(This);
 745 }
 746
 747 static ULONG WINAPI OleDocument_Release(IOleDocument *iface)
 748 {
 749     HTMLDocument *This = impl_from_IOleDocument(iface);
 750     return htmldoc_release(This);
 751 }
 752
 753 static HRESULT WINAPI OleDocument_CreateView(IOleDocument *iface, IOleInPlaceSite *pIPSite, IStream *pstm,
 754                                    DWORD dwReserved, IOleDocumentView **ppView)
 755 {
 756     HTMLDocument *This = impl_from_IOleDocument(iface);
 757     HRESULT hres;
 758
 759     TRACE("(%p)->(%p %p %d %p)\n", This, pIPSite, pstm, dwReserved, ppView);
 760
 761     if(!ppView)
 762         return E_INVALIDARG;
 763
 764     /* FIXME:
 765      * Windows implementation creates new IOleDocumentView when function is called for the
 766      * first time and returns E_FAIL when it is called for the second time, but it doesn't matter
 767      * if the application uses returned interfaces, passed to ActivateMe or returned by
 768      * QueryInterface, so there is no reason to create new interface. This needs more testing.
 769      */
 770
 771     if(pIPSite) {
 772         hres = IOleDocumentView_SetInPlaceSite(&This->IOleDocumentView_iface, pIPSite);
 773         if(FAILED(hres))
 774             return hres;
 775     }
 776
 777     if(pstm)
 778         FIXME("pstm is not supported\n");
 779
 780     IOleDocumentView_AddRef(&This->IOleDocumentView_iface);
 781     *ppView = &This->IOleDocumentView_iface;
 782     return S_OK;
 783 }
 784
 785 static HRESULT WINAPI OleDocument_GetDocMiscStatus(IOleDocument *iface, DWORD *pdwStatus)
 786 {
 787     HTMLDocument *This = impl_from_IOleDocument(iface);
 788     FIXME("(%p)->(%p)\n", This, pdwStatus);
 789     return E_NOTIMPL;
 790 }
 791
 792 static HRESULT WINAPI OleDocument_EnumViews(IOleDocument *iface, IEnumOleDocumentViews **ppEnum,
 793                                    IOleDocumentView **ppView)
 794 {
 795     HTMLDocument *This = impl_from_IOleDocument(iface);
 796     FIXME("(%p)->(%p %p)\n", This, ppEnum, ppView);
 797     return E_NOTIMPL;
 798 }
 799
 800 static const IOleDocumentVtbl OleDocumentVtbl = {
 801     OleDocument_QueryInterface,
 802     OleDocument_AddRef,
 803     OleDocument_Release,
 804     OleDocument_CreateView,
 805     OleDocument_GetDocMiscStatus,
 806     OleDocument_EnumViews
 807 };
 808
 809 /**********************************************************
 810  * IOleControl implementation
 811  */
 812
 813 static inline HTMLDocument *impl_from_IOleControl(IOleControl *iface)
 814 {
 815     return CONTAINING_RECORD(iface, HTMLDocument, IOleControl_iface);
 816 }
 817
 818 static HRESULT WINAPI OleControl_QueryInterface(IOleControl *iface, REFIID riid, void **ppv)
 819 {
 820     HTMLDocument *This = impl_from_IOleControl(iface);
 821     return htmldoc_query_interface(This, riid, ppv);
 822 }
 823
 824 static ULONG WINAPI OleControl_AddRef(IOleControl *iface)
 825 {
 826     HTMLDocument *This = impl_from_IOleControl(iface);
 827     return htmldoc_addref(This);
 828 }
 829
 830 static ULONG WINAPI OleControl_Release(IOleControl *iface)
 831 {
 832     HTMLDocument *This = impl_from_IOleControl(iface);
 833     return htmldoc_release(This);
 834 }
 835
 836 static HRESULT WINAPI OleControl_GetControlInfo(IOleControl *iface, CONTROLINFO *pCI)
 837 {
 838     HTMLDocument *This = impl_from_IOleControl(iface);
 839     FIXME("(%p)->(%p)\n", This, pCI);
 840     return E_NOTIMPL;
 841 }
 842
 843 static HRESULT WINAPI OleControl_OnMnemonic(IOleControl *iface, MSG *pMsg)
 844 {
 845     HTMLDocument *This = impl_from_IOleControl(iface);
 846     FIXME("(%p)->(%p)\n", This, pMsg);
 847     return E_NOTIMPL;
 848 }
 849
 850 HRESULT get_client_disp_property(IOleClientSite *client, DISPID dispid, VARIANT *res)
 851 {
 852     IDispatch *disp = NULL;
 853     DISPPARAMS dispparams = {NULL, 0};
 854     UINT err;
 855     HRESULT hres;
 856
 857     hres = IOleClientSite_QueryInterface(client, &IID_IDispatch, (void**)&disp);
 858     if(FAILED(hres)) {
 859         TRACE("Could not get IDispatch\n");
 860         return hres;
 861     }
 862
 863     VariantInit(res);
 864
 865     hres = IDispatch_Invoke(disp, dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT,
 866             DISPATCH_PROPERTYGET, &dispparams, res, NULL, &err);
 867
 868     IDispatch_Release(disp);
 869
 870     return hres;
 871 }
 872
 873 static HRESULT on_change_dlcontrol(HTMLDocument *This)
 874 {
 875     VARIANT res;
 876     HRESULT hres;
 877
 878     hres = get_client_disp_property(This->doc_obj->client, DISPID_AMBIENT_DLCONTROL, &res);
 879     if(SUCCEEDED(hres))
 880         FIXME("unsupported dlcontrol %08x\n", V_I4(&res));
 881
 882     return S_OK;
 883 }
 884
 885 static HRESULT WINAPI OleControl_OnAmbientPropertyChange(IOleControl *iface, DISPID dispID)
 886 {
 887     HTMLDocument *This = impl_from_IOleControl(iface);
 888     IOleClientSite *client;
 889     VARIANT res;
 890     HRESULT hres;
 891
 892     client = This->doc_obj->client;
 893     if(!client) {
 894         TRACE("client = NULL\n");
 895         return S_OK;
 896     }
 897
 898     switch(dispID) {
 899     case DISPID_AMBIENT_USERMODE:
 900         TRACE("(%p)->(DISPID_AMBIENT_USERMODE)\n", This);
 901         hres = get_client_disp_property(client, DISPID_AMBIENT_USERMODE, &res);
 902         if(FAILED(hres))
 903             return S_OK;
 904
 905         if(V_VT(&res) == VT_BOOL) {
 906             if(V_BOOL(&res)) {
 907                 This->doc_obj->usermode = BROWSEMODE;
 908             }else {
 909                 FIXME("edit mode is not supported\n");
 910                 This->doc_obj->usermode = EDITMODE;
 911             }
 912         }else {
 913             FIXME("usermode=%s\n", debugstr_variant(&res));
 914         }
 915         return S_OK;
 916     case DISPID_AMBIENT_DLCONTROL:
 917         TRACE("(%p)->(DISPID_AMBIENT_DLCONTROL)\n", This);
 918         return on_change_dlcontrol(This);
 919     case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED:
 920         TRACE("(%p)->(DISPID_AMBIENT_OFFLINEIFNOTCONNECTED)\n", This);
 921         on_change_dlcontrol(This);
 922         hres = get_client_disp_property(client, DISPID_AMBIENT_OFFLINEIFNOTCONNECTED, &res);
 923         if(FAILED(hres))
 924             return S_OK;
 925
 926         if(V_VT(&res) == VT_BOOL) {
 927             if(V_BOOL(&res)) {
 928                 FIXME("offline connection is not supported\n");
 929                 hres = E_FAIL;
 930             }
 931         }else {
 932             FIXME("offlineconnected=%s\n", debugstr_variant(&res));
 933         }
 934         return S_OK;
 935     case DISPID_AMBIENT_SILENT:
 936         TRACE("(%p)->(DISPID_AMBIENT_SILENT)\n", This);
 937         on_change_dlcontrol(This);
 938         hres = get_client_disp_property(client, DISPID_AMBIENT_SILENT, &res);
 939         if(FAILED(hres))
 940             return S_OK;
 941
 942         if(V_VT(&res) == VT_BOOL) {
 943             if(V_BOOL(&res)) {
 944                 FIXME("silent mode is not supported\n");
 945                 hres = E_FAIL;
 946             }
 947         }else {
 948             FIXME("silent=%s\n", debugstr_variant(&res));
 949         }
 950         return S_OK;
 951     case DISPID_AMBIENT_USERAGENT:
 952         TRACE("(%p)->(DISPID_AMBIENT_USERAGENT)\n", This);
 953         hres = get_client_disp_property(client, DISPID_AMBIENT_USERAGENT, &res);
 954         if(FAILED(hres))
 955             return S_OK;
 956
 957         FIXME("not supported AMBIENT_USERAGENT\n");
 958         hres = E_FAIL;
 959         return S_OK;
 960     case DISPID_AMBIENT_PALETTE:
 961         TRACE("(%p)->(DISPID_AMBIENT_PALETTE)\n", This);
 962         hres = get_client_disp_property(client, DISPID_AMBIENT_PALETTE, &res);
 963         if(FAILED(hres))
 964             return S_OK;
 965
 966         FIXME("not supported AMBIENT_PALETTE\n");
 967         hres = E_FAIL;
 968         return S_OK;
 969     }
 970
 971     FIXME("(%p) unsupported dispID=%d\n", This, dispID);
 972     return E_FAIL;
 973 }
 974
 975 static HRESULT WINAPI OleControl_FreezeEvents(IOleControl *iface, BOOL bFreeze)
 976 {
 977     HTMLDocument *This = impl_from_IOleControl(iface);
 978     FIXME("(%p)->(%x)\n", This, bFreeze);
 979     return E_NOTIMPL;
 980 }
 981
 982 static const IOleControlVtbl OleControlVtbl = {
 983     OleControl_QueryInterface,
 984     OleControl_AddRef,
 985     OleControl_Release,
 986     OleControl_GetControlInfo,
 987     OleControl_OnMnemonic,
 988     OleControl_OnAmbientPropertyChange,
 989     OleControl_FreezeEvents
 990 };
 991
 992 /**********************************************************
 993  * IObjectWithSite implementation
 994  */
 995
 996 static inline HTMLDocument *impl_from_IObjectWithSite(IObjectWithSite *iface)
 997 {
 998     return CONTAINING_RECORD(iface, HTMLDocument, IObjectWithSite_iface);
 999 }
1000
1001 static HRESULT WINAPI ObjectWithSite_QueryInterface(IObjectWithSite *iface, REFIID riid, void **ppv)
1002 {
1003     HTMLDocument *This = impl_from_IObjectWithSite(iface);
1004     return htmldoc_query_interface(This, riid, ppv);
1005 }
1006
1007 static ULONG WINAPI ObjectWithSite_AddRef(IObjectWithSite *iface)
1008 {
1009     HTMLDocument *This = impl_from_IObjectWithSite(iface);
1010     return htmldoc_addref(This);
1011 }
1012
1013 static ULONG WINAPI ObjectWithSite_Release(IObjectWithSite *iface)
1014 {
1015     HTMLDocument *This = impl_from_IObjectWithSite(iface);
1016     return htmldoc_release(This);
1017 }
1018
1019 static HRESULT WINAPI ObjectWithSite_SetSite(IObjectWithSite *iface, IUnknown *pUnkSite)
1020 {
1021     HTMLDocument *This = impl_from_IObjectWithSite(iface);
1022     FIXME("(%p)->(%p)\n", This, pUnkSite);
1023     return E_NOTIMPL;
1024 }
1025
1026 static HRESULT WINAPI ObjectWithSite_GetSite(IObjectWithSite* iface, REFIID riid, PVOID *ppvSite)
1027 {
1028     HTMLDocument *This = impl_from_IObjectWithSite(iface);
1029     FIXME("(%p)->(%p)\n", This, ppvSite);
1030     return E_NOTIMPL;
1031 }
1032
1033 static const IObjectWithSiteVtbl ObjectWithSiteVtbl = {
1034     ObjectWithSite_QueryInterface,
1035     ObjectWithSite_AddRef,
1036     ObjectWithSite_Release,
1037     ObjectWithSite_SetSite,
1038     ObjectWithSite_GetSite
1039 };
1040
1041 /**********************************************************
1042  * IOleContainer implementation
1043  */
1044
1045 static inline HTMLDocument *impl_from_IOleContainer(IOleContainer *iface)
1046 {
1047     return CONTAINING_RECORD(iface, HTMLDocument, IOleContainer_iface);
1048 }
1049
1050 static HRESULT WINAPI OleContainer_QueryInterface(IOleContainer *iface, REFIID riid, void **ppv)
1051 {
1052     HTMLDocument *This = impl_from_IOleContainer(iface);
1053     return htmldoc_query_interface(This, riid, ppv);
1054 }
1055
1056 static ULONG WINAPI OleContainer_AddRef(IOleContainer *iface)
1057 {
1058     HTMLDocument *This = impl_from_IOleContainer(iface);
1059     return htmldoc_addref(This);
1060 }
1061
1062 static ULONG WINAPI OleContainer_Release(IOleContainer *iface)
1063 {
1064     HTMLDocument *This = impl_from_IOleContainer(iface);
1065     return htmldoc_release(This);
1066 }
1067
1068 static HRESULT WINAPI OleContainer_ParseDisplayName(IOleContainer *iface, IBindCtx *pbc, LPOLESTR pszDisplayName,
1069         ULONG *pchEaten, IMoniker **ppmkOut)
1070 {
1071     HTMLDocument *This = impl_from_IOleContainer(iface);
1072     FIXME("(%p)->(%p %s %p %p)\n", This, pbc, debugstr_w(pszDisplayName), pchEaten, ppmkOut);
1073     return E_NOTIMPL;
1074 }
1075
1076 static HRESULT WINAPI OleContainer_EnumObjects(IOleContainer *iface, DWORD grfFlags, IEnumUnknown **ppenum)
1077 {
1078     HTMLDocument *This = impl_from_IOleContainer(iface);
1079     EnumUnknown *ret;
1080
1081     TRACE("(%p)->(%x %p)\n", This, grfFlags, ppenum);
1082
1083     ret = heap_alloc(sizeof(*ret));
1084     if(!ret)
1085         return E_OUTOFMEMORY;
1086
1087     ret->IEnumUnknown_iface.lpVtbl = &EnumUnknownVtbl;
1088     ret->ref = 1;
1089
1090     *ppenum = &ret->IEnumUnknown_iface;
1091     return S_OK;
1092 }
1093
1094 static HRESULT WINAPI OleContainer_LockContainer(IOleContainer *iface, BOOL fLock)
1095 {
1096     HTMLDocument *This = impl_from_IOleContainer(iface);
1097     FIXME("(%p)->(%x)\n", This, fLock);
1098     return E_NOTIMPL;
1099 }
1100
1101 static const IOleContainerVtbl OleContainerVtbl = {
1102     OleContainer_QueryInterface,
1103     OleContainer_AddRef,
1104     OleContainer_Release,
1105     OleContainer_ParseDisplayName,
1106     OleContainer_EnumObjects,
1107     OleContainer_LockContainer
1108 };
1109
1110 static inline HTMLDocumentObj *impl_from_ITargetContainer(ITargetContainer *iface)
1111 {
1112     return CONTAINING_RECORD(iface, HTMLDocumentObj, ITargetContainer_iface);
1113 }
1114
1115 static HRESULT WINAPI TargetContainer_QueryInterface(ITargetContainer *iface, REFIID riid, void **ppv)
1116 {
1117     HTMLDocumentObj *This = impl_from_ITargetContainer(iface);
1118     return ICustomDoc_QueryInterface(&This->ICustomDoc_iface, riid, ppv);
1119 }
1120
1121 static ULONG WINAPI TargetContainer_AddRef(ITargetContainer *iface)
1122 {
1123     HTMLDocumentObj *This = impl_from_ITargetContainer(iface);
1124     return ICustomDoc_AddRef(&This->ICustomDoc_iface);
1125 }
1126
1127 static ULONG WINAPI TargetContainer_Release(ITargetContainer *iface)
1128 {
1129     HTMLDocumentObj *This = impl_from_ITargetContainer(iface);
1130     return ICustomDoc_Release(&This->ICustomDoc_iface);
1131 }
1132
1133 static HRESULT WINAPI TargetContainer_GetFrameUrl(ITargetContainer *iface, LPWSTR *ppszFrameSrc)
1134 {
1135     HTMLDocumentObj *This = impl_from_ITargetContainer(iface);
1136     FIXME("(%p)->(%p)\n", This, ppszFrameSrc);
1137     return E_NOTIMPL;
1138 }
1139
1140 static HRESULT WINAPI TargetContainer_GetFramesContainer(ITargetContainer *iface, IOleContainer **ppContainer)
1141 {
1142     HTMLDocumentObj *This = impl_from_ITargetContainer(iface);
1143
1144     TRACE("(%p)->(%p)\n", This, ppContainer);
1145
1146     /* NOTE: we should return wrapped interface here */
1147     IOleContainer_AddRef(&This->basedoc.IOleContainer_iface);
1148     *ppContainer = &This->basedoc.IOleContainer_iface;
1149     return S_OK;
1150 }
1151
1152 static const ITargetContainerVtbl TargetContainerVtbl = {
1153     TargetContainer_QueryInterface,
1154     TargetContainer_AddRef,
1155     TargetContainer_Release,
1156     TargetContainer_GetFrameUrl,
1157     TargetContainer_GetFramesContainer
1158 };
1159
1160 void TargetContainer_Init(HTMLDocumentObj *This)
1161 {
1162     This->ITargetContainer_iface.lpVtbl = &TargetContainerVtbl;
1163 }
1164
1165 /**********************************************************
1166  * IObjectSafety implementation
1167  */
1168
1169 static inline HTMLDocument *impl_from_IObjectSafety(IObjectSafety *iface)
1170 {
1171     return CONTAINING_RECORD(iface, HTMLDocument, IObjectSafety_iface);
1172 }
1173
1174 static HRESULT WINAPI ObjectSafety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
1175 {
1176     HTMLDocument *This = impl_from_IObjectSafety(iface);
1177     return htmldoc_query_interface(This, riid, ppv);
1178 }
1179
1180 static ULONG WINAPI ObjectSafety_AddRef(IObjectSafety *iface)
1181 {
1182     HTMLDocument *This = impl_from_IObjectSafety(iface);
1183     return htmldoc_addref(This);
1184 }
1185
1186 static ULONG WINAPI ObjectSafety_Release(IObjectSafety *iface)
1187 {
1188     HTMLDocument *This = impl_from_IObjectSafety(iface);
1189     return htmldoc_release(This);
1190 }
1191
1192 static HRESULT WINAPI ObjectSafety_GetInterfaceSafetyOptions(IObjectSafety *iface,
1193         REFIID riid, DWORD *pdwSupportedOptions, DWORD *pdwEnabledOptions)
1194 {
1195     HTMLDocument *This = impl_from_IObjectSafety(iface);
1196     FIXME("(%p)->(%s %p %p)\n", This, debugstr_guid(riid), pdwSupportedOptions, pdwEnabledOptions);
1197     return E_NOTIMPL;
1198 }
1199
1200 static HRESULT WINAPI ObjectSafety_SetInterfaceSafetyOptions(IObjectSafety *iface,
1201         REFIID riid, DWORD dwOptionSetMask, DWORD dwEnabledOptions)
1202 {
1203     HTMLDocument *This = impl_from_IObjectSafety(iface);
1204     FIXME("(%p)->(%s %x %x)\n", This, debugstr_guid(riid), dwOptionSetMask, dwEnabledOptions);
1205
1206     if(IsEqualGUID(&IID_IPersistMoniker, riid) &&
1207             dwOptionSetMask==INTERFACESAFE_FOR_UNTRUSTED_DATA &&
1208             dwEnabledOptions==INTERFACESAFE_FOR_UNTRUSTED_DATA)
1209         return S_OK;
1210
1211     return E_NOTIMPL;
1212 }
1213
1214 static const IObjectSafetyVtbl ObjectSafetyVtbl = {
1215     ObjectSafety_QueryInterface,
1216     ObjectSafety_AddRef,
1217     ObjectSafety_Release,
1218     ObjectSafety_GetInterfaceSafetyOptions,
1219     ObjectSafety_SetInterfaceSafetyOptions
1220 };
1221
1222 void HTMLDocument_LockContainer(HTMLDocumentObj *This, BOOL fLock)
1223 {
1224     IOleContainer *container;
1225     HRESULT hres;
1226
1227     if(!This->client || This->container_locked == fLock)
1228         return;
1229
1230     hres = IOleClientSite_GetContainer(This->client, &container);
1231     if(SUCCEEDED(hres)) {
1232         IOleContainer_LockContainer(container, fLock);
1233         This->container_locked = fLock;
1234         IOleContainer_Release(container);
1235     }
1236 }
1237
1238 void HTMLDocument_OleObj_Init(HTMLDocument *This)
1239 {
1240     This->IOleObject_iface.lpVtbl = &OleObjectVtbl;
1241     This->IOleDocument_iface.lpVtbl = &OleDocumentVtbl;
1242     This->IOleControl_iface.lpVtbl = &OleControlVtbl;
1243     This->IObjectWithSite_iface.lpVtbl = &ObjectWithSiteVtbl;
1244     This->IOleContainer_iface.lpVtbl = &OleContainerVtbl;
1245     This->IObjectSafety_iface.lpVtbl = &ObjectSafetyVtbl;
1246 }