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