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