ole/defaulthandler.c

   1 /*
   2  *      OLE 2 default object handler
   3  *
   4  *      Copyright 1999  Francis Beaudet
   5  *
   6  * NOTES:
   7  *    The OLE2 default object handler supports a whole whack of
   8  *    interfaces including:
   9  *       IOleObject, IDataObject, IPersistStorage, IViewObject2,
  10  *       IRunnableObject, IOleCache2, IOleCacheControl and much more.
  11  *
  12  *    All the implementation details are taken from: Inside OLE
  13  *    second edition by Kraig Brockschmidt,
  14  *
  15  * TODO
  16  * - This implementation of the default handler does not launch the
  17  *   server in the DoVerb, Update, GetData, GetDataHere and Run
  18  *   methods. When it is fixed to do so, all the methods will have
  19  *   to be  revisited to allow delegating to the running object
  20  *
  21  * - All methods in the class that use the class ID should be
  22  *   aware that it is possible for a class to be treated as
  23  *   another one and go into emulation mode. Nothing has been
  24  *   done in this area.
  25  *
  26  * - Some functions still return E_NOTIMPL they have to be
  27  *   implemented. Most of those are related to the running of the
  28  *   actual server.
  29  *
  30  * - All the methods related to notification and advise sinks are
  31  *   in place but no notifications are sent to the sinks yet.
  32  */
  33 #include <assert.h>
  34
  35 #include "winuser.h"
  36 #include "winerror.h"
  37 #include "ole2.h"
  38 #include "debug.h"
  39
  40 DEFAULT_DEBUG_CHANNEL(ole)
  41
  42 /****************************************************************************
  43  * DefaultHandler
  44  *
  45  */
  46 struct DefaultHandler
  47 {
  48   /*
  49    * List all interface VTables here
  50    */
  51   ICOM_VTABLE(IOleObject)*      lpvtbl1;
  52   ICOM_VTABLE(IUnknown)*        lpvtbl2;
  53   ICOM_VTABLE(IDataObject)*     lpvtbl3;
  54   ICOM_VTABLE(IRunnableObject)* lpvtbl4;
  55
  56   /*
  57    * Reference count of this object
  58    */
  59   ULONG ref;
  60
  61   /*
  62    * IUnknown implementation of the outer object.
  63    */
  64   IUnknown* outerUnknown;
  65
  66   /*
  67    * Class Id that this handler object represents.
  68    */
  69   CLSID clsid;
  70
  71   /*
  72    * IUnknown implementation of the datacache.
  73    */
  74   IUnknown* dataCache;
  75
  76   /*
  77    * Client site for the embedded object.
  78    */
  79   IOleClientSite* clientSite;
  80
  81   /*
  82    * The IOleAdviseHolder maintains the connections
  83    * on behalf of the default handler.
  84    */
  85   IOleAdviseHolder* oleAdviseHolder;
  86
  87   /*
  88    * The IDataAdviseHolder maintains the data
  89    * connections on behalf of the default handler.
  90    */
  91   IDataAdviseHolder* dataAdviseHolder;
  92
  93   /*
  94    * Name of the container and object contained
  95    */
  96   BSTR containerApp;
  97   BSTR containerObj;
  98
  99 };
 100
 101 typedef struct DefaultHandler DefaultHandler;
 102
 103 /*
 104  * Here, I define utility macros to help with the casting of the
 105  * "this" parameter.
 106  * There is a version to accomodate all of the VTables implemented
 107  * by this object.
 108  */
 109 #define _ICOM_THIS_From_IOleObject(class,name)       class* this = (class*)name;
 110 #define _ICOM_THIS_From_NDIUnknown(class, name)      class* this = (class*)(((char*)name)-sizeof(void*));
 111 #define _ICOM_THIS_From_IDataObject(class, name)     class* this = (class*)(((char*)name)-2*sizeof(void*));
 112 #define _ICOM_THIS_From_IRunnableObject(class, name) class* this = (class*)(((char*)name)-3*sizeof(void*));
 113
 114 /*
 115  * Prototypes for the methods of the DefaultHandler class.
 116  */
 117 static DefaultHandler* DefaultHandler_Construct(REFCLSID  clsid,
 118                                                 LPUNKNOWN pUnkOuter);
 119 static void            DefaultHandler_Destroy(DefaultHandler* ptrToDestroy);
 120
 121 /*
 122  * Prototypes for the methods of the DefaultHandler class
 123  * that implement non delegating IUnknown methods.
 124  */
 125 static HRESULT WINAPI DefaultHandler_NDIUnknown_QueryInterface(
 126             IUnknown*      iface,
 127             REFIID         riid,
 128             void**         ppvObject);
 129 static ULONG WINAPI DefaultHandler_NDIUnknown_AddRef(
 130             IUnknown*      iface);
 131 static ULONG WINAPI DefaultHandler_NDIUnknown_Release(
 132             IUnknown*      iface);
 133
 134 /*
 135  * Prototypes for the methods of the DefaultHandler class
 136  * that implement IOleObject methods.
 137  */
 138 static HRESULT WINAPI DefaultHandler_QueryInterface(
 139             IOleObject*      iface,
 140             REFIID           riid,
 141             void**           ppvObject);
 142 static ULONG WINAPI DefaultHandler_AddRef(
 143             IOleObject*        iface);
 144 static ULONG WINAPI DefaultHandler_Release(
 145             IOleObject*        iface);
 146 static HRESULT WINAPI DefaultHandler_SetClientSite(
 147             IOleObject*        iface,
 148             IOleClientSite*    pClientSite);
 149 static HRESULT WINAPI DefaultHandler_GetClientSite(
 150             IOleObject*        iface,
 151             IOleClientSite**   ppClientSite);
 152 static HRESULT WINAPI DefaultHandler_SetHostNames(
 153             IOleObject*        iface,
 154             LPCOLESTR          szContainerApp,
 155             LPCOLESTR          szContainerObj);
 156 static HRESULT WINAPI DefaultHandler_Close(
 157             IOleObject*        iface,
 158             DWORD              dwSaveOption);
 159 static HRESULT WINAPI DefaultHandler_SetMoniker(
 160             IOleObject*        iface,
 161             DWORD              dwWhichMoniker,
 162             IMoniker*          pmk);
 163 static HRESULT WINAPI DefaultHandler_GetMoniker(
 164             IOleObject*        iface,
 165             DWORD              dwAssign,
 166             DWORD              dwWhichMoniker,
 167             IMoniker**         ppmk);
 168 static HRESULT WINAPI DefaultHandler_InitFromData(
 169             IOleObject*        iface,
 170             IDataObject*       pDataObject,
 171             BOOL               fCreation,
 172             DWORD              dwReserved);
 173 static HRESULT WINAPI DefaultHandler_GetClipboardData(
 174             IOleObject*        iface,
 175             DWORD              dwReserved,
 176             IDataObject**      ppDataObject);
 177 static HRESULT WINAPI DefaultHandler_DoVerb(
 178             IOleObject*        iface,
 179             LONG               iVerb,
 180             LPMSG              lpmsg,
 181             IOleClientSite*    pActiveSite,
 182             LONG               lindex,
 183             HWND               hwndParent,
 184             LPCRECT            lprcPosRect);
 185 static HRESULT WINAPI DefaultHandler_EnumVerbs(
 186             IOleObject*        iface,
 187             IEnumOLEVERB**     ppEnumOleVerb);
 188 static HRESULT WINAPI DefaultHandler_Update(
 189             IOleObject*        iface);
 190 static HRESULT WINAPI DefaultHandler_IsUpToDate(
 191             IOleObject*        iface);
 192 static HRESULT WINAPI DefaultHandler_GetUserClassID(
 193             IOleObject*        iface,
 194             CLSID*             pClsid);
 195 static HRESULT WINAPI DefaultHandler_GetUserType(
 196             IOleObject*        iface,
 197             DWORD              dwFormOfType,
 198             LPOLESTR*          pszUserType);
 199 static HRESULT WINAPI DefaultHandler_SetExtent(
 200             IOleObject*        iface,
 201             DWORD              dwDrawAspect,
 202             SIZEL*             psizel);
 203 static HRESULT WINAPI DefaultHandler_GetExtent(
 204             IOleObject*        iface,
 205             DWORD              dwDrawAspect,
 206             SIZEL*             psizel);
 207 static HRESULT WINAPI DefaultHandler_Advise(
 208             IOleObject*        iface,
 209             IAdviseSink*       pAdvSink,
 210             DWORD*             pdwConnection);
 211 static HRESULT WINAPI DefaultHandler_Unadvise(
 212             IOleObject*        iface,
 213             DWORD              dwConnection);
 214 static HRESULT WINAPI DefaultHandler_EnumAdvise(
 215             IOleObject*        iface,
 216             IEnumSTATDATA**    ppenumAdvise);
 217 static HRESULT WINAPI DefaultHandler_GetMiscStatus(
 218             IOleObject*        iface,
 219             DWORD              dwAspect,
 220             DWORD*             pdwStatus);
 221 static HRESULT WINAPI DefaultHandler_SetColorScheme(
 222             IOleObject*        iface,
 223             LOGPALETTE*        pLogpal);
 224
 225 /*
 226  * Prototypes for the methods of the DefaultHandler class
 227  * that implement IDataObject methods.
 228  */
 229 static HRESULT WINAPI DefaultHandler_IDataObject_QueryInterface(
 230             IDataObject*     iface,
 231             REFIID           riid,
 232             void**           ppvObject);
 233 static ULONG WINAPI DefaultHandler_IDataObject_AddRef(
 234             IDataObject*     iface);
 235 static ULONG WINAPI DefaultHandler_IDataObject_Release(
 236             IDataObject*     iface);
 237 static HRESULT WINAPI DefaultHandler_GetData(
 238             IDataObject*     iface,
 239             LPFORMATETC      pformatetcIn,
 240             STGMEDIUM*       pmedium);
 241 static HRESULT WINAPI DefaultHandler_GetDataHere(
 242             IDataObject*     iface,
 243             LPFORMATETC      pformatetc,
 244             STGMEDIUM*       pmedium);
 245 static HRESULT WINAPI DefaultHandler_QueryGetData(
 246             IDataObject*     iface,
 247             LPFORMATETC      pformatetc);
 248 static HRESULT WINAPI DefaultHandler_GetCanonicalFormatEtc(
 249             IDataObject*     iface,
 250             LPFORMATETC      pformatectIn,
 251             LPFORMATETC      pformatetcOut);
 252 static HRESULT WINAPI DefaultHandler_SetData(
 253             IDataObject*     iface,
 254             LPFORMATETC      pformatetc,
 255             STGMEDIUM*       pmedium,
 256             BOOL             fRelease);
 257 static HRESULT WINAPI DefaultHandler_EnumFormatEtc(
 258             IDataObject*     iface,
 259             DWORD            dwDirection,
 260             IEnumFORMATETC** ppenumFormatEtc);
 261 static HRESULT WINAPI DefaultHandler_DAdvise(
 262             IDataObject*     iface,
 263             FORMATETC*       pformatetc,
 264             DWORD            advf,
 265             IAdviseSink*     pAdvSink,
 266             DWORD*           pdwConnection);
 267 static HRESULT WINAPI DefaultHandler_DUnadvise(
 268             IDataObject*     iface,
 269             DWORD            dwConnection);
 270 static HRESULT WINAPI DefaultHandler_EnumDAdvise(
 271             IDataObject*     iface,
 272             IEnumSTATDATA**  ppenumAdvise);
 273
 274 /*
 275  * Prototypes for the methods of the DefaultHandler class
 276  * that implement IRunnableObject methods.
 277  */
 278 static HRESULT WINAPI DefaultHandler_IRunnableObject_QueryInterface(
 279             IRunnableObject*     iface,
 280             REFIID               riid,
 281             void**               ppvObject);
 282 static ULONG WINAPI DefaultHandler_IRunnableObject_AddRef(
 283             IRunnableObject*     iface);
 284 static ULONG WINAPI DefaultHandler_IRunnableObject_Release(
 285             IRunnableObject*     iface);
 286 static HRESULT WINAPI DefaultHandler_GetRunningClass(
 287             IRunnableObject*     iface,
 288             LPCLSID              lpClsid);
 289 static HRESULT WINAPI DefaultHandler_Run(
 290             IRunnableObject*     iface,
 291             IBindCtx*            pbc);
 292 static BOOL    WINAPI DefaultHandler_IsRunning(
 293             IRunnableObject*     iface);
 294 static HRESULT WINAPI DefaultHandler_LockRunning(
 295             IRunnableObject*     iface,
 296             BOOL                 fLock,
 297             BOOL                 fLastUnlockCloses);
 298 static HRESULT WINAPI DefaultHandler_SetContainedObject(
 299             IRunnableObject*     iface,
 300             BOOL                 fContained);
 301
 302
 303 /*
 304  * Virtual function tables for the DefaultHandler class.
 305  */
 306 static ICOM_VTABLE(IOleObject) DefaultHandler_IOleObject_VTable =
 307 {
 308   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 309   DefaultHandler_QueryInterface,
 310   DefaultHandler_AddRef,
 311   DefaultHandler_Release,
 312   DefaultHandler_SetClientSite,
 313   DefaultHandler_GetClientSite,
 314   DefaultHandler_SetHostNames,
 315   DefaultHandler_Close,
 316   DefaultHandler_SetMoniker,
 317   DefaultHandler_GetMoniker,
 318   DefaultHandler_InitFromData,
 319   DefaultHandler_GetClipboardData,
 320   DefaultHandler_DoVerb,
 321   DefaultHandler_EnumVerbs,
 322   DefaultHandler_Update,
 323   DefaultHandler_IsUpToDate,
 324   DefaultHandler_GetUserClassID,
 325   DefaultHandler_GetUserType,
 326   DefaultHandler_SetExtent,
 327   DefaultHandler_GetExtent,
 328   DefaultHandler_Advise,
 329   DefaultHandler_Unadvise,
 330   DefaultHandler_EnumAdvise,
 331   DefaultHandler_GetMiscStatus,
 332   DefaultHandler_SetColorScheme
 333 };
 334
 335 static ICOM_VTABLE(IUnknown) DefaultHandler_NDIUnknown_VTable =
 336 {
 337   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 338   DefaultHandler_NDIUnknown_QueryInterface,
 339   DefaultHandler_NDIUnknown_AddRef,
 340   DefaultHandler_NDIUnknown_Release,
 341 };
 342
 343 static ICOM_VTABLE(IDataObject) DefaultHandler_IDataObject_VTable =
 344 {
 345   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 346   DefaultHandler_IDataObject_QueryInterface,
 347   DefaultHandler_IDataObject_AddRef,
 348   DefaultHandler_IDataObject_Release,
 349   DefaultHandler_GetData,
 350   DefaultHandler_GetDataHere,
 351   DefaultHandler_QueryGetData,
 352   DefaultHandler_GetCanonicalFormatEtc,
 353   DefaultHandler_SetData,
 354   DefaultHandler_EnumFormatEtc,
 355   DefaultHandler_DAdvise,
 356   DefaultHandler_DUnadvise,
 357   DefaultHandler_EnumDAdvise
 358 };
 359
 360 static ICOM_VTABLE(IRunnableObject) DefaultHandler_IRunnableObject_VTable =
 361 {
 362   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 363   DefaultHandler_IRunnableObject_QueryInterface,
 364   DefaultHandler_IRunnableObject_AddRef,
 365   DefaultHandler_IRunnableObject_Release,
 366   DefaultHandler_GetRunningClass,
 367   DefaultHandler_Run,
 368   DefaultHandler_IsRunning,
 369   DefaultHandler_LockRunning,
 370   DefaultHandler_SetContainedObject
 371 };
 372
 373 /******************************************************************************
 374  * OleCreateDefaultHandler [OLE32.90]
 375  */
 376 HRESULT WINAPI OleCreateDefaultHandler(
 377   REFCLSID  clsid,
 378   LPUNKNOWN pUnkOuter,
 379   REFIID    riid,
 380   LPVOID*   ppvObj)
 381 {
 382   DefaultHandler* newHandler = NULL;
 383   HRESULT         hr         = S_OK;
 384   char            xclsid[50];
 385   char            xriid[50];
 386
 387   WINE_StringFromCLSID((LPCLSID)clsid,xclsid);
 388   WINE_StringFromCLSID((LPCLSID)riid,xriid);
 389
 390   TRACE(ole, "(%s, %p, %s, %p)\n", xclsid, pUnkOuter, xriid, ppvObj);
 391
 392   /*
 393    * Sanity check
 394    */
 395   if (ppvObj==0)
 396     return E_POINTER;
 397
 398   *ppvObj = 0;
 399
 400   /*
 401    * If this handler is constructed for aggregation, make sure
 402    * the caller is requesting the IUnknown interface.
 403    * This is necessary because it's the only time the non-delegating
 404    * IUnknown pointer can be returned to the outside.
 405    */
 406   if ( (pUnkOuter!=NULL) &&
 407        (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) != 0) )
 408     return CLASS_E_NOAGGREGATION;
 409
 410   /*
 411    * Try to construct a new instance of the class.
 412    */
 413   newHandler = DefaultHandler_Construct(clsid,
 414                                         pUnkOuter);
 415
 416   if (newHandler == 0)
 417     return E_OUTOFMEMORY;
 418
 419   /*
 420    * Make sure it supports the interface required by the caller.
 421    */
 422   hr = IUnknown_QueryInterface((IUnknown*)&(newHandler->lpvtbl2), riid, ppvObj);
 423
 424   /*
 425    * Release the reference obtained in the constructor. If
 426    * the QueryInterface was unsuccessful, it will free the class.
 427    */
 428   IUnknown_Release((IUnknown*)&(newHandler->lpvtbl2));
 429
 430   return hr;
 431 }
 432
 433 /*********************************************************
 434  * Methods implementation for the DefaultHandler class.
 435  */
 436 static DefaultHandler* DefaultHandler_Construct(
 437   REFCLSID  clsid,
 438   LPUNKNOWN pUnkOuter)
 439 {
 440   DefaultHandler* newObject = 0;
 441
 442   /*
 443    * Allocate space for the object.
 444    */
 445   newObject = HeapAlloc(GetProcessHeap(), 0, sizeof(DefaultHandler));
 446
 447   if (newObject==0)
 448     return newObject;
 449
 450   /*
 451    * Initialize the virtual function table.
 452    */
 453   newObject->lpvtbl1 = &DefaultHandler_IOleObject_VTable;
 454   newObject->lpvtbl2 = &DefaultHandler_NDIUnknown_VTable;
 455   newObject->lpvtbl3 = &DefaultHandler_IDataObject_VTable;
 456   newObject->lpvtbl4 = &DefaultHandler_IRunnableObject_VTable;
 457
 458   /*
 459    * Start with one reference count. The caller of this function
 460    * must release the interface pointer when it is done.
 461    */
 462   newObject->ref = 1;
 463
 464   /*
 465    * Initialize the outer unknown
 466    * We don't keep a reference on the outer unknown since, the way
 467    * aggregation works, our lifetime is at least as large as it's
 468    * lifetime.
 469    */
 470   if (pUnkOuter==NULL)
 471     pUnkOuter = (IUnknown*)&(newObject->lpvtbl2);
 472
 473   newObject->outerUnknown = pUnkOuter;
 474
 475   /*
 476    * Create a datacache object.
 477    * We aggregate with the datacache. Make sure we pass our outer
 478    * unknown as the datacache's outer unknown.
 479    */
 480   CreateDataCache(newObject->outerUnknown,
 481                   clsid,
 482                   &IID_IUnknown,
 483                   (void**)&newObject->dataCache);
 484
 485   /*
 486    * Initialize the other data members of the class.
 487    */
 488   memcpy(&(newObject->clsid), clsid, sizeof(CLSID));
 489   newObject->clientSite = NULL;
 490   newObject->oleAdviseHolder = NULL;
 491   newObject->dataAdviseHolder = NULL;
 492   newObject->containerApp = NULL;
 493   newObject->containerObj = NULL;
 494
 495   return newObject;
 496 }
 497
 498 static void DefaultHandler_Destroy(
 499   DefaultHandler* ptrToDestroy)
 500 {
 501   /*
 502    * Free the strings idenfitying the object
 503    */
 504   if (ptrToDestroy->containerApp!=NULL)
 505   {
 506     SysFreeString(ptrToDestroy->containerApp);
 507     ptrToDestroy->containerApp = NULL;
 508   }
 509
 510   if (ptrToDestroy->containerObj!=NULL)
 511   {
 512     SysFreeString(ptrToDestroy->containerObj);
 513     ptrToDestroy->containerObj = NULL;
 514   }
 515
 516   /*
 517    * Release our reference to the data cache.
 518    */
 519   if (ptrToDestroy->dataCache!=NULL)
 520   {
 521     IUnknown_Release(ptrToDestroy->dataCache);
 522     ptrToDestroy->dataCache = NULL;
 523   }
 524
 525   /*
 526    * Same thing for the client site.
 527    */
 528   if (ptrToDestroy->clientSite!=NULL)
 529   {
 530     IOleClientSite_Release(ptrToDestroy->clientSite);
 531     ptrToDestroy->clientSite = NULL;
 532   }
 533
 534   /*
 535    * And the advise holder.
 536    */
 537   if (ptrToDestroy->oleAdviseHolder!=NULL)
 538   {
 539     IOleClientSite_Release(ptrToDestroy->oleAdviseHolder);
 540     ptrToDestroy->oleAdviseHolder = NULL;
 541   }
 542
 543   /*
 544    * And the data advise holder.
 545    */
 546   if (ptrToDestroy->dataAdviseHolder!=NULL)
 547   {
 548     IOleClientSite_Release(ptrToDestroy->dataAdviseHolder);
 549     ptrToDestroy->dataAdviseHolder = NULL;
 550   }
 551
 552
 553   /*
 554    * Free the actual default handler structure.
 555    */
 556   HeapFree(GetProcessHeap(), 0, ptrToDestroy);
 557 }
 558
 559 /*********************************************************
 560  * Method implementation for the  non delegating IUnknown
 561  * part of the DefaultHandler class.
 562  */
 563
 564 /************************************************************************
 565  * DefaultHandler_NDIUnknown_QueryInterface (IUnknown)
 566  *
 567  * See Windows documentation for more details on IUnknown methods.
 568  *
 569  * This version of QueryInterface will not delegate it's implementation
 570  * to the outer unknown.
 571  */
 572 static HRESULT WINAPI DefaultHandler_NDIUnknown_QueryInterface(
 573             IUnknown*      iface,
 574             REFIID         riid,
 575             void**         ppvObject)
 576 {
 577   _ICOM_THIS_From_NDIUnknown(DefaultHandler, iface);
 578
 579   /*
 580    * Perform a sanity check on the parameters.
 581    */
 582   if ( (this==0) || (ppvObject==0) )
 583     return E_INVALIDARG;
 584
 585   /*
 586    * Initialize the return parameter.
 587    */
 588   *ppvObject = 0;
 589
 590   /*
 591    * Compare the riid with the interface IDs implemented by this object.
 592    */
 593   if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
 594   {
 595     *ppvObject = iface;
 596   }
 597   else if (memcmp(&IID_IOleObject, riid, sizeof(IID_IOleObject)) == 0)
 598   {
 599     *ppvObject = (IOleObject*)&(this->lpvtbl1);
 600   }
 601   else if (memcmp(&IID_IDataObject, riid, sizeof(IID_IDataObject)) == 0)
 602   {
 603     *ppvObject = (IDataObject*)&(this->lpvtbl3);
 604   }
 605   else if (memcmp(&IID_IRunnableObject, riid, sizeof(IID_IRunnableObject)) == 0)
 606   {
 607     *ppvObject = (IRunnableObject*)&(this->lpvtbl4);
 608   }
 609   else
 610   {
 611     /*
 612      * Blind aggregate the data cache to "inherit" it's interfaces.
 613      */
 614     IUnknown_QueryInterface(this->dataCache, riid, ppvObject);
 615   }
 616
 617   /*
 618    * Check that we obtained an interface.
 619    */
 620   if ((*ppvObject)==0)
 621   {
 622     char clsid[50];
 623
 624     WINE_StringFromCLSID((LPCLSID)riid,clsid);
 625
 626     WARN(ole,
 627          "() : asking for un supported interface %s\n",
 628          clsid);
 629
 630     return E_NOINTERFACE;
 631   }
 632
 633   /*
 634    * Query Interface always increases the reference count by one when it is
 635    * successful.
 636    */
 637   IUnknown_AddRef((IUnknown*)*ppvObject);
 638
 639   return S_OK;;
 640 }
 641
 642 /************************************************************************
 643  * DefaultHandler_NDIUnknown_AddRef (IUnknown)
 644  *
 645  * See Windows documentation for more details on IUnknown methods.
 646  *
 647  * This version of QueryInterface will not delegate it's implementation
 648  * to the outer unknown.
 649  */
 650 static ULONG WINAPI DefaultHandler_NDIUnknown_AddRef(
 651             IUnknown*      iface)
 652 {
 653   _ICOM_THIS_From_NDIUnknown(DefaultHandler, iface);
 654
 655   this->ref++;
 656
 657   return this->ref;
 658 }
 659
 660 /************************************************************************
 661  * DefaultHandler_NDIUnknown_Release (IUnknown)
 662  *
 663  * See Windows documentation for more details on IUnknown methods.
 664  *
 665  * This version of QueryInterface will not delegate it's implementation
 666  * to the outer unknown.
 667  */
 668 static ULONG WINAPI DefaultHandler_NDIUnknown_Release(
 669             IUnknown*      iface)
 670 {
 671   _ICOM_THIS_From_NDIUnknown(DefaultHandler, iface);
 672
 673   /*
 674    * Decrease the reference count on this object.
 675    */
 676   this->ref--;
 677
 678   /*
 679    * If the reference count goes down to 0, perform suicide.
 680    */
 681   if (this->ref==0)
 682   {
 683     DefaultHandler_Destroy(this);
 684
 685     return 0;
 686   }
 687
 688   return this->ref;
 689 }
 690
 691 /*********************************************************
 692  * Methods implementation for the IOleObject part of
 693  * the DefaultHandler class.
 694  */
 695
 696 /************************************************************************
 697  * DefaultHandler_QueryInterface (IUnknown)
 698  *
 699  * See Windows documentation for more details on IUnknown methods.
 700  */
 701 static HRESULT WINAPI DefaultHandler_QueryInterface(
 702             IOleObject*      iface,
 703             REFIID           riid,
 704             void**           ppvObject)
 705 {
 706   _ICOM_THIS_From_IOleObject(DefaultHandler, iface);
 707
 708   return IUnknown_QueryInterface(this->outerUnknown, riid, ppvObject);
 709 }
 710
 711 /************************************************************************
 712  * DefaultHandler_AddRef (IUnknown)
 713  *
 714  * See Windows documentation for more details on IUnknown methods.
 715  */
 716 static ULONG WINAPI DefaultHandler_AddRef(
 717             IOleObject*        iface)
 718 {
 719   _ICOM_THIS_From_IOleObject(DefaultHandler, iface);
 720
 721   return IUnknown_AddRef(this->outerUnknown);
 722 }
 723
 724 /************************************************************************
 725  * DefaultHandler_Release (IUnknown)
 726  *
 727  * See Windows documentation for more details on IUnknown methods.
 728  */
 729 static ULONG WINAPI DefaultHandler_Release(
 730             IOleObject*        iface)
 731 {
 732   _ICOM_THIS_From_IOleObject(DefaultHandler, iface);
 733
 734   return IUnknown_Release(this->outerUnknown);
 735 }
 736
 737 /************************************************************************
 738  * DefaultHandler_SetClientSite (IOleObject)
 739  *
 740  * The default handler's implementation of this method only keeps the
 741  * client site pointer for future reference.
 742  *
 743  * See Windows documentation for more details on IOleObject methods.
 744  */
 745 static HRESULT WINAPI DefaultHandler_SetClientSite(
 746             IOleObject*        iface,
 747             IOleClientSite*    pClientSite)
 748 {
 749   _ICOM_THIS_From_IOleObject(DefaultHandler, iface);
 750
 751   TRACE(ole, "(%p, %p)\n", iface, pClientSite);
 752
 753   /*
 754    * Make sure we release the previous client site if there
 755    * was one.
 756    */
 757   if (this->clientSite!=NULL)
 758   {
 759     IOleClientSite_Release(this->clientSite);
 760   }
 761
 762   this->clientSite = pClientSite;
 763
 764   if (this->clientSite!=NULL)
 765   {
 766     IOleClientSite_AddRef(this->clientSite);
 767   }
 768
 769   return S_OK;
 770 }
 771
 772 /************************************************************************
 773  * DefaultHandler_GetClientSite (IOleObject)
 774  *
 775  * The default handler's implementation of this method returns the
 776  * last pointer set in IOleObject_SetClientSite.
 777  *
 778  * See Windows documentation for more details on IOleObject methods.
 779  */
 780 static HRESULT WINAPI DefaultHandler_GetClientSite(
 781             IOleObject*        iface,
 782             IOleClientSite**   ppClientSite)
 783 {
 784   _ICOM_THIS_From_IOleObject(DefaultHandler, iface);
 785
 786   /*
 787    * Sanity check.
 788    */
 789   if (ppClientSite == NULL)
 790     return E_POINTER;
 791
 792   *ppClientSite = this->clientSite;
 793
 794   if (*ppClientSite!=NULL)
 795   {
 796     IOleClientSite_Release(*ppClientSite);
 797   }
 798
 799   return S_OK;
 800 }
 801
 802 /************************************************************************
 803  * DefaultHandler_SetHostNames (IOleObject)
 804  *
 805  * The default handler's implementation of this method just stores
 806  * the strings and returns S_OK.
 807  *
 808  * See Windows documentation for more details on IOleObject methods.
 809  */
 810 static HRESULT WINAPI DefaultHandler_SetHostNames(
 811             IOleObject*        iface,
 812             LPCOLESTR          szContainerApp,
 813             LPCOLESTR          szContainerObj)
 814 {
 815   _ICOM_THIS_From_IOleObject(DefaultHandler, iface);
 816
 817   TRACE(ole, "(%p, %s, %s)\n",
 818         iface,
 819         debugstr_w(szContainerApp),
 820         debugstr_w(szContainerObj));
 821
 822   /*
 823    * Be sure to cleanup before re-assinging the strings.
 824    */
 825   if (this->containerApp!=NULL)
 826   {
 827     SysFreeString(this->containerApp);
 828     this->containerApp = NULL;
 829   }
 830
 831   if (this->containerObj!=NULL)
 832   {
 833     SysFreeString(this->containerObj);
 834     this->containerObj = NULL;
 835   }
 836
 837   /*
 838    * Copy the string supplied.
 839    */
 840   if (szContainerApp != NULL)
 841     this->containerApp = SysAllocString(szContainerApp);
 842
 843   if (szContainerObj != NULL)
 844     this->containerObj = SysAllocString(szContainerObj);
 845
 846   return S_OK;
 847 }
 848
 849 /************************************************************************
 850  * DefaultHandler_Close (IOleObject)
 851  *
 852  * The default handler's implementation of this method is meaningless
 853  * without a running server so it does nothing.
 854  *
 855  * See Windows documentation for more details on IOleObject methods.
 856  */
 857 static HRESULT WINAPI DefaultHandler_Close(
 858             IOleObject*        iface,
 859             DWORD              dwSaveOption)
 860 {
 861   TRACE(ole, "()\n");
 862   return S_OK;
 863 }
 864
 865 /************************************************************************
 866  * DefaultHandler_SetMoniker (IOleObject)
 867  *
 868  * The default handler's implementation of this method does nothing.
 869  *
 870  * See Windows documentation for more details on IOleObject methods.
 871  */
 872 static HRESULT WINAPI DefaultHandler_SetMoniker(
 873             IOleObject*        iface,
 874             DWORD              dwWhichMoniker,
 875             IMoniker*          pmk)
 876 {
 877   TRACE(ole, "(%p, %ld, %p)\n",
 878         iface,
 879         dwWhichMoniker,
 880         pmk);
 881
 882   return S_OK;
 883 }
 884
 885 /************************************************************************
 886  * DefaultHandler_GetMoniker (IOleObject)
 887  *
 888  * Delegate this request to the client site if we have one.
 889  *
 890  * See Windows documentation for more details on IOleObject methods.
 891  */
 892 static HRESULT WINAPI DefaultHandler_GetMoniker(
 893             IOleObject*        iface,
 894             DWORD              dwAssign,
 895             DWORD              dwWhichMoniker,
 896             IMoniker**         ppmk)
 897 {
 898   _ICOM_THIS_From_IOleObject(DefaultHandler, iface);
 899
 900   TRACE(ole, "(%p, %ld, %ld, %p)\n",
 901         iface, dwAssign, dwWhichMoniker, ppmk);
 902
 903   if (this->clientSite)
 904   {
 905     return IOleClientSite_GetMoniker(this->clientSite,
 906                                      dwAssign,
 907                                      dwWhichMoniker,
 908                                      ppmk);
 909
 910   }
 911
 912   return E_UNSPEC;
 913 }
 914
 915 /************************************************************************
 916  * DefaultHandler_InitFromData (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_InitFromData(
 923             IOleObject*        iface,
 924             IDataObject*       pDataObject,
 925             BOOL               fCreation,
 926             DWORD              dwReserved)
 927 {
 928   TRACE(ole, "(%p, %p, %d, %ld)\n",
 929         iface, pDataObject, fCreation, dwReserved);
 930
 931   return OLE_E_NOTRUNNING;
 932 }
 933
 934 /************************************************************************
 935  * DefaultHandler_GetClipboardData (IOleObject)
 936  *
 937  * This method is meaningless if the server is not running
 938  *
 939  * See Windows documentation for more details on IOleObject methods.
 940  */
 941 static HRESULT WINAPI DefaultHandler_GetClipboardData(
 942             IOleObject*        iface,
 943             DWORD              dwReserved,
 944             IDataObject**      ppDataObject)
 945 {
 946   TRACE(ole, "(%p, %ld, %p)\n",
 947         iface, dwReserved, ppDataObject);
 948
 949   return OLE_E_NOTRUNNING;
 950 }
 951
 952 static HRESULT WINAPI DefaultHandler_DoVerb(
 953             IOleObject*        iface,
 954             LONG               iVerb,
 955             LPMSG              lpmsg,
 956             IOleClientSite*    pActiveSite,
 957             LONG               lindex,
 958             HWND               hwndParent,
 959             LPCRECT            lprcPosRect)
 960 {
 961   FIXME(ole, ": Stub\n");
 962   return E_NOTIMPL;
 963 }
 964
 965 /************************************************************************
 966  * DefaultHandler_EnumVerbs (IOleObject)
 967  *
 968  * The default handler implementation of this method simply delegates
 969  * to OleRegEnumVerbs
 970  *
 971  * See Windows documentation for more details on IOleObject methods.
 972  */
 973 static HRESULT WINAPI DefaultHandler_EnumVerbs(
 974             IOleObject*        iface,
 975             IEnumOLEVERB**     ppEnumOleVerb)
 976 {
 977   _ICOM_THIS_From_IOleObject(DefaultHandler, iface);
 978
 979   TRACE(ole, "(%p, %p)\n", iface, ppEnumOleVerb);
 980
 981   return OleRegEnumVerbs(&this->clsid, ppEnumOleVerb);
 982 }
 983
 984 static HRESULT WINAPI DefaultHandler_Update(
 985             IOleObject*        iface)
 986 {
 987   FIXME(ole, ": Stub\n");
 988   return E_NOTIMPL;
 989 }
 990
 991 /************************************************************************
 992  * DefaultHandler_IsUpToDate (IOleObject)
 993  *
 994  * This method is meaningless if the server is not running
 995  *
 996  * See Windows documentation for more details on IOleObject methods.
 997  */
 998 static HRESULT WINAPI DefaultHandler_IsUpToDate(
 999             IOleObject*        iface)
