git.oblomov.eu Git - wine/blob - dlls/ole32/defaulthandler.c

   1 /*
   2  *      OLE 2 default object handler
   3  *
   4  *      Copyright 1999  Francis Beaudet
   5  *      Copyright 2000  Abey George
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  * NOTES:
  22  *    The OLE2 default object handler supports a whole whack of
  23  *    interfaces including:
  24  *       IOleObject, IDataObject, IPersistStorage, IViewObject2,
  25  *       IRunnableObject, IOleCache2, IOleCacheControl and much more.
  26  *
  27  *    All the implementation details are taken from: Inside OLE
  28  *    second edition by Kraig Brockschmidt,
  29  *
  30  * TODO
  31  * - This implementation of the default handler does not launch the
  32  *   server in the DoVerb, Update, GetData, GetDataHere and Run
  33  *   methods. When it is fixed to do so, all the methods will have
  34  *   to be  revisited to allow delegating to the running object
  35  *
  36  * - All methods in the class that use the class ID should be
  37  *   aware that it is possible for a class to be treated as
  38  *   another one and go into emulation mode. Nothing has been
  39  *   done in this area.
  40  *
  41  * - Some functions still return E_NOTIMPL they have to be
  42  *   implemented. Most of those are related to the running of the
  43  *   actual server.
  44  *
  45  * - All the methods related to notification and advise sinks are
  46  *   in place but no notifications are sent to the sinks yet.
  47  */
  48 #include <assert.h>
  49 #include <stdarg.h>
  50 #include <string.h>
  51
  52 #define COBJMACROS
  53
  54 #include "windef.h"
  55 #include "winbase.h"
  56 #include "winuser.h"
  57 #include "winerror.h"
  58 #include "ole2.h"
  59
  60 #include "compobj_private.h"
  61
  62 #include "wine/unicode.h"
  63 #include "wine/debug.h"
  64
  65 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  66
  67 enum storage_state
  68 {
  69     storage_state_uninitialised,
  70     storage_state_initialised,
  71     storage_state_loaded
  72 };
  73
  74 enum object_state
  75 {
  76     object_state_not_running,
  77     object_state_running
  78 };
  79
  80 /****************************************************************************
  81  * DefaultHandler
  82  *
  83  */
  84 struct DefaultHandler
  85 {
  86   const IOleObjectVtbl*      lpVtbl;
  87   const IUnknownVtbl*        lpvtblIUnknown;
  88   const IDataObjectVtbl*     lpvtblIDataObject;
  89   const IRunnableObjectVtbl* lpvtblIRunnableObject;
  90   const IAdviseSinkVtbl     *lpvtblIAdviseSink;
  91   const IPersistStorageVtbl *lpvtblIPersistStorage;
  92
  93   /* Reference count of this object */
  94   LONG ref;
  95
  96   /* IUnknown implementation of the outer object. */
  97   IUnknown* outerUnknown;
  98
  99   /* Class Id that this handler object represents. */
 100   CLSID clsid;
 101
 102   /* IUnknown implementation of the datacache. */
 103   IUnknown* dataCache;
 104   /* IPersistStorage implementation of the datacache. */
 105   IPersistStorage* dataCache_PersistStg;
 106
 107   /* Client site for the embedded object. */
 108   IOleClientSite* clientSite;
 109
 110   /*
 111    * The IOleAdviseHolder maintains the connections
 112    * on behalf of the default handler.
 113    */
 114   IOleAdviseHolder* oleAdviseHolder;
 115
 116   /*
 117    * The IDataAdviseHolder maintains the data
 118    * connections on behalf of the default handler.
 119    */
 120   IDataAdviseHolder* dataAdviseHolder;
 121
 122   /* Name of the container and object contained */
 123   LPWSTR containerApp;
 124   LPWSTR containerObj;
 125
 126   /* IOleObject delegate */
 127   IOleObject *pOleDelegate;
 128   /* IPersistStorage delegate */
 129   IPersistStorage *pPSDelegate;
 130   /* IDataObject delegate */
 131   IDataObject *pDataDelegate;
 132   enum object_state object_state;
 133
 134   /* connection cookie for the advise on the delegate OLE object */
 135   DWORD dwAdvConn;
 136
 137   /* storage passed to Load or InitNew */
 138   IStorage *storage;
 139   enum storage_state storage_state;
 140 };
 141
 142 typedef struct DefaultHandler DefaultHandler;
 143
 144 static inline DefaultHandler *impl_from_IOleObject( IOleObject *iface )
 145 {
 146     return (DefaultHandler *)((char*)iface - FIELD_OFFSET(DefaultHandler, lpVtbl));
 147 }
 148
 149 static inline DefaultHandler *impl_from_NDIUnknown( IUnknown *iface )
 150 {
 151     return (DefaultHandler *)((char*)iface - FIELD_OFFSET(DefaultHandler, lpvtblIUnknown));
 152 }
 153
 154 static inline DefaultHandler *impl_from_IDataObject( IDataObject *iface )
 155 {
 156     return (DefaultHandler *)((char*)iface - FIELD_OFFSET(DefaultHandler, lpvtblIDataObject));
 157 }
 158
 159 static inline DefaultHandler *impl_from_IRunnableObject( IRunnableObject *iface )
 160 {
 161     return (DefaultHandler *)((char*)iface - FIELD_OFFSET(DefaultHandler, lpvtblIRunnableObject));
 162 }
 163
 164 static inline DefaultHandler *impl_from_IAdviseSink( IAdviseSink *iface )
 165 {
 166     return (DefaultHandler *)((char*)iface - FIELD_OFFSET(DefaultHandler, lpvtblIAdviseSink));
 167 }
 168
 169 static inline DefaultHandler *impl_from_IPersistStorage( IPersistStorage *iface )
 170 {
 171     return (DefaultHandler *)((char*)iface - FIELD_OFFSET(DefaultHandler, lpvtblIPersistStorage));
 172 }
 173
 174 static void DefaultHandler_Destroy(DefaultHandler* This);
 175
 176 static inline BOOL object_is_running(DefaultHandler *This)
 177 {
 178     return IRunnableObject_IsRunning((IRunnableObject*)&This->lpvtblIRunnableObject);
 179 }
 180
 181 /*********************************************************
 182  * Method implementation for the  non delegating IUnknown
 183  * part of the DefaultHandler class.
 184  */
 185
 186 /************************************************************************
 187  * DefaultHandler_NDIUnknown_QueryInterface (IUnknown)
 188  *
 189  * See Windows documentation for more details on IUnknown methods.
 190  *
 191  * This version of QueryInterface will not delegate its implementation
 192  * to the outer unknown.
 193  */
 194 static HRESULT WINAPI DefaultHandler_NDIUnknown_QueryInterface(
 195             IUnknown*      iface,
 196             REFIID         riid,
 197             void**         ppvObject)
 198 {
 199   DefaultHandler *This = impl_from_NDIUnknown(iface);
 200
 201   if (!ppvObject)
 202     return E_INVALIDARG;
 203
 204   *ppvObject = NULL;
 205
 206   if (IsEqualIID(&IID_IUnknown, riid))
 207     *ppvObject = iface;
 208   else if (IsEqualIID(&IID_IOleObject, riid))
 209     *ppvObject = &This->lpVtbl;
 210   else if (IsEqualIID(&IID_IDataObject, riid))
 211     *ppvObject = &This->lpvtblIDataObject;
 212   else if (IsEqualIID(&IID_IRunnableObject, riid))
 213     *ppvObject = &This->lpvtblIRunnableObject;
 214   else if (IsEqualIID(&IID_IPersist, riid) ||
 215            IsEqualIID(&IID_IPersistStorage, riid))
 216     *ppvObject = &This->lpvtblIPersistStorage;
 217   else if (IsEqualIID(&IID_IViewObject, riid) ||
 218            IsEqualIID(&IID_IViewObject2, riid) ||
 219            IsEqualIID(&IID_IOleCache, riid) ||
 220            IsEqualIID(&IID_IOleCache2, riid))
 221   {
 222     HRESULT hr = IUnknown_QueryInterface(This->dataCache, riid, ppvObject);
 223     if (FAILED(hr)) FIXME("interface %s not implemented by data cache\n", debugstr_guid(riid));
 224     return hr;
 225   }
 226
 227   /* Check that we obtained an interface. */
 228   if (*ppvObject == NULL)
 229   {
 230     WARN( "() : asking for un supported interface %s\n", debugstr_guid(riid));
 231     return E_NOINTERFACE;
 232   }
 233
 234   /*
 235    * Query Interface always increases the reference count by one when it is
 236    * successful.
 237    */
 238   IUnknown_AddRef((IUnknown*)*ppvObject);
 239
 240   return S_OK;
 241 }
 242
 243 /************************************************************************
 244  * DefaultHandler_NDIUnknown_AddRef (IUnknown)
 245  *
 246  * See Windows documentation for more details on IUnknown methods.
 247  *
 248  * This version of QueryInterface will not delegate its implementation
 249  * to the outer unknown.
 250  */
 251 static ULONG WINAPI DefaultHandler_NDIUnknown_AddRef(
 252             IUnknown*      iface)
 253 {
 254   DefaultHandler *This = impl_from_NDIUnknown(iface);
 255   return InterlockedIncrement(&This->ref);
 256 }
 257
 258 /************************************************************************
 259  * DefaultHandler_NDIUnknown_Release (IUnknown)
 260  *
 261  * See Windows documentation for more details on IUnknown methods.
 262  *
 263  * This version of QueryInterface will not delegate its implementation
 264  * to the outer unknown.
 265  */
 266 static ULONG WINAPI DefaultHandler_NDIUnknown_Release(
 267             IUnknown*      iface)
 268 {
 269   DefaultHandler *This = impl_from_NDIUnknown(iface);
 270   ULONG ref;
 271
 272   ref = InterlockedDecrement(&This->ref);
 273
 274   if (!ref) DefaultHandler_Destroy(This);
 275
 276   return ref;
 277 }
 278
 279 /*********************************************************
 280  * Methods implementation for the IOleObject part of
 281  * the DefaultHandler class.
 282  */
 283
 284 /************************************************************************
 285  * DefaultHandler_QueryInterface (IUnknown)
 286  *
 287  * See Windows documentation for more details on IUnknown methods.
 288  */
 289 static HRESULT WINAPI DefaultHandler_QueryInterface(
 290             IOleObject*      iface,
 291             REFIID           riid,
 292             void**           ppvObject)
 293 {
 294   DefaultHandler *This = impl_from_IOleObject(iface);
 295
 296   return IUnknown_QueryInterface(This->outerUnknown, riid, ppvObject);
 297 }
 298
 299 /************************************************************************
 300  * DefaultHandler_AddRef (IUnknown)
 301  *
 302  * See Windows documentation for more details on IUnknown methods.
 303  */
 304 static ULONG WINAPI DefaultHandler_AddRef(
 305             IOleObject*        iface)
 306 {
 307   DefaultHandler *This = impl_from_IOleObject(iface);
 308
 309   return IUnknown_AddRef(This->outerUnknown);
 310 }
 311
 312 /************************************************************************
 313  * DefaultHandler_Release (IUnknown)
 314  *
 315  * See Windows documentation for more details on IUnknown methods.
 316  */
 317 static ULONG WINAPI DefaultHandler_Release(
 318             IOleObject*        iface)
 319 {
 320   DefaultHandler *This = impl_from_IOleObject(iface);
 321
 322   return IUnknown_Release(This->outerUnknown);
 323 }
 324
 325 /************************************************************************
 326  * DefaultHandler_SetClientSite (IOleObject)
 327  *
 328  * The default handler's implementation of this method only keeps the
 329  * client site pointer for future reference.
 330  *
 331  * See Windows documentation for more details on IOleObject methods.
 332  */
 333 static HRESULT WINAPI DefaultHandler_SetClientSite(
 334             IOleObject*        iface,
 335             IOleClientSite*    pClientSite)
 336 {
 337   DefaultHandler *This = impl_from_IOleObject(iface);
 338   HRESULT hr = S_OK;
 339
 340   TRACE("(%p, %p)\n", iface, pClientSite);
 341
 342   if (object_is_running(This))
 343     hr = IOleObject_SetClientSite(This->pOleDelegate, pClientSite);
 344
 345   /*
 346    * Make sure we release the previous client site if there
 347    * was one.
 348    */
 349   if (This->clientSite)
 350     IOleClientSite_Release(This->clientSite);
 351
 352   This->clientSite = pClientSite;
 353
 354   if (This->clientSite)
 355     IOleClientSite_AddRef(This->clientSite);
 356
 357   return S_OK;
 358 }
 359
 360 /************************************************************************
 361  * DefaultHandler_GetClientSite (IOleObject)
 362  *
 363  * The default handler's implementation of this method returns the
 364  * last pointer set in IOleObject_SetClientSite.
 365  *
 366  * See Windows documentation for more details on IOleObject methods.
 367  */
 368 static HRESULT WINAPI DefaultHandler_GetClientSite(
 369             IOleObject*        iface,
 370             IOleClientSite**   ppClientSite)
 371 {
 372   DefaultHandler *This = impl_from_IOleObject(iface);
 373
 374   if (!ppClientSite)
 375     return E_POINTER;
 376
 377   *ppClientSite = This->clientSite;
 378
 379   if (This->clientSite)
 380     IOleClientSite_AddRef(This->clientSite);
 381
 382   return S_OK;
 383 }
 384
 385 /************************************************************************
 386  * DefaultHandler_SetHostNames (IOleObject)
 387  *
 388  * The default handler's implementation of this method just stores
 389  * the strings and returns S_OK.
 390  *
 391  * See Windows documentation for more details on IOleObject methods.
 392  */
 393 static HRESULT WINAPI DefaultHandler_SetHostNames(
 394             IOleObject*        iface,
 395             LPCOLESTR          szContainerApp,
 396             LPCOLESTR          szContainerObj)
 397 {
 398   DefaultHandler *This = impl_from_IOleObject(iface);
 399
 400   TRACE("(%p, %s, %s)\n",
 401         iface,
 402         debugstr_w(szContainerApp),
 403         debugstr_w(szContainerObj));
 404
 405   if (object_is_running(This))
 406     IOleObject_SetHostNames(This->pOleDelegate, szContainerApp, szContainerObj);
 407
 408   /* Be sure to cleanup before re-assigning the strings. */
 409   HeapFree( GetProcessHeap(), 0, This->containerApp );
 410   This->containerApp = NULL;
 411   HeapFree( GetProcessHeap(), 0, This->containerObj );
 412   This->containerObj = NULL;
 413
 414   if (szContainerApp)
 415   {
 416       if ((This->containerApp = HeapAlloc( GetProcessHeap(), 0,
 417                                            (lstrlenW(szContainerApp) + 1) * sizeof(WCHAR) )))
 418           strcpyW( This->containerApp, szContainerApp );
 419   }
 420
 421   if (szContainerObj)
 422   {
 423       if ((This->containerObj = HeapAlloc( GetProcessHeap(), 0,
 424                                            (lstrlenW(szContainerObj) + 1) * sizeof(WCHAR) )))
 425           strcpyW( This->containerObj, szContainerObj );
 426   }
 427   return S_OK;
 428 }
 429
 430 static void release_delegates(DefaultHandler *This)
 431 {
 432     if (This->pDataDelegate)
 433     {
 434         IDataObject_Release(This->pDataDelegate);
 435         This->pDataDelegate = NULL;
 436     }
 437     if (This->pPSDelegate)
 438     {
 439         IPersistStorage_Release(This->pPSDelegate);
 440         This->pPSDelegate = NULL;
 441     }
 442     if (This->pOleDelegate)
 443     {
 444         IOleObject_Release(This->pOleDelegate);
 445         This->pOleDelegate = NULL;
 446     }
 447 }
 448
 449 /* undoes the work done by DefaultHandler_Run */
 450 static void DefaultHandler_Stop(DefaultHandler *This)
 451 {
 452   if (!object_is_running(This))
 453     return;
 454
 455   IOleObject_Unadvise(This->pOleDelegate, This->dwAdvConn);
 456
 457   /* FIXME: call IOleCache_OnStop */
 458
 459   if (This->dataAdviseHolder)
 460     DataAdviseHolder_OnDisconnect(This->dataAdviseHolder);
 461
 462   This->object_state = object_state_not_running;
 463 }
 464
 465 /************************************************************************
 466  * DefaultHandler_Close (IOleObject)
 467  *
 468  * The default handler's implementation of this method is meaningless
 469  * without a running server so it does nothing.
 470  *
 471  * See Windows documentation for more details on IOleObject methods.
 472  */
 473 static HRESULT WINAPI DefaultHandler_Close(
 474             IOleObject*        iface,
 475             DWORD              dwSaveOption)
 476 {
 477   DefaultHandler *This = impl_from_IOleObject(iface);
 478   HRESULT hr;
 479
 480   TRACE("(%d)\n", dwSaveOption);
 481
 482   if (!object_is_running(This))
 483     return S_OK;
 484
 485   hr = IOleObject_Close(This->pOleDelegate, dwSaveOption);
 486
 487   DefaultHandler_Stop(This);
 488   release_delegates(This);
 489
 490   return hr;
 491 }
 492
 493 /************************************************************************
 494  * DefaultHandler_SetMoniker (IOleObject)
 495  *
 496  * The default handler's implementation of this method does nothing.
 497  *
 498  * See Windows documentation for more details on IOleObject methods.
 499  */
 500 static HRESULT WINAPI DefaultHandler_SetMoniker(
 501             IOleObject*        iface,
 502             DWORD              dwWhichMoniker,
 503             IMoniker*          pmk)
 504 {
 505   DefaultHandler *This = impl_from_IOleObject(iface);
 506
 507   TRACE("(%p, %d, %p)\n",
 508         iface,
 509         dwWhichMoniker,
 510         pmk);
 511
 512   if (object_is_running(This))
 513     return IOleObject_SetMoniker(This->pOleDelegate, dwWhichMoniker, pmk);
 514
 515   return S_OK;
 516 }
 517
 518 /************************************************************************
 519  * DefaultHandler_GetMoniker (IOleObject)
 520  *
 521  * Delegate this request to the client site if we have one.
 522  *
 523  * See Windows documentation for more details on IOleObject methods.
 524  */
 525 static HRESULT WINAPI DefaultHandler_GetMoniker(
 526             IOleObject*        iface,
 527             DWORD              dwAssign,
 528             DWORD              dwWhichMoniker,
 529             IMoniker**         ppmk)
 530 {
 531   DefaultHandler *This = impl_from_IOleObject(iface);
 532
 533   TRACE("(%p, %d, %d, %p)\n",
 534         iface, dwAssign, dwWhichMoniker, ppmk);
 535
 536   if (object_is_running(This))
 537     return IOleObject_GetMoniker(This->pOleDelegate, dwAssign, dwWhichMoniker,
 538                                  ppmk);
 539
 540   /* FIXME: dwWhichMoniker == OLEWHICHMK_CONTAINER only? */
 541   if (This->clientSite)
 542   {
 543     return IOleClientSite_GetMoniker(This->clientSite,
 544                                      dwAssign,
 545                                      dwWhichMoniker,
 546                                      ppmk);
 547
 548   }
 549
 550   return E_FAIL;
 551 }
 552
 553 /************************************************************************
 554  * DefaultHandler_InitFromData (IOleObject)
 555  *
 556  * This method is meaningless if the server is not running
 557  *
 558  * See Windows documentation for more details on IOleObject methods.
 559  */
 560 static HRESULT WINAPI DefaultHandler_InitFromData(
 561             IOleObject*        iface,
 562             IDataObject*       pDataObject,
 563             BOOL               fCreation,
 564             DWORD              dwReserved)
 565 {
 566   DefaultHandler *This = impl_from_IOleObject(iface);
 567
 568   TRACE("(%p, %p, %d, %d)\n",
 569         iface, pDataObject, fCreation, dwReserved);
 570
 571   if (object_is_running(This))
 572     return IOleObject_InitFromData(This->pOleDelegate, pDataObject, fCreation,
 573                                    dwReserved);
 574   return OLE_E_NOTRUNNING;
 575 }
 576
 577 /************************************************************************
 578  * DefaultHandler_GetClipboardData (IOleObject)
 579  *
 580  * This method is meaningless if the server is not running
 581  *
 582  * See Windows documentation for more details on IOleObject methods.
 583  */
 584 static HRESULT WINAPI DefaultHandler_GetClipboardData(
 585             IOleObject*        iface,
 586             DWORD              dwReserved,
 587             IDataObject**      ppDataObject)
 588 {
 589   DefaultHandler *This = impl_from_IOleObject(iface);
 590
 591   TRACE("(%p, %d, %p)\n",
 592         iface, dwReserved, ppDataObject);
 593
 594   if (object_is_running(This))
 595     return IOleObject_GetClipboardData(This->pOleDelegate, dwReserved,
 596                                        ppDataObject);
 597
 598   return OLE_E_NOTRUNNING;
 599 }
 600
 601 static HRESULT WINAPI DefaultHandler_DoVerb(
 602             IOleObject*        iface,
 603             LONG               iVerb,
 604             struct tagMSG*     lpmsg,
 605             IOleClientSite*    pActiveSite,
 606             LONG               lindex,
 607             HWND               hwndParent,
 608             LPCRECT            lprcPosRect)
 609 {
 610   DefaultHandler *This = impl_from_IOleObject(iface);
 611   IRunnableObject *pRunnableObj = (IRunnableObject *)&This->lpvtblIRunnableObject;
 612   HRESULT hr;
 613
 614   TRACE("(%d, %p, %p, %d, %p, %s)\n", iVerb, lpmsg, pActiveSite, lindex, hwndParent, wine_dbgstr_rect(lprcPosRect));
 615
 616   hr = IRunnableObject_Run(pRunnableObj, NULL);
 617   if (FAILED(hr)) return hr;
 618
 619   return IOleObject_DoVerb(This->pOleDelegate, iVerb, lpmsg, pActiveSite,
 620                            lindex, hwndParent, lprcPosRect);
 621 }
 622
 623 /************************************************************************
 624  * DefaultHandler_EnumVerbs (IOleObject)
 625  *
 626  * The default handler implementation of this method simply delegates
 627  * to OleRegEnumVerbs
 628  *
 629  * See Windows documentation for more details on IOleObject methods.
 630  */
 631 static HRESULT WINAPI DefaultHandler_EnumVerbs(
 632             IOleObject*        iface,
 633             IEnumOLEVERB**     ppEnumOleVerb)
 634 {
 635   DefaultHandler *This = impl_from_IOleObject(iface);
 636   HRESULT hr = OLE_S_USEREG;
 637
 638   TRACE("(%p, %p)\n", iface, ppEnumOleVerb);
 639
 640   if (object_is_running(This))
 641     hr = IOleObject_EnumVerbs(This->pOleDelegate, ppEnumOleVerb);
 642
 643   if (hr == OLE_S_USEREG)
 644     return OleRegEnumVerbs(&This->clsid, ppEnumOleVerb);
 645   else
 646     return hr;
 647 }
 648
 649 static HRESULT WINAPI DefaultHandler_Update(
 650             IOleObject*        iface)
 651 {
 652     DefaultHandler *This = impl_from_IOleObject(iface);
 653     TRACE("(%p)\n", iface);
 654
 655     if (!object_is_running(This))
 656     {
 657         FIXME("Should run object\n");
 658         return E_NOTIMPL;
 659     }
 660     return IOleObject_Update(This->pOleDelegate);
 661 }
 662
 663 /************************************************************************
 664  * DefaultHandler_IsUpToDate (IOleObject)
 665  *
 666  * This method is meaningless if the server is not running
 667  *
 668  * See Windows documentation for more details on IOleObject methods.
 669  */
 670 static HRESULT WINAPI DefaultHandler_IsUpToDate(
 671             IOleObject*        iface)
 672 {
 673     DefaultHandler *This = impl_from_IOleObject(iface);
 674     TRACE("(%p)\n", iface);
 675
 676     if (object_is_running(This))
 677         return IOleObject_IsUpToDate(This->pOleDelegate);
 678
 679     return OLE_E_NOTRUNNING;
 680 }
 681
 682 /************************************************************************
 683  * DefaultHandler_GetUserClassID (IOleObject)
 684  *
 685  * TODO: Map to a new class ID if emulation is active.
 686  *
 687  * See Windows documentation for more details on IOleObject methods.
 688  */
 689 static HRESULT WINAPI DefaultHandler_GetUserClassID(
 690             IOleObject*        iface,
 691             CLSID*             pClsid)
 692 {
 693   DefaultHandler *This = impl_from_IOleObject(iface);
 694
 695   TRACE("(%p, %p)\n", iface, pClsid);
 696
 697   if (object_is_running(This))
 698     return IOleObject_GetUserClassID(This->pOleDelegate, pClsid);
 699
 700   if (!pClsid)
 701     return E_POINTER;
 702
 703   *pClsid = This->clsid;
 704
 705   return S_OK;
 706 }
 707
 708 /************************************************************************
 709  * DefaultHandler_GetUserType (IOleObject)
 710  *
 711  * The default handler implementation of this method simply delegates
 712  * to OleRegGetUserType
 713  *
 714  * See Windows documentation for more details on IOleObject methods.
 715  */
 716 static HRESULT WINAPI DefaultHandler_GetUserType(
 717             IOleObject*        iface,
 718             DWORD              dwFormOfType,
 719             LPOLESTR*          pszUserType)
 720 {
 721   DefaultHandler *This = impl_from_IOleObject(iface);
 722
 723   TRACE("(%p, %d, %p)\n", iface, dwFormOfType, pszUserType);
 724   if (object_is_running(This))
 725     return IOleObject_GetUserType(This->pOleDelegate, dwFormOfType, pszUserType);
 726
 727   return OleRegGetUserType(&This->clsid, dwFormOfType, pszUserType);
 728 }
 729
 730 /************************************************************************
 731  * DefaultHandler_SetExtent (IOleObject)
 732  *
 733  * This method is meaningless if the server is not running
 734  *
 735  * See Windows documentation for more details on IOleObject methods.
 736  */
 737 static HRESULT WINAPI DefaultHandler_SetExtent(
 738             IOleObject*        iface,
 739             DWORD              dwDrawAspect,
 740             SIZEL*             psizel)
 741 {
 742   DefaultHandler *This = impl_from_IOleObject(iface);
 743
 744   TRACE("(%p, %x, (%d x %d))\n", iface,
 745         dwDrawAspect, psizel->cx, psizel->cy);
 746
 747   if (object_is_running(This))
 748     return IOleObject_SetExtent(This->pOleDelegate, dwDrawAspect, psizel);
 749
 750   return OLE_E_NOTRUNNING;
 751 }
 752
 753 /************************************************************************
 754  * DefaultHandler_GetExtent (IOleObject)
 755  *
 756  * The default handler's implementation of this method returns uses
 757  * the cache to locate the aspect and extract the extent from it.
 758  *
 759  * See Windows documentation for more details on IOleObject methods.
 760  */
 761 static HRESULT WINAPI DefaultHandler_GetExtent(
 762             IOleObject*        iface,
 763             DWORD              dwDrawAspect,
 764             SIZEL*             psizel)
 765 {
 766   DVTARGETDEVICE* targetDevice;
 767   IViewObject2*   cacheView = NULL;
 768   HRESULT         hres;
 769
 770   DefaultHandler *This = impl_from_IOleObject(iface);
 771
 772   TRACE("(%p, %x, %p)\n", iface, dwDrawAspect, psizel);
 773
 774   if (object_is_running(This))
 775     return IOleObject_GetExtent(This->pOleDelegate, dwDrawAspect, psizel);
 776
 777   hres = IUnknown_QueryInterface(This->dataCache, &IID_IViewObject2, (void**)&cacheView);
 778   if (FAILED(hres))
 779     return E_UNEXPECTED;
 780
 781   /*
 782    * Prepare the call to the cache's GetExtent method.
 783    *
 784    * Here we would build a valid DVTARGETDEVICE structure
 785    * but, since we are calling into the data cache, we
 786    * know its implementation and we'll skip this
 787    * extra work until later.
 788    */
 789   targetDevice = NULL;
 790
 791   hres = IViewObject2_GetExtent(cacheView,
 792                                 dwDrawAspect,
 793                                 -1,
 794                                 targetDevice,
 795                                 psizel);
 796
 797   IViewObject2_Release(cacheView);
 798
 799   return hres;
 800 }
 801
 802 /************************************************************************
 803  * DefaultHandler_Advise (IOleObject)
 804  *
 805  * The default handler's implementation of this method simply
 806  * delegates to the OleAdviseHolder.
 807  *
 808  * See Windows documentation for more details on IOleObject methods.
 809  */
 810 static HRESULT WINAPI DefaultHandler_Advise(
 811             IOleObject*        iface,
 812             IAdviseSink*       pAdvSink,
 813             DWORD*             pdwConnection)
 814 {
 815   HRESULT hres = S_OK;
 816   DefaultHandler *This = impl_from_IOleObject(iface);
 817
 818   TRACE("(%p, %p, %p)\n", iface, pAdvSink, pdwConnection);
 819
 820   /* Make sure we have an advise holder before we start. */
 821   if (!This->oleAdviseHolder)
 822     hres = CreateOleAdviseHolder(&This->oleAdviseHolder);
 823
 824   if (SUCCEEDED(hres))
 825     hres = IOleAdviseHolder_Advise(This->oleAdviseHolder,
 826                                    pAdvSink,
 827                                    pdwConnection);
 828
 829   return hres;
 830 }
 831
 832 /************************************************************************
 833  * DefaultHandler_Unadvise (IOleObject)
 834  *
 835  * The default handler's implementation of this method simply
 836  * delegates to the OleAdviseHolder.
 837  *
 838  * See Windows documentation for more details on IOleObject methods.
 839  */
 840 static HRESULT WINAPI DefaultHandler_Unadvise(
 841             IOleObject*        iface,
 842             DWORD              dwConnection)
 843 {
 844   DefaultHandler *This = impl_from_IOleObject(iface);
 845
 846   TRACE("(%p, %d)\n", iface, dwConnection);
 847
 848   /*
 849    * If we don't have an advise holder yet, it means we don't have
 850    * a connection.
 851    */
 852   if (!This->oleAdviseHolder)
 853     return OLE_E_NOCONNECTION;
 854
 855   return IOleAdviseHolder_Unadvise(This->oleAdviseHolder,
 856                                    dwConnection);
 857 }
 858
 859 /************************************************************************
 860  * DefaultHandler_EnumAdvise (IOleObject)
 861  *
 862  * The default handler's implementation of this method simply
 863  * delegates to the OleAdviseHolder.
 864  *
 865  * See Windows documentation for more details on IOleObject methods.
 866  */
 867 static HRESULT WINAPI DefaultHandler_EnumAdvise(
 868             IOleObject*        iface,
 869             IEnumSTATDATA**    ppenumAdvise)
 870 {
 871   DefaultHandler *This = impl_from_IOleObject(iface);
 872
 873   TRACE("(%p, %p)\n", iface, ppenumAdvise);
 874
 875   if (!ppenumAdvise)
 876     return E_POINTER;
 877
 878   *ppenumAdvise = NULL;
 879
 880   if (!This->oleAdviseHolder)
 881       return S_OK;
 882
 883   return IOleAdviseHolder_EnumAdvise(This->oleAdviseHolder, ppenumAdvise);
 884 }
 885
 886 /************************************************************************
 887  * DefaultHandler_GetMiscStatus (IOleObject)
 888  *
 889  * The default handler's implementation of this method simply delegates
 890  * to OleRegGetMiscStatus.
 891  *
 892  * See Windows documentation for more details on IOleObject methods.
 893  */
 894 static HRESULT WINAPI DefaultHandler_GetMiscStatus(
 895             IOleObject*        iface,
 896             DWORD              dwAspect,
 897             DWORD*             pdwStatus)
 898 {
 899   HRESULT hres;
 900   DefaultHandler *This = impl_from_IOleObject(iface);
 901
 902   TRACE("(%p, %x, %p)\n", iface, dwAspect, pdwStatus);
 903
 904   if (object_is_running(This))
 905     return IOleObject_GetMiscStatus(This->pOleDelegate, dwAspect, pdwStatus);
 906
 907   hres = OleRegGetMiscStatus(&This->clsid, dwAspect, pdwStatus);
 908
 909   if (FAILED(hres))
 910     *pdwStatus = 0;
 911
 912   return hres;
 913 }
 914
 915 /************************************************************************
 916  * DefaultHandler_SetColorScheme (IOleObject)
 917  *
 918  * This method is meaningless if the server is not running
 919  *
 920  * See Windows documentation for more details on IOleObject methods.
 921  */
 922 static HRESULT WINAPI DefaultHandler_SetColorScheme(
 923             IOleObject*           iface,
 924             struct tagLOGPALETTE* pLogpal)
 925 {
 926   DefaultHandler *This = impl_from_IOleObject(iface);
 927
 928   TRACE("(%p, %p))\n", iface, pLogpal);
 929
 930   if (object_is_running(This))
 931     return IOleObject_SetColorScheme(This->pOleDelegate, pLogpal);
 932
 933   return OLE_E_NOTRUNNING;
 934 }
 935
 936 /*********************************************************
 937  * Methods implementation for the IDataObject part of
 938  * the DefaultHandler class.
 939  */
 940
 941 /************************************************************************
 942  * DefaultHandler_IDataObject_QueryInterface (IUnknown)
 943  *
 944  * See Windows documentation for more details on IUnknown methods.
 945  */
 946 static HRESULT WINAPI DefaultHandler_IDataObject_QueryInterface(
 947             IDataObject*     iface,
 948            REFIID           riid,
 949             void**           ppvObject)
 950 {
 951   DefaultHandler *This = impl_from_IDataObject(iface);
 952
 953   return IUnknown_QueryInterface(This->outerUnknown, riid, ppvObject);
 954 }
 955
 956 /************************************************************************
 957  * DefaultHandler_IDataObject_AddRef (IUnknown)
 958  *
 959  * See Windows documentation for more details on IUnknown methods.
 960  */
 961 static ULONG WINAPI DefaultHandler_IDataObject_AddRef(
 962             IDataObject*     iface)
 963 {
 964   DefaultHandler *This = impl_from_IDataObject(iface);
 965
 966   return IUnknown_AddRef(This->outerUnknown);
 967 }
 968
 969 /************************************************************************
 970  * DefaultHandler_IDataObject_Release (IUnknown)
 971  *
 972  * See Windows documentation for more details on IUnknown methods.
 973  */
 974 static ULONG WINAPI DefaultHandler_IDataObject_Release(
 975             IDataObject*     iface)
 976 {
 977   DefaultHandler *This = impl_from_IDataObject(iface);
 978
 979   return IUnknown_Release(This->outerUnknown);
 980 }
 981
 982 /************************************************************************
 983  * DefaultHandler_GetData
 984  *
 985  * Get Data from a source dataobject using format pformatetcIn->cfFormat
 986  * See Windows documentation for more details on GetData.
 987  * Default handler's implementation of this method delegates to the cache.
 988  */
 989 static HRESULT WINAPI DefaultHandler_GetData(
 990             IDataObject*     iface,
 991             LPFORMATETC      pformatetcIn,
 992             STGMEDIUM*       pmedium)
 993 {
 994   IDataObject* cacheDataObject = NULL;
 995   HRESULT      hres;
 996
 997   DefaultHandler *This = impl_from_IDataObject(iface);
 998
 999   TRACE("(%p, %p, %p)\n", iface, pformatetcIn, pmedium);
1000
1001   hres = IUnknown_QueryInterface(This->dataCache,
1002                                  &IID_IDataObject,
1003                                  (void**)&cacheDataObject);
1004
1005   if (FAILED(hres))
1006     return E_UNEXPECTED;
1007
1008   hres = IDataObject_GetData(cacheDataObject,
1009                              pformatetcIn,
1010                              pmedium);
1011
1012   IDataObject_Release(cacheDataObject);
1013
1014   if (FAILED(hres) && This->pDataDelegate)
1015     hres = IDataObject_GetData(This->pDataDelegate, pformatetcIn, pmedium);
1016
1017   return hres;
1018 }
1019
1020 static HRESULT WINAPI DefaultHandler_GetDataHere(
1021             IDataObject*     iface,
1022             LPFORMATETC      pformatetc,
1023             STGMEDIUM*       pmedium)
1024 {
1025   FIXME(": Stub\n");
1026   return E_NOTIMPL;
1027 }
1028
1029 /************************************************************************
1030  * DefaultHandler_QueryGetData (IDataObject)
1031  *
1032  * The default handler's implementation of this method delegates to
1033  * the cache.
1034  *
1035  * See Windows documentation for more details on IDataObject methods.
1036  */
1037 static HRESULT WINAPI DefaultHandler_QueryGetData(
1038             IDataObject*     iface,
1039             LPFORMATETC      pformatetc)
1040 {
1041   IDataObject* cacheDataObject = NULL;
1042   HRESULT      hres;
1043
1044   DefaultHandler *This = impl_from_IDataObject(iface);
1045
1046   TRACE("(%p, %p)\n", iface, pformatetc);
1047
1048   hres = IUnknown_QueryInterface(This->dataCache,
1049                                  &IID_IDataObject,
1050                                  (void**)&cacheDataObject);
1051
1052   if (FAILED(hres))
1053     return E_UNEXPECTED;
1054
1055   hres = IDataObject_QueryGetData(cacheDataObject,
1056                                   pformatetc);
1057
1058   IDataObject_Release(cacheDataObject);
1059
1060   if (FAILED(hres) && This->pDataDelegate)
1061     hres = IDataObject_QueryGetData(This->pDataDelegate, pformatetc);
1062
1063   return hres;
1064 }
1065
1066 /************************************************************************
1067  * DefaultHandler_GetCanonicalFormatEtc (IDataObject)
1068  *
1069  * This method is meaningless if the server is not running
1070  *
1071  * See Windows documentation for more details on IDataObject methods.
1072  */
1073 static HRESULT WINAPI DefaultHandler_GetCanonicalFormatEtc(
1074             IDataObject*     iface,
1075             LPFORMATETC      pformatetcIn,
1076             LPFORMATETC      pformatetcOut)
1077 {
1078   DefaultHandler *This = impl_from_IDataObject(iface);
1079
1080   TRACE("(%p, %p, %p)\n", iface, pformatetcIn, pformatetcOut);
1081
1082   if (!This->pDataDelegate)
1083     return OLE_E_NOTRUNNING;
1084
1085   return IDataObject_GetCanonicalFormatEtc(This->pDataDelegate, pformatetcIn, pformatetcOut);
1086 }
1087
1088 /************************************************************************
1089  * DefaultHandler_SetData (IDataObject)
1090  *
1091  * The default handler's implementation of this method delegates to
1092  * the cache.
1093  *
1094  * See Windows documentation for more details on IDataObject methods.
1095  */
1096 static HRESULT WINAPI DefaultHandler_SetData(
1097             IDataObject*     iface,
1098             LPFORMATETC      pformatetc,
1099             STGMEDIUM*       pmedium,
1100             BOOL             fRelease)
1101 {
1102   DefaultHandler *This = impl_from_IDataObject(iface);
1103   IDataObject* cacheDataObject = NULL;
1104   HRESULT      hres;
1105
1106   TRACE("(%p, %p, %p, %d)\n", iface, pformatetc, pmedium, fRelease);
1107
1108   hres = IUnknown_QueryInterface(This->dataCache,
1109                                  &IID_IDataObject,
1110                                  (void**)&cacheDataObject);
1111
1112   if (FAILED(hres))
1113     return E_UNEXPECTED;
1114
1115   hres = IDataObject_SetData(cacheDataObject,
1116                              pformatetc,
1117                              pmedium,
1118                              fRelease);
1119
1120   IDataObject_Release(cacheDataObject);
1121
1122   return hres;
1123 }
1124
1125 /************************************************************************
1126  * DefaultHandler_EnumFormatEtc (IDataObject)
1127  *
1128  * The default handler's implementation of This method simply delegates
1129  * to OleRegEnumFormatEtc.
1130  *
1131  * See Windows documentation for more details on IDataObject methods.
1132  */
1133 static HRESULT WINAPI DefaultHandler_EnumFormatEtc(
1134             IDataObject*     iface,
1135             DWORD            dwDirection,
1136             IEnumFORMATETC** ppenumFormatEtc)
1137 {
1138   HRESULT hres;
1139   DefaultHandler *This = impl_from_IDataObject(iface);
1140
1141   TRACE("(%p, %x, %p)\n", iface, dwDirection, ppenumFormatEtc);
1142
1143   hres = OleRegEnumFormatEtc(&This->clsid, dwDirection, ppenumFormatEtc);
1144
1145   return hres;
1146 }
1147
1148 /************************************************************************
1149  * DefaultHandler_DAdvise (IDataObject)
1150  *
1151  * The default handler's implementation of this method simply
1152  * delegates to the DataAdviseHolder.
1153  *
1154  * See Windows documentation for more details on IDataObject methods.
1155  */
1156 static HRESULT WINAPI DefaultHandler_DAdvise(
1157             IDataObject*     iface,
1158             FORMATETC*       pformatetc,
1159             DWORD            advf,
1160             IAdviseSink*     pAdvSink,
1161             DWORD*           pdwConnection)
1162 {
1163   HRESULT hres = S_OK;
1164   DefaultHandler *This = impl_from_IDataObject(iface);
1165
1166   TRACE("(%p, %p, %d, %p, %p)\n",
1167         iface, pformatetc, advf, pAdvSink, pdwConnection);
1168
1169   /* Make sure we have a data advise holder before we start. */
1170   if (!This->dataAdviseHolder)
1171   {
1172     hres = CreateDataAdviseHolder(&This->dataAdviseHolder);
1173     if (SUCCEEDED(hres) && This->pDataDelegate)
1174       DataAdviseHolder_OnConnect(This->dataAdviseHolder, This->pDataDelegate);
1175   }
1176
1177   if (SUCCEEDED(hres))
1178     hres = IDataAdviseHolder_Advise(This->dataAdviseHolder,
1179                                     iface,
1180                                     pformatetc,
1181                                     advf,
1182                                     pAdvSink,
1183                                     pdwConnection);
1184
1185   return hres;
1186 }
1187
1188 /************************************************************************
1189  * DefaultHandler_DUnadvise (IDataObject)
1190  *
1191  * The default handler's implementation of this method simply
1192  * delegates to the DataAdviseHolder.
1193  *
1194  * See Windows documentation for more details on IDataObject methods.
1195  */
1196 static HRESULT WINAPI DefaultHandler_DUnadvise(
1197             IDataObject*     iface,
1198             DWORD            dwConnection)
1199 {
1200   DefaultHandler *This = impl_from_IDataObject(iface);
1201
1202   TRACE("(%p, %d)\n", iface, dwConnection);
1203
1204   /*
1205    * If we don't have a data advise holder yet, it means that
1206    * we don't have any connections..
1207    */
1208   if (!This->dataAdviseHolder)
1209     return OLE_E_NOCONNECTION;
1210
1211   return IDataAdviseHolder_Unadvise(This->dataAdviseHolder,
1212                                     dwConnection);
1213 }
1214
1215 /************************************************************************
1216  * DefaultHandler_EnumDAdvise (IDataObject)
1217  *
1218  * The default handler's implementation of this method simply
1219  * delegates to the DataAdviseHolder.
1220  *
1221  * See Windows documentation for more details on IDataObject methods.
1222  */
1223 static HRESULT WINAPI DefaultHandler_EnumDAdvise(
1224             IDataObject*     iface,
1225             IEnumSTATDATA**  ppenumAdvise)
1226 {
1227   DefaultHandler *This = impl_from_IDataObject(iface);
1228
1229   TRACE("(%p, %p)\n", iface, ppenumAdvise);
1230
1231   if (!ppenumAdvise)
1232     return E_POINTER;
1233
1234   *ppenumAdvise = NULL;
1235
1236   /* If we have a data advise holder object, delegate. */
1237   if (This->dataAdviseHolder)
1238     return IDataAdviseHolder_EnumAdvise(This->dataAdviseHolder,
1239                                         ppenumAdvise);
1240
1241   return S_OK;
1242 }
1243
1244 /*********************************************************
1245  * Methods implementation for the IRunnableObject part
1246  * of the DefaultHandler class.
1247  */
1248
1249 /************************************************************************
1250  * DefaultHandler_IRunnableObject_QueryInterface (IUnknown)
1251  *
1252  * See Windows documentation for more details on IUnknown methods.
1253  */
1254 static HRESULT WINAPI DefaultHandler_IRunnableObject_QueryInterface(
1255             IRunnableObject*     iface,
1256             REFIID               riid,
1257             void**               ppvObject)
1258 {
1259   DefaultHandler *This = impl_from_IRunnableObject(iface);
1260
1261   return IUnknown_QueryInterface(This->outerUnknown, riid, ppvObject);
1262 }
1263
1264 /************************************************************************
1265  * DefaultHandler_IRunnableObject_AddRef (IUnknown)
1266  *
1267  * See Windows documentation for more details on IUnknown methods.
1268  */
1269 static ULONG WINAPI DefaultHandler_IRunnableObject_AddRef(
1270             IRunnableObject*     iface)
1271 {
1272   DefaultHandler *This = impl_from_IRunnableObject(iface);
1273
1274   return IUnknown_AddRef(This->outerUnknown);
1275 }
1276
1277 /************************************************************************
1278  * DefaultHandler_IRunnableObject_Release (IUnknown)
1279  *
1280  * See Windows documentation for more details on IUnknown methods.
1281  */
1282 static ULONG WINAPI DefaultHandler_IRunnableObject_Release(
1283             IRunnableObject*     iface)
1284 {
1285   DefaultHandler *This = impl_from_IRunnableObject(iface);
1286
1287   return IUnknown_Release(This->outerUnknown);
1288 }
1289
1290 /************************************************************************
1291  * DefaultHandler_GetRunningClass (IRunnableObject)
1292  *
1293  * See Windows documentation for more details on IRunnableObject methods.
1294  */
1295 static HRESULT WINAPI DefaultHandler_GetRunningClass(
1296             IRunnableObject*     iface,
1297             LPCLSID              lpClsid)
1298 {
1299   FIXME("()\n");
1300   return S_OK;
1301 }
1302
1303 static HRESULT WINAPI DefaultHandler_Run(
1304             IRunnableObject*     iface,
1305             IBindCtx*            pbc)
1306 {
1307   DefaultHandler *This = impl_from_IRunnableObject(iface);
1308   HRESULT hr;
1309
1310   FIXME("(%p): semi-stub\n", pbc);
1311
1312   /* already running? if so nothing to do */
1313   if (object_is_running(This))
1314     return S_OK;
1315
1316   release_delegates(This);
1317
1318   hr = CoCreateInstance(&This->clsid, NULL, CLSCTX_LOCAL_SERVER,
1319                         &IID_IOleObject, (void **)&This->pOleDelegate);
1320   if (FAILED(hr))
1321     return hr;
1322
1323   This->object_state = object_state_running;
1324
1325   hr = IOleObject_Advise(This->pOleDelegate,
1326                          (IAdviseSink *)&This->lpvtblIAdviseSink,
1327                          &This->dwAdvConn);
1328
1329   if (SUCCEEDED(hr) && This->clientSite)
1330     hr = IOleObject_SetClientSite(This->pOleDelegate, This->clientSite);
1331
1332   if (SUCCEEDED(hr))
1333   {
1334     IOleObject_QueryInterface(This->pOleDelegate, &IID_IPersistStorage,
1335                               (void **)&This->pPSDelegate);
1336     if (This->pPSDelegate)
1337     {
1338       if(This->storage_state == storage_state_initialised)
1339         hr = IPersistStorage_InitNew(This->pPSDelegate, This->storage);
1340       else if(This->storage_state == storage_state_loaded)
1341         hr = IPersistStorage_Load(This->pPSDelegate, This->storage);
1342     }
1343   }
1344
1345   if (SUCCEEDED(hr) && This->containerApp)
1346     hr = IOleObject_SetHostNames(This->pOleDelegate, This->containerApp,
1347                                  This->containerObj);
1348
1349   /* FIXME: do more stuff here:
1350    * - IOleObject_GetMiscStatus
1351    * - IOleObject_GetMoniker
1352    * - IOleCache_OnRun
1353    */
1354
1355   if (SUCCEEDED(hr))
1356     hr = IOleObject_QueryInterface(This->pOleDelegate, &IID_IDataObject,
1357                                    (void **)&This->pDataDelegate);
1358
1359   if (SUCCEEDED(hr) && This->dataAdviseHolder)
1360     hr = DataAdviseHolder_OnConnect(This->dataAdviseHolder, This->pDataDelegate);
1361
1362   if (FAILED(hr))
1363   {
1364     DefaultHandler_Stop(This);
1365     release_delegates(This);
1366   }
1367
1368   return hr;
1369 }
1370
1371 /************************************************************************
1372  * DefaultHandler_IsRunning (IRunnableObject)
1373  *
1374  * See Windows documentation for more details on IRunnableObject methods.
1375  */
1376 static BOOL    WINAPI DefaultHandler_IsRunning(
1377             IRunnableObject*     iface)
1378 {
1379   DefaultHandler *This = impl_from_IRunnableObject(iface);
1380
1381   TRACE("()\n");
1382
1383   if (This->object_state == object_state_running)
1384     return TRUE;
1385   else
1386     return FALSE;
1387 }
1388
1389 /************************************************************************
1390  * DefaultHandler_LockRunning (IRunnableObject)
1391  *
1392  * See Windows documentation for more details on IRunnableObject methods.
1393  */
1394 static HRESULT WINAPI DefaultHandler_LockRunning(
1395             IRunnableObject*     iface,
1396             BOOL                 fLock,
1397             BOOL                 fLastUnlockCloses)
1398 {
1399   FIXME("()\n");
1400   return S_OK;
1401 }
1402
1403 /************************************************************************
1404  * DefaultHandler_SetContainedObject (IRunnableObject)
1405  *
1406  * See Windows documentation for more details on IRunnableObject methods.
1407  */
1408 static HRESULT WINAPI DefaultHandler_SetContainedObject(
1409             IRunnableObject*     iface,
1410             BOOL                 fContained)
1411 {
1412   FIXME("()\n");
1413   return S_OK;
1414 }
1415
1416 static HRESULT WINAPI DefaultHandler_IAdviseSink_QueryInterface(
1417     IAdviseSink *iface,
1418     REFIID riid,
1419     void **ppvObject)
1420 {
1421     if (IsEqualIID(riid, &IID_IUnknown) ||
1422         IsEqualIID(riid, &IID_IAdviseSink))
1423     {
1424         *ppvObject = iface;
1425         IAdviseSink_AddRef(iface);
1426         return S_OK;
1427     }
1428
1429     return E_NOINTERFACE;
1430 }
1431
1432 static ULONG WINAPI DefaultHandler_IAdviseSink_AddRef(
1433     IAdviseSink *iface)
1434 {
1435     DefaultHandler *This = impl_from_IAdviseSink(iface);
1436
1437     return IUnknown_AddRef((IUnknown *)&This->lpvtblIUnknown);
1438 }
1439
1440 static ULONG WINAPI DefaultHandler_IAdviseSink_Release(
1441             IAdviseSink *iface)
1442 {
1443     DefaultHandler *This = impl_from_IAdviseSink(iface);
1444
1445     return IUnknown_Release((IUnknown *)&This->lpvtblIUnknown);
1446 }
1447
1448 static void WINAPI DefaultHandler_IAdviseSink_OnDataChange(
1449     IAdviseSink *iface,
1450     FORMATETC *pFormatetc,
1451     STGMEDIUM *pStgmed)
1452 {
1453     FIXME(": stub\n");
1454 }
1455
1456 static void WINAPI DefaultHandler_IAdviseSink_OnViewChange(
1457     IAdviseSink *iface,
1458     DWORD dwAspect,
1459     LONG lindex)
1460 {
1461     FIXME(": stub\n");
1462 }
1463
1464 static void WINAPI DefaultHandler_IAdviseSink_OnRename(
1465     IAdviseSink *iface,
1466     IMoniker *pmk)
1467 {
1468     DefaultHandler *This = impl_from_IAdviseSink(iface);
1469
1470     TRACE("(%p)\n", pmk);
1471
1472     if (This->oleAdviseHolder)
1473         IOleAdviseHolder_SendOnRename(This->oleAdviseHolder, pmk);
1474 }
1475
1476 static void WINAPI DefaultHandler_IAdviseSink_OnSave(
1477     IAdviseSink *iface)
1478 {
1479     DefaultHandler *This = impl_from_IAdviseSink(iface);
1480
1481     TRACE("()\n");
1482
1483     if (This->oleAdviseHolder)
1484         IOleAdviseHolder_SendOnSave(This->oleAdviseHolder);
1485 }
1486
1487 static void WINAPI DefaultHandler_IAdviseSink_OnClose(
1488     IAdviseSink *iface)
1489 {
1490     DefaultHandler *This = impl_from_IAdviseSink(iface);
1491
1492     TRACE("()\n");
1493
1494     if (This->oleAdviseHolder)
1495         IOleAdviseHolder_SendOnClose(This->oleAdviseHolder);
1496
1497     DefaultHandler_Stop(This);
1498 }
1499
1500
1501 /************************************************************************
1502  * DefaultHandler_IPersistStorage_QueryInterface
1503  *
1504  */
1505 static HRESULT WINAPI DefaultHandler_IPersistStorage_QueryInterface(
1506             IPersistStorage*     iface,
1507             REFIID               riid,
1508             void**               ppvObject)
1509 {
1510   DefaultHandler *This = impl_from_IPersistStorage(iface);
1511
1512   return IUnknown_QueryInterface(This->outerUnknown, riid, ppvObject);
1513 }
1514
1515 /************************************************************************
1516  * DefaultHandler_IPersistStorage_AddRef
1517  *
1518  */
1519 static ULONG WINAPI DefaultHandler_IPersistStorage_AddRef(
1520             IPersistStorage*     iface)
1521 {
1522   DefaultHandler *This = impl_from_IPersistStorage(iface);
1523
1524   return IUnknown_AddRef(This->outerUnknown);
1525 }
1526
1527 /************************************************************************
1528  * DefaultHandler_IPersistStorage_Release
1529  *
1530  */
1531 static ULONG WINAPI DefaultHandler_IPersistStorage_Release(
1532             IPersistStorage*     iface)
1533 {
1534   DefaultHandler *This = impl_from_IPersistStorage(iface);
1535
1536   return IUnknown_Release(This->outerUnknown);
1537 }
1538
1539 /************************************************************************
1540  * DefaultHandler_IPersistStorage_GetClassID
1541  *
1542  */
1543 static HRESULT WINAPI DefaultHandler_IPersistStorage_GetClassID(
1544             IPersistStorage*     iface,
1545             CLSID*               clsid)
1546 {
1547     DefaultHandler *This = impl_from_IPersistStorage(iface);
1548     HRESULT hr;
1549
1550     TRACE("(%p)->(%p)\n", iface, clsid);
1551
1552     if(object_is_running(This))
1553         hr = IPersistStorage_GetClassID(This->pPSDelegate, clsid);
1554     else
1555         hr = IPersistStorage_GetClassID(This->dataCache_PersistStg, clsid);
1556
1557     return hr;
1558 }
1559
1560 /************************************************************************
1561  * DefaultHandler_IPersistStorage_IsDirty
1562  *
1563  */
1564 static HRESULT WINAPI DefaultHandler_IPersistStorage_IsDirty(
1565             IPersistStorage*     iface)
1566 {
1567     DefaultHandler *This = impl_from_IPersistStorage(iface);
1568     HRESULT hr;
1569
1570     TRACE("(%p)\n", iface);
1571
1572     hr = IPersistStorage_IsDirty(This->dataCache_PersistStg);
1573     if(hr != S_FALSE) return hr;
1574
1575     if(object_is_running(This))
1576         hr = IPersistStorage_IsDirty(This->pPSDelegate);
1577
1578     return hr;
1579 }
1580
1581 /***********************************************************************
1582  *   init_ole_stream
1583  *
1584  * Creates the '\1Ole' stream.
1585  * The format of this stream is as follows:
1586  *
1587  * DWORD Version == 0x02000001
1588  * DWORD Flags - low bit set indicates the object is a link otherwise it's embedded.
1589  * DWORD LinkupdateOption - [MS-OLEDS describes this as an implementation specific hint
1590  *                           supplied by the app that creates the data structure.  May be
1591  *                           ignored on processing].
1592  *
1593  * DWORD Reserved == 0
1594  * DWORD MonikerStreamSize - size of the rest of the data (ie CLSID + moniker stream data).
1595  * CLSID clsid - class id of object capable of processing the moniker
1596  * BYTE  data[] - moniker data for a link
1597  */
1598
1599 static const WCHAR OleStream[] = {1,'O','l','e',0};
1600 typedef struct
1601 {
1602     DWORD version;
1603     DWORD flags;
1604     DWORD link_update_opt;
1605     DWORD res;
1606     DWORD moniker_size;
1607 } ole_stream_header_t;
1608 static const DWORD ole_stream_version = 0x02000001;
1609
1610 static void init_ole_stream(IStorage *storage)
1611 {
1612     HRESULT hr;
1613     IStream *stream;
1614
1615     hr = IStorage_CreateStream(storage, OleStream, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stream);
1616     if(SUCCEEDED(hr))
1617     {
1618         DWORD written;
1619         ole_stream_header_t header;
1620
1621         header.version         = ole_stream_version;
1622         header.flags           = 0;
1623         header.link_update_opt = 0;
1624         header.res             = 0;
1625         header.moniker_size    = 0;
1626
1627         IStream_Write(stream, &header, sizeof(header), &written);
1628         IStream_Release(stream);
1629     }
1630     return;
1631 }
1632
1633 static HRESULT load_ole_stream(DefaultHandler *This, IStorage *storage)
1634 {
1635     IStream *stream;
1636     HRESULT hr;
1637
1638     hr = IStorage_OpenStream(storage, OleStream, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stream);
1639
1640     if(SUCCEEDED(hr))
1641     {
1642         DWORD read;
1643         ole_stream_header_t header;
1644
1645         hr = IStream_Read(stream, &header, sizeof(header), &read);
1646         if(hr == S_OK && read == sizeof(header) && header.version == ole_stream_version)
1647         {
1648             if(header.flags & 1)
1649             {
1650                 /* FIXME: Read the moniker and deal with the link */
1651                 FIXME("Linked objects are not supported yet\n");
1652             }
1653         }
1654         else
1655         {
1656             WARN("Incorrect OleStream header\n");
1657             hr = DV_E_CLIPFORMAT;
1658         }
1659         IStream_Release(stream);
1660     }
1661     else
1662     {
1663         init_ole_stream(storage);
1664         hr = S_OK;
1665     }
1666     return hr;
1667 }
1668
1669 /************************************************************************
1670  * DefaultHandler_IPersistStorage_InitNew
1671  *
1672  */
1673 static HRESULT WINAPI DefaultHandler_IPersistStorage_InitNew(
1674            IPersistStorage*     iface,
1675            IStorage*            pStg)
1676 {
1677     DefaultHandler *This = impl_from_IPersistStorage(iface);
1678     HRESULT hr;
1679
1680     TRACE("(%p)->(%p)\n", iface, pStg);
1681     init_ole_stream(pStg);
1682
1683     hr = IPersistStorage_InitNew(This->dataCache_PersistStg, pStg);
1684
1685     if(SUCCEEDED(hr) && object_is_running(This))
1686         hr = IPersistStorage_InitNew(This->pPSDelegate, pStg);
1687
1688     if(SUCCEEDED(hr))
1689     {
1690         IStorage_AddRef(pStg);
1691         This->storage = pStg;
1692         This->storage_state = storage_state_initialised;
1693     }
1694
1695     return hr;
1696 }
1697
1698
1699 /************************************************************************
1700  * DefaultHandler_IPersistStorage_Load
1701  *
1702  */
1703 static HRESULT WINAPI DefaultHandler_IPersistStorage_Load(
1704            IPersistStorage*     iface,
1705            IStorage*            pStg)
1706 {
1707     DefaultHandler *This = impl_from_IPersistStorage(iface);
1708     HRESULT hr;
1709
1710     TRACE("(%p)->(%p)\n", iface, pStg);
1711
1712     hr = load_ole_stream(This, pStg);
1713
1714     if(SUCCEEDED(hr))
1715         hr = IPersistStorage_Load(This->dataCache_PersistStg, pStg);
1716
1717     if(SUCCEEDED(hr) && object_is_running(This))
1718         hr = IPersistStorage_Load(This->pPSDelegate, pStg);
1719
1720     if(SUCCEEDED(hr))
1721     {
1722         IStorage_AddRef(pStg);
1723         This->storage = pStg;
1724         This->storage_state = storage_state_loaded;
1725     }
1726     return hr;
1727 }
1728
1729
1730 /************************************************************************
1731  * DefaultHandler_IPersistStorage_Save
1732  *
1733  */
1734 static HRESULT WINAPI DefaultHandler_IPersistStorage_Save(
1735            IPersistStorage*     iface,
1736            IStorage*            pStgSave,
1737            BOOL                 fSameAsLoad)
1738 {
1739     DefaultHandler *This = impl_from_IPersistStorage(iface);
1740     HRESULT hr;
1741
1742     TRACE("(%p)->(%p, %d)\n", iface, pStgSave, fSameAsLoad);
1743
1744     hr = IPersistStorage_Save(This->dataCache_PersistStg, pStgSave, fSameAsLoad);
1745     if(SUCCEEDED(hr) && object_is_running(This))
1746         hr = IPersistStorage_Save(This->pPSDelegate, pStgSave, fSameAsLoad);
1747
1748     return hr;
1749 }
1750
1751
1752 /************************************************************************
1753  * DefaultHandler_IPersistStorage_SaveCompleted
1754  *
1755  */
1756 static HRESULT WINAPI DefaultHandler_IPersistStorage_SaveCompleted(
1757            IPersistStorage*     iface,
1758            IStorage*            pStgNew)
1759 {
1760     DefaultHandler *This = impl_from_IPersistStorage(iface);
1761     HRESULT hr;
1762
1763     TRACE("(%p)->(%p)\n", iface, pStgNew);
1764
1765     hr = IPersistStorage_SaveCompleted(This->dataCache_PersistStg, pStgNew);
1766
1767     if(SUCCEEDED(hr) && object_is_running(This))
1768         hr = IPersistStorage_SaveCompleted(This->pPSDelegate, pStgNew);
1769
1770     if(pStgNew)
1771     {
1772         IStorage_AddRef(pStgNew);
1773         if(This->storage) IStorage_Release(This->storage);
1774         This->storage = pStgNew;
1775         This->storage_state = storage_state_loaded;
1776     }
1777
1778     return hr;
1779 }
1780
1781
1782 /************************************************************************
1783  * DefaultHandler_IPersistStorage_HandsOffStorage
1784  *
1785  */
1786 static HRESULT WINAPI DefaultHandler_IPersistStorage_HandsOffStorage(
1787             IPersistStorage*     iface)
1788 {
1789     DefaultHandler *This = impl_from_IPersistStorage(iface);
1790     HRESULT hr;
1791
1792     TRACE("(%p)\n", iface);
1793
1794     hr = IPersistStorage_HandsOffStorage(This->dataCache_PersistStg);
1795
1796     if(SUCCEEDED(hr) && object_is_running(This))
1797         hr = IPersistStorage_HandsOffStorage(This->pPSDelegate);
1798
1799     if(This->storage) IStorage_Release(This->storage);
1800     This->storage = NULL;
1801     This->storage_state = storage_state_uninitialised;
1802
1803     return hr;
1804 }
1805
1806
1807 /*
1808  * Virtual function tables for the DefaultHandler class.
1809  */
1810 static const IOleObjectVtbl DefaultHandler_IOleObject_VTable =
1811 {
1812   DefaultHandler_QueryInterface,
1813   DefaultHandler_AddRef,
1814   DefaultHandler_Release,
1815   DefaultHandler_SetClientSite,
1816   DefaultHandler_GetClientSite,
1817   DefaultHandler_SetHostNames,
1818   DefaultHandler_Close,
1819   DefaultHandler_SetMoniker,
1820   DefaultHandler_GetMoniker,
1821   DefaultHandler_InitFromData,
1822   DefaultHandler_GetClipboardData,
1823   DefaultHandler_DoVerb,
1824   DefaultHandler_EnumVerbs,
1825   DefaultHandler_Update,
1826   DefaultHandler_IsUpToDate,
1827   DefaultHandler_GetUserClassID,
1828   DefaultHandler_GetUserType,
1829   DefaultHandler_SetExtent,
1830   DefaultHandler_GetExtent,
1831   DefaultHandler_Advise,
1832   DefaultHandler_Unadvise,
1833   DefaultHandler_EnumAdvise,
1834   DefaultHandler_GetMiscStatus,
1835   DefaultHandler_SetColorScheme
1836 };
1837
1838 static const IUnknownVtbl DefaultHandler_NDIUnknown_VTable =
1839 {
1840   DefaultHandler_NDIUnknown_QueryInterface,
1841   DefaultHandler_NDIUnknown_AddRef,
1842   DefaultHandler_NDIUnknown_Release,
1843 };
1844
1845 static const IDataObjectVtbl DefaultHandler_IDataObject_VTable =
1846 {
1847   DefaultHandler_IDataObject_QueryInterface,
1848   DefaultHandler_IDataObject_AddRef,
1849   DefaultHandler_IDataObject_Release,
1850   DefaultHandler_GetData,
1851   DefaultHandler_GetDataHere,
1852   DefaultHandler_QueryGetData,
1853   DefaultHandler_GetCanonicalFormatEtc,
1854   DefaultHandler_SetData,
1855   DefaultHandler_EnumFormatEtc,
1856   DefaultHandler_DAdvise,
1857   DefaultHandler_DUnadvise,
1858   DefaultHandler_EnumDAdvise
1859 };
1860
1861 static const IRunnableObjectVtbl DefaultHandler_IRunnableObject_VTable =
1862 {
1863   DefaultHandler_IRunnableObject_QueryInterface,
1864   DefaultHandler_IRunnableObject_AddRef,
1865   DefaultHandler_IRunnableObject_Release,
1866   DefaultHandler_GetRunningClass,
1867   DefaultHandler_Run,
1868   DefaultHandler_IsRunning,
1869   DefaultHandler_LockRunning,
1870   DefaultHandler_SetContainedObject
1871 };
1872
1873 static const IAdviseSinkVtbl DefaultHandler_IAdviseSink_VTable =
1874 {
1875   DefaultHandler_IAdviseSink_QueryInterface,
1876   DefaultHandler_IAdviseSink_AddRef,
1877   DefaultHandler_IAdviseSink_Release,
1878   DefaultHandler_IAdviseSink_OnDataChange,
1879   DefaultHandler_IAdviseSink_OnViewChange,
1880   DefaultHandler_IAdviseSink_OnRename,
1881   DefaultHandler_IAdviseSink_OnSave,
1882   DefaultHandler_IAdviseSink_OnClose
1883 };
1884
1885 static const IPersistStorageVtbl DefaultHandler_IPersistStorage_VTable =
1886 {
1887   DefaultHandler_IPersistStorage_QueryInterface,
1888   DefaultHandler_IPersistStorage_AddRef,
1889   DefaultHandler_IPersistStorage_Release,
1890   DefaultHandler_IPersistStorage_GetClassID,
1891   DefaultHandler_IPersistStorage_IsDirty,
1892   DefaultHandler_IPersistStorage_InitNew,
1893   DefaultHandler_IPersistStorage_Load,
1894   DefaultHandler_IPersistStorage_Save,
1895   DefaultHandler_IPersistStorage_SaveCompleted,
1896   DefaultHandler_IPersistStorage_HandsOffStorage
1897 };
1898
1899 /*********************************************************
1900  * Methods implementation for the DefaultHandler class.
1901  */
1902 static DefaultHandler* DefaultHandler_Construct(
1903   REFCLSID  clsid,
1904   LPUNKNOWN pUnkOuter)
1905 {
1906   DefaultHandler* This = NULL;
1907   HRESULT hr;
1908
1909   This = HeapAlloc(GetProcessHeap(), 0, sizeof(DefaultHandler));
1910
1911   if (!This)
1912     return This;
1913
1914   This->lpVtbl = &DefaultHandler_IOleObject_VTable;
1915   This->lpvtblIUnknown = &DefaultHandler_NDIUnknown_VTable;
1916   This->lpvtblIDataObject = &DefaultHandler_IDataObject_VTable;
1917   This->lpvtblIRunnableObject = &DefaultHandler_IRunnableObject_VTable;
1918   This->lpvtblIAdviseSink = &DefaultHandler_IAdviseSink_VTable;
1919   This->lpvtblIPersistStorage = &DefaultHandler_IPersistStorage_VTable;
1920
1921   /*
1922    * Start with one reference count. The caller of this function
1923    * must release the interface pointer when it is done.
1924    */
1925   This->ref = 1;
1926
1927   /*
1928    * Initialize the outer unknown
1929    * We don't keep a reference on the outer unknown since, the way
1930    * aggregation works, our lifetime is at least as large as its
1931    * lifetime.
1932    */
1933   if (!pUnkOuter)
1934     pUnkOuter = (IUnknown*)&This->lpvtblIUnknown;
1935
1936   This->outerUnknown = pUnkOuter;
1937
1938   /*
1939    * Create a datacache object.
1940    * We aggregate with the datacache. Make sure we pass our outer
1941    * unknown as the datacache's outer unknown.
1942    */
1943   hr = CreateDataCache(This->outerUnknown,
1944                        clsid,
1945                        &IID_IUnknown,
1946                        (void**)&This->dataCache);
1947   if(SUCCEEDED(hr))
1948     hr = IUnknown_QueryInterface(This->dataCache, &IID_IPersistStorage, (void**)&This->dataCache_PersistStg);
1949   if(FAILED(hr))
1950     ERR("Unexpected error creating data cache\n");
1951
1952   This->clsid = *clsid;
1953   This->clientSite = NULL;
1954   This->oleAdviseHolder = NULL;
1955   This->dataAdviseHolder = NULL;
1956   This->containerApp = NULL;
1957   This->containerObj = NULL;
1958   This->pOleDelegate = NULL;
1959   This->pPSDelegate = NULL;
1960   This->pDataDelegate = NULL;
1961   This->object_state = object_state_not_running;
1962
1963   This->dwAdvConn = 0;
1964   This->storage = NULL;
1965   This->storage_state = storage_state_uninitialised;
1966
1967   return This;
1968 }
1969
1970 static void DefaultHandler_Destroy(
1971   DefaultHandler* This)
1972 {
1973   /* release delegates */
1974   DefaultHandler_Stop(This);
1975   release_delegates(This);
1976
1977   HeapFree( GetProcessHeap(), 0, This->containerApp );
1978   This->containerApp = NULL;
1979   HeapFree( GetProcessHeap(), 0, This->containerObj );
1980   This->containerObj = NULL;
1981
1982   if (This->dataCache)
1983   {
1984     IPersistStorage_Release(This->dataCache_PersistStg);
1985     IUnknown_Release(This->dataCache);
1986     This->dataCache_PersistStg = NULL;
1987     This->dataCache = NULL;
1988   }
1989
1990   if (This->clientSite)
1991   {
1992     IOleClientSite_Release(This->clientSite);
1993     This->clientSite = NULL;
1994   }
1995
1996   if (This->oleAdviseHolder)
1997   {
1998     IOleAdviseHolder_Release(This->oleAdviseHolder);
1999     This->oleAdviseHolder = NULL;
2000   }
2001
2002   if (This->dataAdviseHolder)
2003   {
2004     IDataAdviseHolder_Release(This->dataAdviseHolder);
2005     This->dataAdviseHolder = NULL;
2006   }
2007
2008   if (This->storage)
2009   {
2010     IStorage_Release(This->storage);
2011     This->storage = NULL;
2012   }
2013
2014   HeapFree(GetProcessHeap(), 0, This);
2015 }
2016
2017 /******************************************************************************
2018  * OleCreateDefaultHandler [OLE32.@]
2019  */
2020 HRESULT WINAPI OleCreateDefaultHandler(
2021   REFCLSID  clsid,
2022   LPUNKNOWN pUnkOuter,
2023   REFIID    riid,
2024   LPVOID*   ppvObj)
2025 {
2026   DefaultHandler* newHandler = NULL;
2027   HRESULT         hr         = S_OK;
2028
2029   TRACE("(%s, %p, %s, %p)\n", debugstr_guid(clsid), pUnkOuter, debugstr_guid(riid), ppvObj);
2030
2031   if (!ppvObj)
2032     return E_POINTER;
2033
2034   *ppvObj = NULL;
2035
2036   /*
2037    * If This handler is constructed for aggregation, make sure
2038    * the caller is requesting the IUnknown interface.
2039    * This is necessary because it's the only time the non-delegating
2040    * IUnknown pointer can be returned to the outside.
2041    */
2042   if (pUnkOuter && !IsEqualIID(&IID_IUnknown, riid))
2043     return CLASS_E_NOAGGREGATION;
2044
2045   /*
2046    * Try to construct a new instance of the class.
2047    */
2048   newHandler = DefaultHandler_Construct(clsid, pUnkOuter);
2049
2050   if (!newHandler)
2051     return E_OUTOFMEMORY;
2052
2053   /*
2054    * Make sure it supports the interface required by the caller.
2055    */
2056   hr = IUnknown_QueryInterface((IUnknown*)&newHandler->lpvtblIUnknown, riid, ppvObj);
2057
2058   /*
2059    * Release the reference obtained in the constructor. If
2060    * the QueryInterface was unsuccessful, it will free the class.
2061    */
2062   IUnknown_Release((IUnknown*)&newHandler->lpvtblIUnknown);
2063
2064   return hr;
2065 }