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