1000 {
1001   TRACE(ole, "(%p)\n", iface);
1002
1003   return OLE_E_NOTRUNNING;
1004 }
1005
1006 /************************************************************************
1007  * DefaultHandler_GetUserClassID (IOleObject)
1008  *
1009  * TODO: Map to a new class ID if emulation is active.
1010  *
1011  * See Windows documentation for more details on IOleObject methods.
1012  */
1013 static HRESULT WINAPI DefaultHandler_GetUserClassID(
1014             IOleObject*        iface,
1015             CLSID*             pClsid)
1016 {
1017   _ICOM_THIS_From_IOleObject(DefaultHandler, iface);
1018
1019   TRACE(ole, "(%p, %p)\n", iface, pClsid);
1020
1021   /*
1022    * Sanity check.
1023    */
1024   if (pClsid==NULL)
1025     return E_POINTER;
1026
1027   memcpy(pClsid, &this->clsid, sizeof(CLSID));
1028
1029   return S_OK;
1030 }
1031
1032 /************************************************************************
1033  * DefaultHandler_GetUserType (IOleObject)
1034  *
1035  * The default handler implementation of this method simply delegates
1036  * to OleRegGetUserType
1037  *
1038  * See Windows documentation for more details on IOleObject methods.
1039  */
1040 static HRESULT WINAPI DefaultHandler_GetUserType(
1041             IOleObject*        iface,
1042             DWORD              dwFormOfType,
1043             LPOLESTR*          pszUserType)
1044 {
1045   _ICOM_THIS_From_IOleObject(DefaultHandler, iface);
1046
1047   TRACE(ole, "(%p, %ld, %p)\n", iface, dwFormOfType, pszUserType);
1048
1049   return OleRegGetUserType(&this->clsid, dwFormOfType, pszUserType);
1050 }
1051
1052 /************************************************************************
1053  * DefaultHandler_SetExtent (IOleObject)
1054  *
1055  * This method is meaningless if the server is not running
1056  *
1057  * See Windows documentation for more details on IOleObject methods.
1058  */
1059 static HRESULT WINAPI DefaultHandler_SetExtent(
1060             IOleObject*        iface,
1061             DWORD              dwDrawAspect,
1062             SIZEL*             psizel)
1063 {
1064   TRACE(ole, "(%p, %lx, (%d,%d))\n", iface, dwDrawAspect, psizel->cx, psizel->cy);
1065   return OLE_E_NOTRUNNING;
1066 }
1067
1068 /************************************************************************
1069  * DefaultHandler_GetExtent (IOleObject)
1070  *
1071  * The default handler's implementation of this method returns uses
1072  * the cache to locate the aspect and extract the extent from it.
1073  *
1074  * See Windows documentation for more details on IOleObject methods.
1075  */
1076 static HRESULT WINAPI DefaultHandler_GetExtent(
1077             IOleObject*        iface,
1078             DWORD              dwDrawAspect,
1079             SIZEL*             psizel)
1080 {
1081   DVTARGETDEVICE* targetDevice;
1082   IViewObject2*   cacheView = NULL;
1083   HRESULT         hres;
1084
1085   _ICOM_THIS_From_IOleObject(DefaultHandler, iface);
1086
1087   TRACE(ole, "(%p, %lx, %p)\n", iface, dwDrawAspect, psizel);
1088
1089   hres = IUnknown_QueryInterface(this->dataCache, &IID_IViewObject2, (void**)&cacheView);
1090
1091   if (FAILED(hres))
1092     return E_UNEXPECTED;
1093
1094   /*
1095    * Prepare the call to the cache's GetExtent method.
1096    *
1097    * Here we would build a valid DVTARGETDEVICE structure
1098    * but, since we are calling into the data cache, we
1099    * know it's implementation and we'll skip this
1100    * extra work until later.
1101    */
1102   targetDevice = NULL;
1103
1104   hres = IViewObject2_GetExtent(cacheView,
1105                                 dwDrawAspect,
1106                                 -1,
1107                                 targetDevice,
1108                                 psizel);
1109
1110   /*
1111    * Cleanup
1112    */
1113   IViewObject2_Release(cacheView);
1114
1115   return hres;
1116 }
1117
1118 /************************************************************************
1119  * DefaultHandler_Advise (IOleObject)
1120  *
1121  * The default handler's implementation of this method simply
1122  * delegates to the OleAdviseHolder.
1123  *
1124  * See Windows documentation for more details on IOleObject methods.
1125  */
1126 static HRESULT WINAPI DefaultHandler_Advise(
1127             IOleObject*        iface,
1128             IAdviseSink*       pAdvSink,
1129             DWORD*             pdwConnection)
1130 {
1131   HRESULT hres = S_OK;
1132   _ICOM_THIS_From_IOleObject(DefaultHandler, iface);
1133
1134   TRACE(ole, "(%p, %p, %p)\n", iface, pAdvSink, pdwConnection);
1135
1136   /*
1137    * Make sure we have an advise holder before we start.
1138    */
1139   if (this->oleAdviseHolder==NULL)
1140   {
1141     hres = CreateOleAdviseHolder(&this->oleAdviseHolder);
1142   }
1143
1144   if (SUCCEEDED(hres))
1145   {
1146     hres = IOleAdviseHolder_Advise(this->oleAdviseHolder,
1147                                    pAdvSink,
1148                                    pdwConnection);
1149   }
1150
1151   return hres;
1152 }
1153
1154 /************************************************************************
1155  * DefaultHandler_Unadvise (IOleObject)
1156  *
1157  * The default handler's implementation of this method simply
1158  * delegates to the OleAdviseHolder.
1159  *
1160  * See Windows documentation for more details on IOleObject methods.
1161  */
1162 static HRESULT WINAPI DefaultHandler_Unadvise(
1163             IOleObject*        iface,
1164             DWORD              dwConnection)
1165 {
1166   _ICOM_THIS_From_IOleObject(DefaultHandler, iface);
1167
1168   TRACE(ole, "(%p, %ld)\n", iface, dwConnection);
1169
1170   /*
1171    * If we don't have an advise holder yet, it means we don't have
1172    * a connection.
1173    */
1174   if (this->oleAdviseHolder==NULL)
1175     return OLE_E_NOCONNECTION;
1176
1177   return IOleAdviseHolder_Unadvise(this->oleAdviseHolder,
1178                                    dwConnection);
1179 }
1180
1181 /************************************************************************
1182  * DefaultHandler_EnumAdvise (IOleObject)
1183  *
1184  * The default handler's implementation of this method simply
1185  * delegates to the OleAdviseHolder.
1186  *
1187  * See Windows documentation for more details on IOleObject methods.
1188  */
1189 static HRESULT WINAPI DefaultHandler_EnumAdvise(
1190             IOleObject*        iface,
1191             IEnumSTATDATA**    ppenumAdvise)
1192 {
1193   _ICOM_THIS_From_IOleObject(DefaultHandler, iface);
1194
1195   TRACE(ole, "(%p, %p)\n", iface, ppenumAdvise);
1196
1197   /*
1198    * Sanity check
1199    */
1200   if (ppenumAdvise==NULL)
1201     return E_POINTER;
1202
1203   /*
1204    * Initialize the out parameter.
1205    */
1206   *ppenumAdvise = NULL;
1207
1208   if (this->oleAdviseHolder==NULL)
1209     return IOleAdviseHolder_EnumAdvise(this->oleAdviseHolder,
1210                                        ppenumAdvise);
1211
1212   return S_OK;
1213 }
1214
1215 /************************************************************************
1216  * DefaultHandler_GetMiscStatus (IOleObject)
1217  *
1218  * The default handler's implementation of this method simply delegates
1219  * to OleRegGetMiscStatus.
1220  *
1221  * See Windows documentation for more details on IOleObject methods.
1222  */
1223 static HRESULT WINAPI DefaultHandler_GetMiscStatus(
1224             IOleObject*        iface,
1225             DWORD              dwAspect,
1226             DWORD*             pdwStatus)
1227 {
1228   HRESULT hres;
1229   _ICOM_THIS_From_IOleObject(DefaultHandler, iface);
1230
1231   TRACE(ole, "(%p, %lx, %p)\n", iface, dwAspect, pdwStatus);
1232
1233   hres = OleRegGetMiscStatus(&(this->clsid), dwAspect, pdwStatus);
1234
1235   if (FAILED(hres))
1236     *pdwStatus = 0;
1237
1238   return S_OK;
1239 }
1240
1241 /************************************************************************
1242  * DefaultHandler_SetExtent (IOleObject)
1243  *
1244  * This method is meaningless if the server is not running
1245  *
1246  * See Windows documentation for more details on IOleObject methods.
1247  */
1248 static HRESULT WINAPI DefaultHandler_SetColorScheme(
1249             IOleObject*        iface,
1250             LOGPALETTE*        pLogpal)
1251 {
1252   TRACE(ole, "(%p, %p))\n", iface, pLogpal);
1253   return OLE_E_NOTRUNNING;
1254 }
1255
1256 /*********************************************************
1257  * Methods implementation for the IDataObject part of
1258  * the DefaultHandler class.
1259  */
1260
1261 /************************************************************************
1262  * DefaultHandler_IDataObject_QueryInterface (IUnknown)
1263  *
1264  * See Windows documentation for more details on IUnknown methods.
1265  */
1266 static HRESULT WINAPI DefaultHandler_IDataObject_QueryInterface(
1267             IDataObject*     iface,
1268            REFIID           riid,
1269             void**           ppvObject)
1270 {
1271   _ICOM_THIS_From_IDataObject(DefaultHandler, iface);
1272
1273   return IUnknown_QueryInterface(this->outerUnknown, riid, ppvObject);
1274 }
1275
1276 /************************************************************************
1277  * DefaultHandler_IDataObject_AddRef (IUnknown)
1278  *
1279  * See Windows documentation for more details on IUnknown methods.
1280  */
1281 static ULONG WINAPI DefaultHandler_IDataObject_AddRef(
1282             IDataObject*     iface)
1283 {
1284   _ICOM_THIS_From_IDataObject(DefaultHandler, iface);
1285
1286   return IUnknown_AddRef(this->outerUnknown);
1287 }
1288
1289 /************************************************************************
1290  * DefaultHandler_IDataObject_Release (IUnknown)
1291  *
1292  * See Windows documentation for more details on IUnknown methods.
1293  */
1294 static ULONG WINAPI DefaultHandler_IDataObject_Release(
1295             IDataObject*     iface)
1296 {
1297   _ICOM_THIS_From_IDataObject(DefaultHandler, iface);
1298
1299   return IUnknown_Release(this->outerUnknown);
1300 }
1301
1302 static HRESULT WINAPI DefaultHandler_GetData(
1303             IDataObject*     iface,
1304             LPFORMATETC      pformatetcIn,
1305             STGMEDIUM*       pmedium)
1306 {
1307   FIXME(ole, ": Stub\n");
1308   return E_NOTIMPL;
1309 }
1310
1311 static HRESULT WINAPI DefaultHandler_GetDataHere(
1312             IDataObject*     iface,
1313             LPFORMATETC      pformatetc,
1314             STGMEDIUM*       pmedium)
1315 {
1316   FIXME(ole, ": Stub\n");
1317   return E_NOTIMPL;
1318 }
1319
1320 /************************************************************************
1321  * DefaultHandler_QueryGetData (IDataObject)
1322  *
1323  * The default handler's implementation of this method delegates to
1324  * the cache.
1325  *
1326  * See Windows documentation for more details on IDataObject methods.
1327  */
1328 static HRESULT WINAPI DefaultHandler_QueryGetData(
1329             IDataObject*     iface,
1330             LPFORMATETC      pformatetc)
1331 {
1332   IDataObject* cacheDataObject = NULL;
1333   HRESULT      hres;
1334
1335   _ICOM_THIS_From_IDataObject(DefaultHandler, iface);
1336
1337   TRACE(ole, "(%p, %p)\n", iface, pformatetc);
1338
1339   hres = IUnknown_QueryInterface(this->dataCache,
1340                                  &IID_IDataObject,
1341                                  (void**)&cacheDataObject);
1342
1343   if (FAILED(hres))
1344     return E_UNEXPECTED;
1345
1346   hres = IDataObject_QueryGetData(cacheDataObject,
1347                                   pformatetc);
1348
1349   IDataObject_Release(cacheDataObject);
1350
1351   return hres;
1352 }
1353
1354 /************************************************************************
1355  * DefaultHandler_GetCanonicalFormatEtc (IDataObject)
1356  *
1357  * This method is meaningless if the server is not running
1358  *
1359  * See Windows documentation for more details on IDataObject methods.
1360  */
1361 static HRESULT WINAPI DefaultHandler_GetCanonicalFormatEtc(
1362             IDataObject*     iface,
1363             LPFORMATETC      pformatectIn,
1364             LPFORMATETC      pformatetcOut)
1365 {
1366   FIXME(ole, "(%p, %p, %p)\n", iface, pformatectIn, pformatetcOut);
1367
1368   return OLE_E_NOTRUNNING;
1369 }
1370
1371 /************************************************************************
1372  * DefaultHandler_SetData (IDataObject)
1373  *
1374  * The default handler's implementation of this method delegates to
1375  * the cache.
1376  *
1377  * See Windows documentation for more details on IDataObject methods.
1378  */
1379 static HRESULT WINAPI DefaultHandler_SetData(
1380             IDataObject*     iface,
1381             LPFORMATETC      pformatetc,
1382             STGMEDIUM*       pmedium,
1383             BOOL             fRelease)
1384 {
1385   IDataObject* cacheDataObject = NULL;
1386   HRESULT      hres;
1387
1388   _ICOM_THIS_From_IDataObject(DefaultHandler, iface);
1389
1390   TRACE(ole, "(%p, %p, %p, %d)\n", iface, pformatetc, pmedium, fRelease);
1391
1392   hres = IUnknown_QueryInterface(this->dataCache,
1393                                  &IID_IDataObject,
1394                                  (void**)&cacheDataObject);
1395
1396   if (FAILED(hres))
1397     return E_UNEXPECTED;
1398
1399   hres = IDataObject_SetData(cacheDataObject,
1400                              pformatetc,
1401                              pmedium,
1402                              fRelease);
1403
1404   IDataObject_Release(cacheDataObject);
1405
1406   return hres;
1407 }
1408
1409 /************************************************************************
1410  * DefaultHandler_EnumFormatEtc (IDataObject)
1411  *
1412  * The default handler's implementation of this method simply delegates
1413  * to OleRegEnumFormatEtc.
1414  *
1415  * See Windows documentation for more details on IDataObject methods.
1416  */
1417 static HRESULT WINAPI DefaultHandler_EnumFormatEtc(
1418             IDataObject*     iface,
1419             DWORD            dwDirection,
1420             IEnumFORMATETC** ppenumFormatEtc)
1421 {
1422   HRESULT hres;
1423   _ICOM_THIS_From_IDataObject(DefaultHandler, iface);
1424
1425   TRACE(ole, "(%p, %lx, %p)\n", iface, dwDirection, ppenumFormatEtc);
1426
1427   hres = OleRegEnumFormatEtc(&(this->clsid), dwDirection, ppenumFormatEtc);
1428
1429   return hres;
1430 }
1431
1432 /************************************************************************
1433  * DefaultHandler_DAdvise (IDataObject)
1434  *
1435  * The default handler's implementation of this method simply
1436  * delegates to the DataAdviseHolder.
1437  *
1438  * See Windows documentation for more details on IDataObject methods.
1439  */
1440 static HRESULT WINAPI DefaultHandler_DAdvise(
1441             IDataObject*     iface,
1442             FORMATETC*       pformatetc,
1443             DWORD            advf,
1444             IAdviseSink*     pAdvSink,
1445             DWORD*           pdwConnection)
1446 {
1447   HRESULT hres = S_OK;
1448   _ICOM_THIS_From_IDataObject(DefaultHandler, iface);
1449
1450   TRACE(ole, "(%p, %p, %ld, %p, %p)\n",
1451         iface, pformatetc, advf, pAdvSink, pdwConnection);
1452
1453   /*
1454    * Make sure we have a data advise holder before we start.
1455    */
1456   if (this->dataAdviseHolder==NULL)
1457   {
1458     hres = CreateDataAdviseHolder(&this->dataAdviseHolder);
1459   }
1460
1461   if (SUCCEEDED(hres))
1462   {
1463     hres = IDataAdviseHolder_Advise(this->dataAdviseHolder,
1464                                     iface,
1465                                     pformatetc,
1466                                     advf,
1467                                     pAdvSink,
1468                                     pdwConnection);
1469   }
1470
1471   return hres;
1472 }
1473
1474 /************************************************************************
1475  * DefaultHandler_DUnadvise (IDataObject)
1476  *
1477  * The default handler's implementation of this method simply
1478  * delegates to the DataAdviseHolder.
1479  *
1480  * See Windows documentation for more details on IDataObject methods.
1481  */
1482 static HRESULT WINAPI DefaultHandler_DUnadvise(
1483             IDataObject*     iface,
1484             DWORD            dwConnection)
1485 {
1486   _ICOM_THIS_From_IDataObject(DefaultHandler, iface);
1487
1488   TRACE(ole, "(%p, %ld)\n", iface, dwConnection);
1489
1490   /*
1491    * If we don't have a data advise holder yet, it means that
1492    * we don't have any connections..
1493    */
1494   if (this->dataAdviseHolder==NULL)
1495   {
1496     return OLE_E_NOCONNECTION;
1497   }
1498
1499   return IDataAdviseHolder_Unadvise(this->dataAdviseHolder,
1500                                     dwConnection);
1501 }
1502
1503 /************************************************************************
1504  * DefaultHandler_EnumDAdvise (IDataObject)
1505  *
1506  * The default handler's implementation of this method simply
1507  * delegates to the DataAdviseHolder.
1508  *
1509  * See Windows documentation for more details on IDataObject methods.
1510  */
1511 static HRESULT WINAPI DefaultHandler_EnumDAdvise(
1512             IDataObject*     iface,
1513             IEnumSTATDATA**  ppenumAdvise)
1514 {
1515   _ICOM_THIS_From_IDataObject(DefaultHandler, iface);
1516
1517   TRACE(ole, "(%p, %p)\n", iface, ppenumAdvise);
1518
1519   /*
1520    * Sanity check
1521    */
1522   if (ppenumAdvise == NULL)
1523     return E_POINTER;
1524
1525   /*
1526    * Initialize the out parameter.
1527    */
1528   *ppenumAdvise = NULL;
1529
1530   /*
1531    * If we have a data advise holder object, delegate.
1532    */
1533   if (this->dataAdviseHolder!=NULL)
1534   {
1535     return IDataAdviseHolder_EnumAdvise(this->dataAdviseHolder,
1536                                         ppenumAdvise);
1537   }
1538
1539   return S_OK;
1540 }
1541
1542 /*********************************************************
1543  * Methods implementation for the IRunnableObject part
1544  * of the DefaultHandler class.
1545  */
1546
1547 /************************************************************************
1548  * DefaultHandler_IRunnableObject_QueryInterface (IUnknown)
1549  *
1550  * See Windows documentation for more details on IUnknown methods.
1551  */
1552 static HRESULT WINAPI DefaultHandler_IRunnableObject_QueryInterface(
1553             IRunnableObject*     iface,
1554             REFIID               riid,
1555             void**               ppvObject)
1556 {
1557   _ICOM_THIS_From_IRunnableObject(DefaultHandler, iface);
1558
1559   return IUnknown_QueryInterface(this->outerUnknown, riid, ppvObject);
1560 }
1561
1562 /************************************************************************
1563  * DefaultHandler_IRunnableObject_QueryInterface (IUnknown)
1564  *
1565  * See Windows documentation for more details on IUnknown methods.
1566  */
1567 static ULONG WINAPI DefaultHandler_IRunnableObject_AddRef(
1568             IRunnableObject*     iface)
1569 {
1570   _ICOM_THIS_From_IRunnableObject(DefaultHandler, iface);
1571
1572   return IUnknown_AddRef(this->outerUnknown);
1573 }
1574
1575 /************************************************************************
1576  * DefaultHandler_IRunnableObject_QueryInterface (IUnknown)
1577  *
1578  * See Windows documentation for more details on IUnknown methods.
1579  */
1580 static ULONG WINAPI DefaultHandler_IRunnableObject_Release(
1581             IRunnableObject*     iface)
1582 {
1583   _ICOM_THIS_From_IRunnableObject(DefaultHandler, iface);
1584
1585   return IUnknown_Release(this->outerUnknown);
1586 }
1587
1588 /************************************************************************
1589  * DefaultHandler_GetRunningClass (IRunnableObject)
1590  *
1591  * According to Brockscmidt, Chapter 19, the default handler's
1592  * implementation of IRunnableobject does nothing until the object
1593  * is actually running.
1594  *
1595  * See Windows documentation for more details on IRunnableObject methods.
1596  */
1597 static HRESULT WINAPI DefaultHandler_GetRunningClass(
1598             IRunnableObject*     iface,
1599             LPCLSID              lpClsid)
1600 {
1601   TRACE(ole, "()\n");
1602   return S_OK;
1603 }
1604
1605 static HRESULT WINAPI DefaultHandler_Run(
1606             IRunnableObject*     iface,
1607             IBindCtx*            pbc)
1608 {
1609   FIXME(ole, ": Stub\n");
1610   return E_NOTIMPL;
1611 }
1612
1613 /************************************************************************
1614  * DefaultHandler_IsRunning (IRunnableObject)
1615  *
1616  * According to Brockscmidt, Chapter 19, the default handler's
1617  * implementation of IRunnableobject does nothing until the object
1618  * is actually running.
1619  *
1620  * See Windows documentation for more details on IRunnableObject methods.
1621  */
1622 static BOOL    WINAPI DefaultHandler_IsRunning(
1623             IRunnableObject*     iface)
1624 {
1625   TRACE(ole, "()\n");
1626   return S_FALSE;
1627 }
1628
1629 /************************************************************************
1630  * DefaultHandler_LockRunning (IRunnableObject)
1631  *
1632  * According to Brockscmidt, Chapter 19, the default handler's
1633  * implementation of IRunnableobject does nothing until the object
1634  * is actually running.
1635  *
1636  * See Windows documentation for more details on IRunnableObject methods.
1637  */
1638 static HRESULT WINAPI DefaultHandler_LockRunning(
1639             IRunnableObject*     iface,
1640             BOOL                 fLock,
1641             BOOL                 fLastUnlockCloses)
1642 {
1643   TRACE(ole, "()\n");
1644   return S_OK;
1645 }
1646
1647 /************************************************************************
1648  * DefaultHandler_SetContainedObject (IRunnableObject)
1649  *
1650  * According to Brockscmidt, Chapter 19, the default handler's
1651  * implementation of IRunnableobject does nothing until the object
1652  * is actually running.
1653  *
1654  * See Windows documentation for more details on IRunnableObject methods.
1655  */
1656 static HRESULT WINAPI DefaultHandler_SetContainedObject(
1657             IRunnableObject*     iface,
1658             BOOL                 fContained)
1659 {
1660   TRACE(ole, "()\n");
1661   return S_OK;
1662 }
1663