dlls/ole32/defaulthandler.c

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