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