git.oblomov.eu Git - wine/blob - 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "config.h"
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "ole2.h"
  30 #include "shlguid.h"
  31 #include "mshtmdid.h"
  32 #include "idispids.h"
  33
  34 #include "wine/debug.h"
  35
  36 #include "mshtml_private.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  39
  40 /**********************************************************
  41  * IOleObject implementation
  42  */
  43
  44 #define OLEOBJ_THIS(iface) DEFINE_THIS(HTMLDocument, OleObject, iface)
  45
  46 static HRESULT WINAPI OleObject_QueryInterface(IOleObject *iface, REFIID riid, void **ppvObject)
  47 {
  48     HTMLDocument *This = OLEOBJ_THIS(iface);
  49     return IHTMLDocument2_QueryInterface(HTMLDOC(This), riid, ppvObject);
  50 }
  51
  52 static ULONG WINAPI OleObject_AddRef(IOleObject *iface)
  53 {
  54     HTMLDocument *This = OLEOBJ_THIS(iface);
  55     return IHTMLDocument2_AddRef(HTMLDOC(This));
  56 }
  57
  58 static ULONG WINAPI OleObject_Release(IOleObject *iface)
  59 {
  60     HTMLDocument *This = OLEOBJ_THIS(iface);
  61     return IHTMLDocument2_Release(HTMLDOC(This));
  62 }
  63
  64 static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite *pClientSite)
  65 {
  66     HTMLDocument *This = OLEOBJ_THIS(iface);
  67     IDocHostUIHandler *pDocHostUIHandler = NULL;
  68     IOleCommandTarget *cmdtrg = NULL;
  69     HRESULT hres;
  70
  71     TRACE("(%p)->(%p)\n", This, pClientSite);
  72
  73     if(pClientSite == This->client)
  74         return S_OK;
  75
  76     if(This->client)
  77         IOleClientSite_Release(This->client);
  78
  79     if(This->hostui)
  80         IDocHostUIHandler_Release(This->hostui);
  81
  82     if(!pClientSite) {
  83         This->client = NULL;
  84         return S_OK;
  85     }
  86
  87     hres = IOleObject_QueryInterface(pClientSite, &IID_IDocHostUIHandler, (void**)&pDocHostUIHandler);
  88     if(SUCCEEDED(hres)) {
  89         DOCHOSTUIINFO hostinfo;
  90         LPOLESTR key_path = NULL, override_key_path = NULL;
  91         IDocHostUIHandler2 *pDocHostUIHandler2;
  92
  93         memset(&hostinfo, 0, sizeof(DOCHOSTUIINFO));
  94         hostinfo.cbSize = sizeof(DOCHOSTUIINFO);
  95         hres = IDocHostUIHandler_GetHostInfo(pDocHostUIHandler, &hostinfo);
  96         if(SUCCEEDED(hres))
  97             /* FIXME: use hostinfo */
  98             TRACE("hostinfo = {%lu %08lx %08lx %s %s}\n",
  99                     hostinfo.cbSize, hostinfo.dwFlags, hostinfo.dwDoubleClick,
 100                     debugstr_w(hostinfo.pchHostCss), debugstr_w(hostinfo.pchHostNS));
 101
 102         if(!This->has_key_path) {
 103             hres = IDocHostUIHandler_GetOptionKeyPath(pDocHostUIHandler, &key_path, 0);
 104             if(hres == S_OK && key_path) {
 105                 if(key_path[0]) {
 106                     /* FIXME: use key_path */
 107                     TRACE("key_path = %s\n", debugstr_w(key_path));
 108                 }
 109                 CoTaskMemFree(key_path);
 110             }
 111
 112             hres = IDocHostUIHandler_QueryInterface(pDocHostUIHandler, &IID_IDocHostUIHandler2,
 113                     (void**)&pDocHostUIHandler2);
 114             if(SUCCEEDED(hres)) {
 115                 hres = IDocHostUIHandler2_GetOverrideKeyPath(pDocHostUIHandler2, &override_key_path, 0);
 116                 if(hres == S_OK && override_key_path && override_key_path[0]) {
 117                     if(override_key_path[0]) {
 118                         /*FIXME: use override_key_path */
 119                         TRACE("override_key_path = %s\n", debugstr_w(override_key_path));
 120                     }
 121                     CoTaskMemFree(override_key_path);
 122                 }
 123             }
 124
 125             This->has_key_path = TRUE;
 126         }
 127     }
 128
 129     /* Native calls here GetWindow. What is it for?
 130      * We don't have anything to do with it here (yet). */
 131     if(pClientSite) {
 132         IOleWindow *pOleWindow = NULL;
 133         HWND hwnd;
 134
 135         hres = IOleClientSite_QueryInterface(pClientSite, &IID_IOleWindow, (void**)&pOleWindow);
 136         if(SUCCEEDED(hres)) {
 137             IOleWindow_GetWindow(pOleWindow, &hwnd);
 138             IOleWindow_Release(pOleWindow);
 139         }
 140     }
 141
 142     hres = IOleClientSite_QueryInterface(pClientSite, &IID_IOleCommandTarget, (void**)&cmdtrg);
 143     if(SUCCEEDED(hres)) {
 144         VARIANT var;
 145         OLECMD cmd = {OLECMDID_SETPROGRESSTEXT, 0};
 146
 147         IOleCommandTarget_QueryStatus(cmdtrg, NULL, 1, &cmd, NULL);
 148
 149         V_VT(&var) = VT_I4;
 150         V_I4(&var) = 0;
 151         IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_SETPROGRESSMAX, 0, &var, NULL);
 152         IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_SETPROGRESSPOS, 0, &var, NULL);
 153
 154         IOleCommandTarget_Release(cmdtrg);
 155     }
 156
 157     IOleClientSite_AddRef(pClientSite);
 158     This->client = pClientSite;
 159     This->hostui = pDocHostUIHandler;
 160
 161     IOleControl_OnAmbientPropertyChange(CONTROL(This), DISPID_AMBIENT_USERMODE);
 162     IOleControl_OnAmbientPropertyChange(CONTROL(This), DISPID_AMBIENT_OFFLINEIFNOTCONNECTED);
 163     IOleControl_OnAmbientPropertyChange(CONTROL(This), DISPID_AMBIENT_SILENT);
 164     IOleControl_OnAmbientPropertyChange(CONTROL(This), DISPID_AMBIENT_USERAGENT);
 165     IOleControl_OnAmbientPropertyChange(CONTROL(This), DISPID_AMBIENT_PALETTE);
 166
 167     return S_OK;
 168 }
 169
 170 static HRESULT WINAPI OleObject_GetClientSite(IOleObject *iface, IOleClientSite **ppClientSite)
 171 {
 172     HTMLDocument *This = OLEOBJ_THIS(iface);
 173
 174     TRACE("(%p)->(%p)\n", This, ppClientSite);
 175
 176     if(!ppClientSite)
 177         return E_INVALIDARG;
 178
 179     if(This->client)
 180         IOleClientSite_AddRef(This->client);
 181     *ppClientSite = This->client;
 182
 183     return S_OK;
 184 }
 185
 186 static HRESULT WINAPI OleObject_SetHostNames(IOleObject *iface, LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
 187 {
 188     HTMLDocument *This = OLEOBJ_THIS(iface);
 189     FIXME("(%p)->(%s %s)\n", This, debugstr_w(szContainerApp), debugstr_w(szContainerObj));
 190     return E_NOTIMPL;
 191 }
 192
 193 static HRESULT WINAPI OleObject_Close(IOleObject *iface, DWORD dwSaveOption)
 194 {
 195     HTMLDocument *This = OLEOBJ_THIS(iface);
 196
 197     TRACE("(%p)->(%08lx)\n", This, dwSaveOption);
 198
 199     if(dwSaveOption == OLECLOSE_PROMPTSAVE)
 200         FIXME("OLECLOSE_PROMPTSAVE not implemented\n");
 201
 202     if(This->in_place_active)
 203         IOleInPlaceObjectWindowless_InPlaceDeactivate(INPLACEWIN(This));
 204
 205     HTMLDocument_LockContainer(This, FALSE);
 206
 207     return S_OK;
 208 }
 209
 210 static HRESULT WINAPI OleObject_SetMoniker(IOleObject *iface, DWORD dwWhichMoniker, IMoniker *pmk)
 211 {
 212     HTMLDocument *This = OLEOBJ_THIS(iface);
 213     FIXME("(%p %ld %p)->()\n", This, dwWhichMoniker, pmk);
 214     return E_NOTIMPL;
 215 }
 216
 217 static HRESULT WINAPI OleObject_GetMoniker(IOleObject *iface, DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
 218 {
 219     HTMLDocument *This = OLEOBJ_THIS(iface);
 220     FIXME("(%p)->(%ld %ld %p)\n", This, dwAssign, dwWhichMoniker, ppmk);
 221     return E_NOTIMPL;
 222 }
 223
 224 static HRESULT WINAPI OleObject_InitFromData(IOleObject *iface, IDataObject *pDataObject, BOOL fCreation,
 225                                         DWORD dwReserved)
 226 {
 227     HTMLDocument *This = OLEOBJ_THIS(iface);
 228     FIXME("(%p)->(%p %x %ld)\n", This, pDataObject, fCreation, dwReserved);
 229     return E_NOTIMPL;
 230 }
 231
 232 static HRESULT WINAPI OleObject_GetClipboardData(IOleObject *iface, DWORD dwReserved, IDataObject **ppDataObject)
 233 {
 234     HTMLDocument *This = OLEOBJ_THIS(iface);
 235     FIXME("(%p)->(%ld %p)\n", This, dwReserved, ppDataObject);
 236     return E_NOTIMPL;
 237 }
 238
 239 static HRESULT WINAPI OleObject_DoVerb(IOleObject *iface, LONG iVerb, LPMSG lpmsg, IOleClientSite *pActiveSite,
 240                                         LONG lindex, HWND hwndParent, LPCRECT lprcPosRect)
 241 {
 242     HTMLDocument *This = OLEOBJ_THIS(iface);
 243     IOleDocumentSite *pDocSite;
 244     HRESULT hres;
 245
 246     TRACE("(%p)->(%ld %p %p %ld %p %p)\n", This, iVerb, lpmsg, pActiveSite, lindex, hwndParent, lprcPosRect);
 247
 248     if(iVerb != OLEIVERB_SHOW && iVerb != OLEIVERB_UIACTIVATE && iVerb != OLEIVERB_INPLACEACTIVATE) {
 249         FIXME("iVerb = %ld not supported\n", iVerb);
 250         return E_NOTIMPL;
 251     }
 252
 253     if(!pActiveSite)
 254         pActiveSite = This->client;
 255
 256     hres = IOleClientSite_QueryInterface(pActiveSite, &IID_IOleDocumentSite, (void**)&pDocSite);
 257     if(SUCCEEDED(hres)) {
 258         HTMLDocument_LockContainer(This, TRUE);
 259
 260         /* FIXME: Create new IOleDocumentView. See CreateView for more info. */
 261         hres = IOleDocumentSite_ActivateMe(pDocSite, DOCVIEW(This));
 262         IOleDocumentSite_Release(pDocSite);
 263     }else {
 264         hres = IOleDocumentView_UIActivate(DOCVIEW(This), TRUE);
 265         if(SUCCEEDED(hres)) {
 266             if(lprcPosRect) {
 267                 RECT rect; /* We need to pass rect as not const pointer */
 268                 memcpy(&rect, lprcPosRect, sizeof(RECT));
 269                 IOleDocumentView_SetRect(DOCVIEW(This), &rect);
 270             }
 271             IOleDocumentView_Show(DOCVIEW(This), TRUE);
 272         }
 273     }
 274
 275     return hres;
 276 }
 277
 278 static HRESULT WINAPI OleObject_EnumVerbs(IOleObject *iface, IEnumOLEVERB **ppEnumOleVerb)
 279 {
 280     HTMLDocument *This = OLEOBJ_THIS(iface);
 281     FIXME("(%p)->(%p)\n", This, ppEnumOleVerb);
 282     return E_NOTIMPL;
 283 }
 284
 285 static HRESULT WINAPI OleObject_Update(IOleObject *iface)
 286 {
 287     HTMLDocument *This = OLEOBJ_THIS(iface);
 288     FIXME("(%p)\n", This);
 289     return E_NOTIMPL;
 290 }
 291
 292 static HRESULT WINAPI OleObject_IsUpToDate(IOleObject *iface)
 293 {
 294     HTMLDocument *This = OLEOBJ_THIS(iface);
 295     FIXME("(%p)\n", This);
 296     return E_NOTIMPL;
 297 }
 298
 299 static HRESULT WINAPI OleObject_GetUserClassID(IOleObject *iface, CLSID *pClsid)
 300 {
 301     HTMLDocument *This = OLEOBJ_THIS(iface);
 302
 303     TRACE("(%p)->(%p)\n", This, pClsid);
 304
 305     if(!pClsid)
 306         return E_INVALIDARG;
 307
 308     memcpy(pClsid, &CLSID_HTMLDocument, sizeof(GUID));
 309     return S_OK;
 310 }
 311
 312 static HRESULT WINAPI OleObject_GetUserType(IOleObject *iface, DWORD dwFormOfType, LPOLESTR *pszUserType)
 313 {
 314     HTMLDocument *This = OLEOBJ_THIS(iface);
 315     FIXME("(%p)->(%ld %p)\n", This, dwFormOfType, pszUserType);
 316     return E_NOTIMPL;
 317 }
 318
 319 static HRESULT WINAPI OleObject_SetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 320 {
 321     HTMLDocument *This = OLEOBJ_THIS(iface);
 322     FIXME("(%p)->(%ld %p)\n", This, dwDrawAspect, psizel);
 323     return E_NOTIMPL;
 324 }
 325
 326 static HRESULT WINAPI OleObject_GetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 327 {
 328     HTMLDocument *This = OLEOBJ_THIS(iface);
 329     FIXME("(%p)->(%ld %p)\n", This, dwDrawAspect, psizel);
 330     return E_NOTIMPL;
 331 }
 332
 333 static HRESULT WINAPI OleObject_Advise(IOleObject *iface, IAdviseSink *pAdvSink, DWORD *pdwConnection)
 334 {
 335     HTMLDocument *This = OLEOBJ_THIS(iface);
 336     FIXME("(%p)->(%p %p)\n", This, pAdvSink, pdwConnection);
 337     return E_NOTIMPL;
 338 }
 339
 340 static HRESULT WINAPI OleObject_Unadvise(IOleObject *iface, DWORD dwConnection)
 341 {
 342     HTMLDocument *This = OLEOBJ_THIS(iface);
 343     FIXME("(%p)->(%ld)\n", This, dwConnection);
 344     return E_NOTIMPL;
 345 }
 346
 347 static HRESULT WINAPI OleObject_EnumAdvise(IOleObject *iface, IEnumSTATDATA **ppenumAdvise)
 348 {
 349     HTMLDocument *This = OLEOBJ_THIS(iface);
 350     FIXME("(%p)->(%p)\n", This, ppenumAdvise);
 351     return E_NOTIMPL;
 352 }
 353
 354 static HRESULT WINAPI OleObject_GetMiscStatus(IOleObject *iface, DWORD dwAspect, DWORD *pdwStatus)
 355 {
 356     HTMLDocument *This = OLEOBJ_THIS(iface);
 357     FIXME("(%p)->(%ld %p)\n", This, dwAspect, pdwStatus);
 358     return E_NOTIMPL;
 359 }
 360
 361 static HRESULT WINAPI OleObject_SetColorScheme(IOleObject *iface, LOGPALETTE *pLogpal)
 362 {
 363     HTMLDocument *This = OLEOBJ_THIS(iface);
 364     FIXME("(%p)->(%p)\n", This, pLogpal);
 365     return E_NOTIMPL;
 366 }
 367
 368 #undef OLEPBJ_THIS
 369
 370 static const IOleObjectVtbl OleObjectVtbl = {
 371     OleObject_QueryInterface,
 372     OleObject_AddRef,
 373     OleObject_Release,
 374     OleObject_SetClientSite,
 375     OleObject_GetClientSite,
 376     OleObject_SetHostNames,
 377     OleObject_Close,
 378     OleObject_SetMoniker,
 379     OleObject_GetMoniker,
 380     OleObject_InitFromData,
 381     OleObject_GetClipboardData,
 382     OleObject_DoVerb,
 383     OleObject_EnumVerbs,
 384     OleObject_Update,
 385     OleObject_IsUpToDate,
 386     OleObject_GetUserClassID,
 387     OleObject_GetUserType,
 388     OleObject_SetExtent,
 389     OleObject_GetExtent,
 390     OleObject_Advise,
 391     OleObject_Unadvise,
 392     OleObject_EnumAdvise,
 393     OleObject_GetMiscStatus,
 394     OleObject_SetColorScheme
 395 };
 396
 397 /**********************************************************
 398  * IOleDocument implementation
 399  */
 400
 401 #define OLEDOC_THIS(iface) DEFINE_THIS(HTMLDocument, OleDocument, iface)
 402
 403 static HRESULT WINAPI OleDocument_QueryInterface(IOleDocument *iface, REFIID riid, void **ppvObject)
 404 {
 405     HTMLDocument *This = OLEDOC_THIS(iface);
 406     return IHTMLDocument2_QueryInterface(HTMLDOC(This), riid, ppvObject);
 407 }
 408
 409 static ULONG WINAPI OleDocument_AddRef(IOleDocument *iface)
 410 {
 411     HTMLDocument *This = OLEDOC_THIS(iface);
 412     return IHTMLDocument2_AddRef(HTMLDOC(This));
 413 }
 414
 415 static ULONG WINAPI OleDocument_Release(IOleDocument *iface)
 416 {
 417     HTMLDocument *This = OLEDOC_THIS(iface);
 418     return IHTMLDocument2_Release(HTMLDOC(This));
 419 }
 420
 421 static HRESULT WINAPI OleDocument_CreateView(IOleDocument *iface, IOleInPlaceSite *pIPSite, IStream *pstm,
 422                                    DWORD dwReserved, IOleDocumentView **ppView)
 423 {
 424     HTMLDocument *This = OLEDOC_THIS(iface);
 425     HRESULT hres;
 426
 427     TRACE("(%p)->(%p %p %ld %p)\n", This, pIPSite, pstm, dwReserved, ppView);
 428
 429     if(!ppView)
 430         return E_INVALIDARG;
 431
 432     /* FIXME:
 433      * Windows implementation creates new IOleDocumentView when function is called for the
 434      * first time and returns E_FAIL when it is called for the second time, but it doesn't matter
 435      * if the application uses returned interfaces, passed to ActivateMe or returned by
 436      * QueryInterface, so there is no reason to create new interface. This needs more testing.
 437      */
 438
 439     if(pIPSite) {
 440         hres = IOleDocumentView_SetInPlaceSite(DOCVIEW(This), pIPSite);
 441         if(FAILED(hres))
 442             return hres;
 443     }
 444
 445     if(pstm)
 446         FIXME("pstm is not supported\n");
 447
 448     IOleDocumentView_AddRef(DOCVIEW(This));
 449     *ppView = DOCVIEW(This);
 450     return S_OK;
 451 }
 452
 453 static HRESULT WINAPI OleDocument_GetDocMiscStatus(IOleDocument *iface, DWORD *pdwStatus)
 454 {
 455     HTMLDocument *This = OLEDOC_THIS(iface);
 456     FIXME("(%p)->(%p)\n", This, pdwStatus);
 457     return E_NOTIMPL;
 458 }
 459
 460 static HRESULT WINAPI OleDocument_EnumViews(IOleDocument *iface, IEnumOleDocumentViews **ppEnum,
 461                                    IOleDocumentView **ppView)
 462 {
 463     HTMLDocument *This = OLEDOC_THIS(iface);
 464     FIXME("(%p)->(%p %p)\n", This, ppEnum, ppView);
 465     return E_NOTIMPL;
 466 }
 467
 468 #undef OLEDOC_THIS
 469
 470 static const IOleDocumentVtbl OleDocumentVtbl = {
 471     OleDocument_QueryInterface,
 472     OleDocument_AddRef,
 473     OleDocument_Release,
 474     OleDocument_CreateView,
 475     OleDocument_GetDocMiscStatus,
 476     OleDocument_EnumViews
 477 };
 478
 479 /**********************************************************
 480  * IOleCommandTarget implementation
 481  */
 482
 483 #define CMDTARGET_THIS(iface) DEFINE_THIS(HTMLDocument, OleCommandTarget, iface)
 484
 485 static HRESULT exec_open(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 486 {
 487     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 488     return E_NOTIMPL;
 489 }
 490
 491 static HRESULT exec_new(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 492 {
 493     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 494     return E_NOTIMPL;
 495 }
 496
 497 static HRESULT exec_save(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 498 {
 499     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 500     return E_NOTIMPL;
 501 }
 502
 503 static HRESULT exec_save_as(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 504 {
 505     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 506     return E_NOTIMPL;
 507 }
 508
 509 static HRESULT exec_save_copy_as(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 510 {
 511     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 512     return E_NOTIMPL;
 513 }
 514
 515 static HRESULT exec_print(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 516 {
 517     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 518     return E_NOTIMPL;
 519 }
 520
 521 static HRESULT exec_print_preview(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 522 {
 523     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 524     return E_NOTIMPL;
 525 }
 526
 527 static HRESULT exec_page_setup(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 528 {
 529     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 530     return E_NOTIMPL;
 531 }
 532
 533 static HRESULT exec_spell(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 534 {
 535     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 536     return E_NOTIMPL;
 537 }
 538
 539 static HRESULT exec_properties(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 540 {
 541     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 542     return E_NOTIMPL;
 543 }
 544
 545 static HRESULT exec_cut(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 546 {
 547     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 548     return E_NOTIMPL;
 549 }
 550
 551 static HRESULT exec_copy(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 552 {
 553     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 554     return E_NOTIMPL;
 555 }
 556
 557 static HRESULT exec_paste(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 558 {
 559     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 560     return E_NOTIMPL;
 561 }
 562
 563 static HRESULT exec_paste_special(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 564 {
 565     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 566     return E_NOTIMPL;
 567 }
 568
 569 static HRESULT exec_undo(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 570 {
 571     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 572     return E_NOTIMPL;
 573 }
 574
 575 static HRESULT exec_rendo(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 576 {
 577     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 578     return E_NOTIMPL;
 579 }
 580
 581 static HRESULT exec_select_all(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 582 {
 583     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 584     return E_NOTIMPL;
 585 }
 586
 587 static HRESULT exec_clear_selection(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 588 {
 589     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 590     return E_NOTIMPL;
 591 }
 592
 593 static HRESULT exec_zoom(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 594 {
 595     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 596     return E_NOTIMPL;
 597 }
 598
 599 static HRESULT exec_get_zoom_range(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 600 {
 601     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 602     return E_NOTIMPL;
 603 }
 604
 605 static HRESULT exec_refresh(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 606 {
 607     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 608     return E_NOTIMPL;
 609 }
 610
 611 static HRESULT exec_stop(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 612 {
 613     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 614     return E_NOTIMPL;
 615 }
 616
 617 static HRESULT exec_stop_download(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 618 {
 619     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 620     return E_NOTIMPL;
 621 }
 622
 623 static HRESULT exec_delete(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 624 {
 625     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 626     return E_NOTIMPL;
 627 }
 628
 629 static HRESULT exec_enable_interaction(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 630 {
 631     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 632     return E_NOTIMPL;
 633 }
 634
 635 static HRESULT exec_on_unload(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 636 {
 637     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 638     return E_NOTIMPL;
 639 }
 640
 641 static HRESULT exec_show_page_setup(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 642 {
 643     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 644     return E_NOTIMPL;
 645 }
 646
 647 static HRESULT exec_show_print(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 648 {
 649     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 650     return E_NOTIMPL;
 651 }
 652
 653 static HRESULT exec_close(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 654 {
 655     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 656     return E_NOTIMPL;
 657 }
 658
 659 static HRESULT exec_set_print_template(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 660 {
 661     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 662     return E_NOTIMPL;
 663 }
 664
 665 static HRESULT exec_get_print_template(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 666 {
 667     FIXME("(%p)->(%ld %p %p)\n", This, nCmdexecopt, pvaIn, pvaOut);
 668     return E_NOTIMPL;
 669 }
 670
 671 static const struct {
 672     OLECMDF cmdf;
 673     HRESULT (*func)(HTMLDocument*,DWORD,VARIANT*,VARIANT*);
 674 } exec_table[OLECMDID_GETPRINTTEMPLATE+1] = {
 675     {0},
 676     { OLECMDF_SUPPORTED,                  exec_open                 }, /* OLECMDID_OPEN */
 677     { OLECMDF_SUPPORTED,                  exec_new                  }, /* OLECMDID_NEW */
 678     { OLECMDF_SUPPORTED,                  exec_save                 }, /* OLECMDID_SAVE */
 679     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_save_as              }, /* OLECMDID_SAVEAS */
 680     { OLECMDF_SUPPORTED,                  exec_save_copy_as         }, /* OLECMDID_SAVECOPYAS */
 681     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_print                }, /* OLECMDID_PRINT */
 682     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_print_preview        }, /* OLECMDID_PRINTPREVIEW */
 683     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_page_setup           }, /* OLECMDID_PAGESETUP */
 684     { OLECMDF_SUPPORTED,                  exec_spell                }, /* OLECMDID_SPELL */
 685     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_properties           }, /* OLECMDID_PROPERTIES */
 686     { OLECMDF_SUPPORTED,                  exec_cut                  }, /* OLECMDID_CUT */
 687     { OLECMDF_SUPPORTED,                  exec_copy                 }, /* OLECMDID_COPY */
 688     { OLECMDF_SUPPORTED,                  exec_paste                }, /* OLECMDID_PASTE */
 689     { OLECMDF_SUPPORTED,                  exec_paste_special        }, /* OLECMDID_PASTESPECIAL */
 690     { OLECMDF_SUPPORTED,                  exec_undo                 }, /* OLECMDID_UNDO */
 691     { OLECMDF_SUPPORTED,                  exec_rendo                }, /* OLECMDID_REDO */
 692     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_select_all           }, /* OLECMDID_SELECTALL */
 693     { OLECMDF_SUPPORTED,                  exec_clear_selection      }, /* OLECMDID_CLEARSELECTION */
 694     { OLECMDF_SUPPORTED,                  exec_zoom                 }, /* OLECMDID_ZOOM */
 695     { OLECMDF_SUPPORTED,                  exec_get_zoom_range       }, /* OLECMDID_GETZOOMRANGE */
 696     {0},
 697     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_refresh              }, /* OLECMDID_REFRESH */
 698     { OLECMDF_SUPPORTED|OLECMDF_ENABLED,  exec_stop                 }, /* OLECMDID_STOP */
 699     {0},{0},{0},{0},{0},{0},
 700     { OLECMDF_SUPPORTED,                  exec_stop_download        }, /* OLECMDID_STOPDOWNLOAD */
 701     {0},{0},
 702     { OLECMDF_SUPPORTED,                  exec_delete               }, /* OLECMDID_DELETE */
 703     {0},{0},
 704     { OLECMDF_SUPPORTED,                  exec_enable_interaction   }, /* OLECMDID_ENABLE_INTERACTION */
 705     { OLECMDF_SUPPORTED,                  exec_on_unload            }, /* OLECMDID_ONUNLOAD */
 706     {0},{0},{0},{0},{0},
 707     { OLECMDF_SUPPORTED,                  exec_show_page_setup      }, /* OLECMDID_SHOWPAGESETUP */
 708     { OLECMDF_SUPPORTED,                  exec_show_print           }, /* OLECMDID_SHOWPRINT */
 709     {0},{0},
 710     { OLECMDF_SUPPORTED,                  exec_close                }, /* OLECMDID_CLOSE */
 711     {0},{0},{0},
 712     { OLECMDF_SUPPORTED,                  exec_set_print_template   }, /* OLECMDID_SETPRINTTEMPLATE */
 713     { OLECMDF_SUPPORTED,                  exec_get_print_template   }  /* OLECMDID_GETPRINTTEMPLATE */
 714 };
 715
 716 static HRESULT WINAPI OleCommandTarget_QueryInterface(IOleCommandTarget *iface, REFIID riid, void **ppv)
 717 {
 718     HTMLDocument *This = CMDTARGET_THIS(iface);
 719     return IHTMLDocument2_QueryInterface(HTMLDOC(This), riid, ppv);
 720 }
 721
 722 static ULONG WINAPI OleCommandTarget_AddRef(IOleCommandTarget *iface)
 723 {
 724     HTMLDocument *This = CMDTARGET_THIS(iface);
 725     return IHTMLDocument2_AddRef(HTMLDOC(This));
 726 }
 727
 728 static ULONG WINAPI OleCommandTarget_Release(IOleCommandTarget *iface)
 729 {
 730     HTMLDocument *This = CMDTARGET_THIS(iface);
 731     return IHTMLDocument_Release(HTMLDOC(This));
 732 }
 733
 734 static HRESULT WINAPI OleCommandTarget_QueryStatus(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
 735         ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText)
 736 {
 737     HTMLDocument *This = CMDTARGET_THIS(iface);
 738     HRESULT hres = S_OK, hr;
 739
 740     TRACE("(%p)->(%s %ld %p %p)\n", This, debugstr_guid(pguidCmdGroup), cCmds, prgCmds, pCmdText);
 741
 742     if(!pguidCmdGroup) {
 743         ULONG i;
 744
 745         for(i=0; i<cCmds; i++) {
 746             if(prgCmds[i].cmdID<OLECMDID_OPEN || prgCmds[i].cmdID>OLECMDID_GETPRINTTEMPLATE) {
 747                 WARN("Unsupported cmdID = %ld\n", prgCmds[i].cmdID);
 748                 prgCmds[i].cmdf = 0;
 749                 hres = OLECMDERR_E_NOTSUPPORTED;
 750             }else {
 751                 if(prgCmds[i].cmdID == OLECMDID_OPEN || prgCmds[i].cmdID == OLECMDID_NEW) {
 752                     IOleCommandTarget *cmdtrg = NULL;
 753                     OLECMD olecmd;
 754
 755                     prgCmds[i].cmdf = OLECMDF_SUPPORTED;
 756                     if(This->client) {
 757                         hr = IOleClientSite_QueryInterface(This->client, &IID_IOleCommandTarget,
 758                                 (void**)&cmdtrg);
 759                         if(SUCCEEDED(hr)) {
 760                             olecmd.cmdID = prgCmds[i].cmdID;
 761                             olecmd.cmdf = 0;
 762
 763                             hr = IOleCommandTarget_QueryStatus(cmdtrg, NULL, 1, &olecmd, NULL);
 764                             if(SUCCEEDED(hr) && olecmd.cmdf)
 765                                 prgCmds[i].cmdf = olecmd.cmdf;
 766                         }
 767                     }else {
 768                         ERR("This->client == NULL, native would crash\n");
 769                     }
 770                 }else {
 771                     prgCmds[i].cmdf = exec_table[prgCmds[i].cmdID].cmdf;
 772                     TRACE("cmdID = %ld  returning %lx\n", prgCmds[i].cmdID, prgCmds[i].cmdf);
 773                 }
 774                 hres = S_OK;
 775             }
 776         }
 777
 778         if(pguidCmdGroup)
 779             FIXME("Set pCmdText\n");
 780     }else {
 781         FIXME("Unsupported pguidCmdGroup %s\n", debugstr_guid(pguidCmdGroup));
 782         hres = OLECMDERR_E_UNKNOWNGROUP;
 783     }
 784
 785     return hres;
 786 }
 787
 788 static HRESULT WINAPI OleCommandTarget_Exec(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
 789         DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 790 {
 791     HTMLDocument *This = CMDTARGET_THIS(iface);
 792
 793     if(!pguidCmdGroup) {
 794         if(nCmdID<OLECMDID_OPEN || nCmdID>OLECMDID_GETPRINTTEMPLATE || !exec_table[nCmdID].func) {
 795             WARN("Unsupported cmdID = %ld\n", nCmdID);
 796             return OLECMDERR_E_NOTSUPPORTED;
 797         }
 798
 799         return exec_table[nCmdID].func(This, nCmdexecopt, pvaIn, pvaOut);
 800     }else if(IsEqualGUID(&CGID_ShellDocView, pguidCmdGroup)) {
 801         FIXME("unsupported nCmdID %ld of CGID_ShellDocView group\n", nCmdID);
 802         return OLECMDERR_E_UNKNOWNGROUP;
 803     }
 804
 805     FIXME("Unsupported pguidCmdGroup %s\n", debugstr_guid(pguidCmdGroup));
 806     return OLECMDERR_E_UNKNOWNGROUP;
 807 }
 808
 809 #undef CMDTARGET_THIS
 810
 811 static const IOleCommandTargetVtbl OleCommandTargetVtbl = {
 812     OleCommandTarget_QueryInterface,
 813     OleCommandTarget_AddRef,
 814     OleCommandTarget_Release,
 815     OleCommandTarget_QueryStatus,
 816     OleCommandTarget_Exec
 817 };
 818
 819 /**********************************************************
 820  * IOleControl implementation
 821  */
 822
 823 #define CONTROL_THIS(iface) DEFINE_THIS(HTMLDocument, OleControl, iface)
 824
 825 static HRESULT WINAPI OleControl_QueryInterface(IOleControl *iface, REFIID riid, void **ppv)
 826 {
 827     HTMLDocument *This = CONTROL_THIS(iface);
 828     return IHTMLDocument2_QueryInterface(HTMLDOC(This), riid, ppv);
 829 }
 830
 831 static ULONG WINAPI OleControl_AddRef(IOleControl *iface)
 832 {
 833     HTMLDocument *This = CONTROL_THIS(iface);
 834     return IHTMLDocument2_AddRef(HTMLDOC(This));
 835 }
 836
 837 static ULONG WINAPI OleControl_Release(IOleControl *iface)
 838 {
 839     HTMLDocument *This = CONTROL_THIS(iface);
 840     return IHTMLDocument_Release(HTMLDOC(This));
 841 }
 842
 843 static HRESULT WINAPI OleControl_GetControlInfo(IOleControl *iface, CONTROLINFO *pCI)
 844 {
 845     HTMLDocument *This = CONTROL_THIS(iface);
 846     FIXME("(%p)->(%p)\n", This, pCI);
 847     return E_NOTIMPL;
 848 }
 849
 850 static HRESULT WINAPI OleControl_OnMnemonic(IOleControl *iface, MSG *pMsg)
 851 {
 852     HTMLDocument *This = CONTROL_THIS(iface);
 853     FIXME("(%p)->(%p)\n", This, pMsg);
 854     return E_NOTIMPL;
 855 }
 856
 857 static HRESULT get_property(IOleClientSite *client, DISPID dispid, VARIANT *res)
 858 {
 859     IDispatch *disp = NULL;
 860     DISPPARAMS dispparams = {NULL, 0};
 861     UINT err;
 862     HRESULT hres;
 863
 864     hres = IOleClientSite_QueryInterface(client, &IID_IDispatch, (void**)&disp);
 865     if(FAILED(hres)) {
 866         TRACE("Could not get IDispatch\n");
 867         return hres;
 868     }
 869
 870     VariantInit(res);
 871
 872     hres = IDispatch_Invoke(disp, dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT,
 873             DISPATCH_PROPERTYGET, &dispparams, res, NULL, &err);
 874
 875     IDispatch_Release(disp);
 876
 877     return hres;
 878 }
 879
 880 static HRESULT on_change_dlcontrol(HTMLDocument *This)
 881 {
 882     VARIANT res;
 883     HRESULT hres;
 884
 885     hres = get_property(This->client, DISPID_AMBIENT_DLCONTROL, &res);
 886     if(SUCCEEDED(hres))
 887         FIXME("unsupported dlcontrol %08lx\n", V_I4(&res));
 888
 889     return S_OK;
 890 }
 891
 892 static HRESULT WINAPI OleControl_OnAmbientPropertyChange(IOleControl *iface, DISPID dispID)
 893 {
 894     HTMLDocument *This = CONTROL_THIS(iface);
 895     VARIANT res;
 896     HRESULT hres;
 897
 898     if(!This->client) {
 899         TRACE("This->client = NULL\n");
 900         return S_OK;
 901     }
 902
 903     switch(dispID) {
 904     case DISPID_AMBIENT_USERMODE:
 905         TRACE("(%p)->(DISPID_AMBIENT_USERMODE)\n", This);
 906         hres = get_property(This->client, DISPID_AMBIENT_USERMODE, &res);
 907         if(FAILED(hres))
 908             return S_OK;
 909
 910         if(V_VT(&res) == VT_BOOL) {
 911             if(!V_BOOL(&res)) {
 912                 FIXME("edit mode is not supported\n");
 913                 hres = E_FAIL;
 914             }
 915         }else {
 916             FIXME("V_VT(res)=%d\n", V_VT(&res));
 917         }
 918         return S_OK;
 919     case DISPID_AMBIENT_DLCONTROL:
 920         TRACE("(%p)->(DISPID_AMBIENT_DLCONTROL)\n", This);
 921         return on_change_dlcontrol(This);
 922     case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED:
 923         TRACE("(%p)->(DISPID_AMBIENT_OFFLINEIFNOTCONNECTED)\n", This);
 924         on_change_dlcontrol(This);
 925         hres = get_property(This->client, DISPID_AMBIENT_OFFLINEIFNOTCONNECTED, &res);
 926         if(FAILED(hres))
 927             return S_OK;
 928
 929         if(V_VT(&res) == VT_BOOL) {
 930             if(V_BOOL(&res)) {
 931                 FIXME("offline connection is not supported\n");
 932                 hres = E_FAIL;
 933             }
 934         }else {
 935             FIXME("V_VT(res)=%d\n", V_VT(&res));
 936         }
 937         return S_OK;
 938     case DISPID_AMBIENT_SILENT:
 939         TRACE("(%p)->(DISPID_AMBIENT_SILENT)\n", This);
 940         on_change_dlcontrol(This);
 941         hres = get_property(This->client, DISPID_AMBIENT_SILENT, &res);
 942         if(FAILED(hres))
 943             return S_OK;
 944
 945         if(V_VT(&res) == VT_BOOL) {
 946             if(V_BOOL(&res)) {
 947                 FIXME("silent mode is not supported\n");
 948                 hres = E_FAIL;
 949             }
 950         }else {
 951             FIXME("V_VT(res)=%d\n", V_VT(&res));
 952         }
 953         return S_OK;
 954     case DISPID_AMBIENT_USERAGENT:
 955         TRACE("(%p)->(DISPID_AMBIENT_USERAGENT)\n", This);
 956         hres = get_property(This->client, DISPID_AMBIENT_USERAGENT, &res);
 957         if(FAILED(hres))
 958             return S_OK;
 959
 960         FIXME("not supported AMBIENT_USERAGENT\n");
 961         hres = E_FAIL;
 962         return S_OK;
 963     case DISPID_AMBIENT_PALETTE:
 964         TRACE("(%p)->(DISPID_AMBIENT_PALETTE)\n", This);
 965         hres = get_property(This->client, DISPID_AMBIENT_PALETTE, &res);
 966         if(FAILED(hres))
 967             return S_OK;
 968
 969         FIXME("not supported AMBIENT_PALETTE\n");
 970         hres = E_FAIL;
 971         return S_OK;
 972     }
 973
 974     FIXME("(%p) unsupported dispID=%ld\n", This, dispID);
 975     return E_FAIL;
 976 }
 977
 978 static HRESULT WINAPI OleControl_FreezeEvents(IOleControl *iface, BOOL bFreeze)
 979 {
 980     HTMLDocument *This = CONTROL_THIS(iface);
 981     FIXME("(%p)->(%x)\n", This, bFreeze);
 982     return E_NOTIMPL;
 983 }
 984
 985 #undef CONTROL_THIS
 986
 987 static const IOleControlVtbl OleControlVtbl = {
 988     OleControl_QueryInterface,
 989     OleControl_AddRef,
 990     OleControl_Release,
 991     OleControl_GetControlInfo,
 992     OleControl_OnMnemonic,
 993     OleControl_OnAmbientPropertyChange,
 994     OleControl_FreezeEvents
 995 };
 996
 997 void HTMLDocument_LockContainer(HTMLDocument *This, BOOL fLock)
 998 {
 999     IOleContainer *container;
1000     HRESULT hres;
1001
1002     if(!This->client || This->container_locked == fLock)
1003         return;
1004
1005     hres = IOleClientSite_GetContainer(This->client, &container);
1006     if(SUCCEEDED(hres)) {
1007         IOleContainer_LockContainer(container, fLock);
1008         This->container_locked = fLock;
1009         IOleContainer_Release(container);
1010     }
1011 }
1012
1013 void HTMLDocument_OleObj_Init(HTMLDocument *This)
1014 {
1015     This->lpOleObjectVtbl = &OleObjectVtbl;
1016     This->lpOleDocumentVtbl = &OleDocumentVtbl;
1017     This->lpOleCommandTargetVtbl = &OleCommandTargetVtbl;
1018     This->lpOleControlVtbl = &OleControlVtbl;
1019
1020     This->client = NULL;
1021     This->hostui = NULL;
1022
1023     This->has_key_path = FALSE;
1024     This->container_locked = FALSE;
1025 }