git.oblomov.eu Git - wine/blob - dlls/ole32/defaulthandler.c

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