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