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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 "ole2.h"
  59
  60 #include "compobj_private.h"
  61
  62 #include "wine/unicode.h"
  63 #include "wine/debug.h"
  64
  65 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  66
  67 enum storage_state
  68 {
  69     storage_state_uninitialised,
  70     storage_state_initialised,
  71     storage_state_loaded
  72 };
  73
  74 /****************************************************************************
  75  * DefaultHandler
  76  *
  77  */
  78 struct DefaultHandler
  79 {
  80   const IOleObjectVtbl*      lpVtbl;
  81   const IUnknownVtbl*        lpvtblIUnknown;
  82   const IDataObjectVtbl*     lpvtblIDataObject;
  83   const IRunnableObjectVtbl* lpvtblIRunnableObject;
  84   const IAdviseSinkVtbl     *lpvtblIAdviseSink;
  85   const IPersistStorageVtbl *lpvtblIPersistStorage;
  86
  87   /* Reference count of this object */
  88   LONG ref;
  89
  90   /* IUnknown implementation of the outer object. */
  91   IUnknown* outerUnknown;
  92
  93   /* Class Id that this handler object represents. */
  94   CLSID clsid;
  95
  96   /* IUnknown implementation of the datacache. */
  97   IUnknown* dataCache;
  98   /* IPersistStorage implementation of the datacache. */
  99   IPersistStorage* dataCache_PersistStg;
 100
 101   /* Client site for the embedded object. */
 102   IOleClientSite* clientSite;
 103
 104   /*
 105    * The IOleAdviseHolder maintains the connections
 106    * on behalf of the default handler.
 107    */
 108   IOleAdviseHolder* oleAdviseHolder;
 109
 110   /*
 111    * The IDataAdviseHolder maintains the data
 112    * connections on behalf of the default handler.
 113    */
 114   IDataAdviseHolder* dataAdviseHolder;
 115
 116   /* Name of the container and object contained */
 117   LPWSTR containerApp;
 118   LPWSTR containerObj;
 119
 120   /* IOleObject delegate */
 121   IOleObject *pOleDelegate;
 122   /* IPersistStorage delegate */
 123   IPersistStorage *pPSDelegate;
 124   /* IDataObject delegate */
 125   IDataObject *pDataDelegate;
 126
 127   /* connection cookie for the advise on the delegate OLE object */
 128   DWORD dwAdvConn;
 129
 130   /* storage passed to Load or InitNew */
 131   IStorage *storage;
 132   enum storage_state storage_state;
 133 };
 134
 135 typedef struct DefaultHandler DefaultHandler;
 136
 137 static inline DefaultHandler *impl_from_IOleObject( IOleObject *iface )
 138 {
 139     return (DefaultHandler *)((char*)iface - FIELD_OFFSET(DefaultHandler, lpVtbl));
 140 }
 141
 142 static inline DefaultHandler *impl_from_NDIUnknown( IUnknown *iface )
 143 {
 144     return (DefaultHandler *)((char*)iface - FIELD_OFFSET(DefaultHandler, lpvtblIUnknown));
 145 }
 146
 147 static inline DefaultHandler *impl_from_IDataObject( IDataObject *iface )
 148 {
 149     return (DefaultHandler *)((char*)iface - FIELD_OFFSET(DefaultHandler, lpvtblIDataObject));
 150 }
 151
 152 static inline DefaultHandler *impl_from_IRunnableObject( IRunnableObject *iface )
 153 {
 154     return (DefaultHandler *)((char*)iface - FIELD_OFFSET(DefaultHandler, lpvtblIRunnableObject));
 155 }
 156
 157 static inline DefaultHandler *impl_from_IAdviseSink( IAdviseSink *iface )
 158 {
 159     return (DefaultHandler *)((char*)iface - FIELD_OFFSET(DefaultHandler, lpvtblIAdviseSink));
 160 }
 161
 162 static inline DefaultHandler *impl_from_IPersistStorage( IPersistStorage *iface )
 163 {
 164     return (DefaultHandler *)((char*)iface - FIELD_OFFSET(DefaultHandler, lpvtblIPersistStorage));
 165 }
 166
 167 static void DefaultHandler_Destroy(DefaultHandler* This);
 168
 169 static inline BOOL object_is_running(DefaultHandler *This)
 170 {
 171     return IRunnableObject_IsRunning((IRunnableObject*)&This->lpvtblIRunnableObject);
 172 }
 173
 174 /*********************************************************
 175  * Method implementation for the  non delegating IUnknown
 176  * part of the DefaultHandler class.
 177  */
 178
 179 /************************************************************************
 180  * DefaultHandler_NDIUnknown_QueryInterface (IUnknown)
 181  *
 182  * See Windows documentation for more details on IUnknown methods.
 183  *
 184  * This version of QueryInterface will not delegate its implementation
 185  * to the outer unknown.
 186  */
 187 static HRESULT WINAPI DefaultHandler_NDIUnknown_QueryInterface(
 188             IUnknown*      iface,
 189             REFIID         riid,
 190             void**         ppvObject)
 191 {
 192   DefaultHandler *This = impl_from_NDIUnknown(iface);
 193
 194   if (!ppvObject)
 195     return E_INVALIDARG;
 196
 197   *ppvObject = NULL;
 198
 199   if (IsEqualIID(&IID_IUnknown, riid))
 200     *ppvObject = iface;
 201   else if (IsEqualIID(&IID_IOleObject, riid))
 202     *ppvObject = (IOleObject*)&This->lpVtbl;
 203   else if (IsEqualIID(&IID_IDataObject, riid))
 204     *ppvObject = (IDataObject*)&This->lpvtblIDataObject;
 205   else if (IsEqualIID(&IID_IRunnableObject, riid))
 206     *ppvObject = (IRunnableObject*)&This->lpvtblIRunnableObject;
 207   else if (IsEqualIID(&IID_IPersist, riid) ||
 208            IsEqualIID(&IID_IPersistStorage, riid))
 209     *ppvObject = &This->lpvtblIPersistStorage;
 210   else if (IsEqualIID(&IID_IViewObject, riid) ||
 211            IsEqualIID(&IID_IViewObject2, riid) ||
 212            IsEqualIID(&IID_IOleCache, riid) ||
 213            IsEqualIID(&IID_IOleCache2, riid))
 214   {
 215     HRESULT hr = IUnknown_QueryInterface(This->dataCache, riid, ppvObject);
 216     if (FAILED(hr)) FIXME("interface %s not implemented by data cache\n", debugstr_guid(riid));
 217     return hr;
 218   }
 219
 220   /* Check that we obtained an interface. */
 221   if (*ppvObject == NULL)
 222   {
 223     WARN( "() : asking for un supported interface %s\n", debugstr_guid(riid));
 224     return E_NOINTERFACE;
 225   }
 226
 227   /*
 228    * Query Interface always increases the reference count by one when it is
 229    * successful.
 230    */
 231   IUnknown_AddRef((IUnknown*)*ppvObject);
 232
 233   return S_OK;
 234 }
 235
 236 /************************************************************************
 237  * DefaultHandler_NDIUnknown_AddRef (IUnknown)
 238  *
 239  * See Windows documentation for more details on IUnknown methods.
 240  *
 241  * This version of QueryInterface will not delegate its implementation
 242  * to the outer unknown.
 243  */
 244 static ULONG WINAPI DefaultHandler_NDIUnknown_AddRef(
 245             IUnknown*      iface)
 246 {
 247   DefaultHandler *This = impl_from_NDIUnknown(iface);
 248   return InterlockedIncrement(&This->ref);
 249 }
 250
 251 /************************************************************************
 252  * DefaultHandler_NDIUnknown_Release (IUnknown)
 253  *
 254  * See Windows documentation for more details on IUnknown methods.
 255  *
 256  * This version of QueryInterface will not delegate its implementation
 257  * to the outer unknown.
 258  */
 259 static ULONG WINAPI DefaultHandler_NDIUnknown_Release(
 260             IUnknown*      iface)
 261 {
 262   DefaultHandler *This = impl_from_NDIUnknown(iface);
 263   ULONG ref;
 264
 265   ref = InterlockedDecrement(&This->ref);
 266
 267   if (!ref) DefaultHandler_Destroy(This);
 268
 269   return ref;
 270 }
 271
 272 /*********************************************************
 273  * Methods implementation for the IOleObject part of
 274  * the DefaultHandler class.
 275  */
 276
 277 /************************************************************************
 278  * DefaultHandler_QueryInterface (IUnknown)
 279  *
 280  * See Windows documentation for more details on IUnknown methods.
 281  */
 282 static HRESULT WINAPI DefaultHandler_QueryInterface(
 283             IOleObject*      iface,
 284             REFIID           riid,
 285             void**           ppvObject)
 286 {
 287   DefaultHandler *This = impl_from_IOleObject(iface);
 288
 289   return IUnknown_QueryInterface(This->outerUnknown, riid, ppvObject);
 290 }
 291
 292 /************************************************************************
 293  * DefaultHandler_AddRef (IUnknown)
 294  *
 295  * See Windows documentation for more details on IUnknown methods.
 296  */
 297 static ULONG WINAPI DefaultHandler_AddRef(
 298             IOleObject*        iface)
 299 {
 300   DefaultHandler *This = impl_from_IOleObject(iface);
 301
 302   return IUnknown_AddRef(This->outerUnknown);
 303 }
 304
 305 /************************************************************************
 306  * DefaultHandler_Release (IUnknown)
 307  *
 308  * See Windows documentation for more details on IUnknown methods.
 309  */
 310 static ULONG WINAPI DefaultHandler_Release(
 311             IOleObject*        iface)
 312 {
 313   DefaultHandler *This = impl_from_IOleObject(iface);
 314
 315   return IUnknown_Release(This->outerUnknown);
 316 }
 317
 318 /************************************************************************
 319  * DefaultHandler_SetClientSite (IOleObject)
 320  *
 321  * The default handler's implementation of this method only keeps the
 322  * client site pointer for future reference.
 323  *
 324  * See Windows documentation for more details on IOleObject methods.
 325  */
 326 static HRESULT WINAPI DefaultHandler_SetClientSite(
 327             IOleObject*        iface,
 328             IOleClientSite*    pClientSite)
 329 {
 330   DefaultHandler *This = impl_from_IOleObject(iface);
 331   HRESULT hr = S_OK;
 332
 333   TRACE("(%p, %p)\n", iface, pClientSite);
 334
 335   if (object_is_running(This))
 336     hr = IOleObject_SetClientSite(This->pOleDelegate, pClientSite);
 337
 338   /*
 339    * Make sure we release the previous client site if there
 340    * was one.
 341    */
 342   if (This->clientSite)
 343     IOleClientSite_Release(This->clientSite);
 344
 345   This->clientSite = pClientSite;
 346
 347   if (This->clientSite)
 348     IOleClientSite_AddRef(This->clientSite);
 349
 350   return S_OK;
 351 }
 352
 353 /************************************************************************
 354  * DefaultHandler_GetClientSite (IOleObject)
 355  *
 356  * The default handler's implementation of this method returns the
 357  * last pointer set in IOleObject_SetClientSite.
 358  *
 359  * See Windows documentation for more details on IOleObject methods.
 360  */
 361 static HRESULT WINAPI DefaultHandler_GetClientSite(
 362             IOleObject*        iface,
 363             IOleClientSite**   ppClientSite)
 364 {
 365   DefaultHandler *This = impl_from_IOleObject(iface);
 366
 367   if (!ppClientSite)
 368     return E_POINTER;
 369
 370   *ppClientSite = This->clientSite;
 371
 372   if (This->clientSite)
 373     IOleClientSite_AddRef(This->clientSite);
 374
 375   return S_OK;
 376 }
 377
 378 /************************************************************************
 379  * DefaultHandler_SetHostNames (IOleObject)
 380  *
 381  * The default handler's implementation of this method just stores
 382  * the strings and returns S_OK.
 383  *
 384  * See Windows documentation for more details on IOleObject methods.
 385  */
 386 static HRESULT WINAPI DefaultHandler_SetHostNames(
 387             IOleObject*        iface,
 388             LPCOLESTR          szContainerApp,
 389             LPCOLESTR          szContainerObj)
 390 {
 391   DefaultHandler *This = impl_from_IOleObject(iface);
 392
 393   TRACE("(%p, %s, %s)\n",
 394         iface,
 395         debugstr_w(szContainerApp),
 396         debugstr_w(szContainerObj));
 397
 398   if (object_is_running(This))
 399     IOleObject_SetHostNames(This->pOleDelegate, szContainerApp, szContainerObj);
 400
 401   /* Be sure to cleanup before re-assigning the strings. */
 402   HeapFree( GetProcessHeap(), 0, This->containerApp );
 403   This->containerApp = NULL;
 404   HeapFree( GetProcessHeap(), 0, This->containerObj );
 405   This->containerObj = NULL;
 406
 407   if (szContainerApp)
 408   {
 409       if ((This->containerApp = HeapAlloc( GetProcessHeap(), 0,
 410                                            (lstrlenW(szContainerApp) + 1) * sizeof(WCHAR) )))
 411           strcpyW( This->containerApp, szContainerApp );
 412   }
 413
 414   if (szContainerObj)
 415   {
 416       if ((This->containerObj = HeapAlloc( GetProcessHeap(), 0,
 417                                            (lstrlenW(szContainerObj) + 1) * sizeof(WCHAR) )))
 418           strcpyW( This->containerObj, szContainerObj );
 419   }
 420   return S_OK;
 421 }
 422
 423 /* undoes the work done by DefaultHandler_Run */
 424 static void DefaultHandler_Stop(DefaultHandler *This)
 425 {
 426   if (!object_is_running(This))
 427     return;
 428
 429   IOleObject_Unadvise(This->pOleDelegate, This->dwAdvConn);
 430
 431   /* FIXME: call IOleCache_OnStop */
 432
 433   if (This->dataAdviseHolder)
 434     DataAdviseHolder_OnDisconnect(This->dataAdviseHolder);
 435   if (This->pDataDelegate)
 436   {
 437      IDataObject_Release(This->pDataDelegate);
 438      This->pDataDelegate = NULL;
 439   }
 440   if (This->pPSDelegate)
 441   {
 442      IPersistStorage_Release(This->pPSDelegate);
 443      This->pPSDelegate = NULL;
 444   }
 445   IOleObject_Release(This->pOleDelegate);
 446   This->pOleDelegate = NULL;
 447 }
 448
 449 /************************************************************************
 450  * DefaultHandler_Close (IOleObject)
 451  *
 452  * The default handler's implementation of this method is meaningless
 453  * without a running server so it does nothing.
 454  *
 455  * See Windows documentation for more details on IOleObject methods.
 456  */
 457 static HRESULT WINAPI DefaultHandler_Close(
 458             IOleObject*        iface,
 459             DWORD              dwSaveOption)
 460 {
 461   DefaultHandler *This = impl_from_IOleObject(iface);
 462   HRESULT hr;
 463
 464   TRACE("(%d)\n", dwSaveOption);
 465
 466   if (!object_is_running(This))
 467     return S_OK;
 468
 469   hr = IOleObject_Close(This->pOleDelegate, dwSaveOption);
 470
 471   DefaultHandler_Stop(This);
 472
 473   return hr;
 474 }
 475
 476 /************************************************************************
 477  * DefaultHandler_SetMoniker (IOleObject)
 478  *
 479  * The default handler's implementation of this method does nothing.
 480  *
 481  * See Windows documentation for more details on IOleObject methods.
 482  */
 483 static HRESULT WINAPI DefaultHandler_SetMoniker(
 484             IOleObject*        iface,
 485             DWORD              dwWhichMoniker,
 486             IMoniker*          pmk)
 487 {
 488   DefaultHandler *This = impl_from_IOleObject(iface);
 489
 490   TRACE("(%p, %d, %p)\n",
 491         iface,
 492         dwWhichMoniker,
 493         pmk);
 494
 495   if (object_is_running(This))
 496     return IOleObject_SetMoniker(This->pOleDelegate, dwWhichMoniker, pmk);
 497
 498   return S_OK;
 499 }
 500
 501 /************************************************************************
 502  * DefaultHandler_GetMoniker (IOleObject)
 503  *
 504  * Delegate this request to the client site if we have one.
 505  *
 506  * See Windows documentation for more details on IOleObject methods.
 507  */
 508 static HRESULT WINAPI DefaultHandler_GetMoniker(
 509             IOleObject*        iface,
 510             DWORD              dwAssign,
 511             DWORD              dwWhichMoniker,
 512             IMoniker**         ppmk)
 513 {
 514   DefaultHandler *This = impl_from_IOleObject(iface);
 515
 516   TRACE("(%p, %d, %d, %p)\n",
 517         iface, dwAssign, dwWhichMoniker, ppmk);
 518
 519   if (object_is_running(This))
 520     return IOleObject_GetMoniker(This->pOleDelegate, dwAssign, dwWhichMoniker,
 521                                  ppmk);
 522
 523   /* FIXME: dwWhichMoniker == OLEWHICHMK_CONTAINER only? */
 524   if (This->clientSite)
 525   {
 526     return IOleClientSite_GetMoniker(This->clientSite,
 527                                      dwAssign,
 528                                      dwWhichMoniker,
 529                                      ppmk);
 530
 531   }
 532
 533   return E_FAIL;
 534 }
 535
 536 /************************************************************************
 537  * DefaultHandler_InitFromData (IOleObject)
 538  *
 539  * This method is meaningless if the server is not running
 540  *
 541  * See Windows documentation for more details on IOleObject methods.
 542  */
 543 static HRESULT WINAPI DefaultHandler_InitFromData(
 544             IOleObject*        iface,
 545             IDataObject*       pDataObject,
 546             BOOL               fCreation,
 547             DWORD              dwReserved)
 548 {
 549   DefaultHandler *This = impl_from_IOleObject(iface);
 550
 551   TRACE("(%p, %p, %d, %d)\n",
 552         iface, pDataObject, fCreation, dwReserved);
 553
 554   if (object_is_running(This))
 555     return IOleObject_InitFromData(This->pOleDelegate, pDataObject, fCreation,
 556                                    dwReserved);
 557   return OLE_E_NOTRUNNING;
 558 }
 559
 560 /************************************************************************
 561  * DefaultHandler_GetClipboardData (IOleObject)
 562  *
 563  * This method is meaningless if the server is not running
 564  *
 565  * See Windows documentation for more details on IOleObject methods.
 566  */
 567 static HRESULT WINAPI DefaultHandler_GetClipboardData(
 568             IOleObject*        iface,
 569             DWORD              dwReserved,
 570             IDataObject**      ppDataObject)
 571 {
 572   DefaultHandler *This = impl_from_IOleObject(iface);
 573
 574   TRACE("(%p, %d, %p)\n",
 575         iface, dwReserved, ppDataObject);
 576
 577   if (object_is_running(This))
 578     return IOleObject_GetClipboardData(This->pOleDelegate, dwReserved,
 579                                        ppDataObject);
 580
 581   return OLE_E_NOTRUNNING;
 582 }
 583
 584 static HRESULT WINAPI DefaultHandler_DoVerb(
 585             IOleObject*        iface,
 586             LONG               iVerb,
 587             struct tagMSG*     lpmsg,
 588             IOleClientSite*    pActiveSite,
 589             LONG               lindex,
 590             HWND               hwndParent,
 591             LPCRECT            lprcPosRect)
 592 {
 593   DefaultHandler *This = impl_from_IOleObject(iface);
 594   IRunnableObject *pRunnableObj = (IRunnableObject *)&This->lpvtblIRunnableObject;
 595   HRESULT hr;
 596
 597   TRACE("(%d, %p, %p, %d, %p, %s)\n", iVerb, lpmsg, pActiveSite, lindex, hwndParent, wine_dbgstr_rect(lprcPosRect));
 598
 599   hr = IRunnableObject_Run(pRunnableObj, NULL);
 600   if (FAILED(hr)) return hr;
 601
 602   return IOleObject_DoVerb(This->pOleDelegate, iVerb, lpmsg, pActiveSite,
 603                            lindex, hwndParent, lprcPosRect);
 604 }
 605
 606 /************************************************************************
 607  * DefaultHandler_EnumVerbs (IOleObject)
 608  *
 609  * The default handler implementation of this method simply delegates
 610  * to OleRegEnumVerbs
 611  *
 612  * See Windows documentation for more details on IOleObject methods.
 613  */
 614 static HRESULT WINAPI DefaultHandler_EnumVerbs(
 615             IOleObject*        iface,
 616             IEnumOLEVERB**     ppEnumOleVerb)
 617 {
 618   DefaultHandler *This = impl_from_IOleObject(iface);
 619   HRESULT hr = OLE_S_USEREG;
 620
 621   TRACE("(%p, %p)\n", iface, ppEnumOleVerb);
 622
 623   if (object_is_running(This))
 624     hr = IOleObject_EnumVerbs(This->pOleDelegate, ppEnumOleVerb);
 625
 626   if (hr == OLE_S_USEREG)
 627     return OleRegEnumVerbs(&This->clsid, ppEnumOleVerb);
 628   else
 629     return hr;
 630 }
 631
 632 static HRESULT WINAPI DefaultHandler_Update(
 633             IOleObject*        iface)
 634 {
 635     DefaultHandler *This = impl_from_IOleObject(iface);
 636     TRACE("(%p)\n", iface);
 637
 638     if (!object_is_running(This))
 639     {
 640         FIXME("Should run object\n");
 641         return E_NOTIMPL;
 642     }
 643     return IOleObject_Update(This->pOleDelegate);
 644 }
 645
 646 /************************************************************************
 647  * DefaultHandler_IsUpToDate (IOleObject)
 648  *
 649  * This method is meaningless if the server is not running
 650  *
 651  * See Windows documentation for more details on IOleObject methods.
 652  */
 653 static HRESULT WINAPI DefaultHandler_IsUpToDate(
 654             IOleObject*        iface)
 655 {
 656     DefaultHandler *This = impl_from_IOleObject(iface);
 657     TRACE("(%p)\n", iface);
 658
 659     if (object_is_running(This))
 660         return IOleObject_IsUpToDate(This->pOleDelegate);
 661
 662     return OLE_E_NOTRUNNING;
 663 }
 664
 665 /************************************************************************
 666  * DefaultHandler_GetUserClassID (IOleObject)
 667  *
 668  * TODO: Map to a new class ID if emulation is active.
 669  *
 670  * See Windows documentation for more details on IOleObject methods.
 671  */
 672 static HRESULT WINAPI DefaultHandler_GetUserClassID(
 673             IOleObject*        iface,
 674             CLSID*             pClsid)
 675 {
 676   DefaultHandler *This = impl_from_IOleObject(iface);
 677
 678   TRACE("(%p, %p)\n", iface, pClsid);
 679
 680   if (object_is_running(This))
 681     return IOleObject_GetUserClassID(This->pOleDelegate, pClsid);
 682
 683   if (!pClsid)
 684     return E_POINTER;
 685
 686   *pClsid = This->clsid;
 687
 688   return S_OK;
 689 }
 690
 691 /************************************************************************
 692  * DefaultHandler_GetUserType (IOleObject)
 693  *
 694  * The default handler implementation of this method simply delegates
 695  * to OleRegGetUserType
 696  *
 697  * See Windows documentation for more details on IOleObject methods.
 698  */
 699 static HRESULT WINAPI DefaultHandler_GetUserType(
 700             IOleObject*        iface,
 701             DWORD              dwFormOfType,
 702             LPOLESTR*          pszUserType)
 703 {
 704   DefaultHandler *This = impl_from_IOleObject(iface);
 705
 706   TRACE("(%p, %d, %p)\n", iface, dwFormOfType, pszUserType);
 707   if (object_is_running(This))
 708     return IOleObject_GetUserType(This->pOleDelegate, dwFormOfType, pszUserType);
 709
 710   return OleRegGetUserType(&This->clsid, dwFormOfType, pszUserType);
 711 }
 712
 713 /************************************************************************
 714  * DefaultHandler_SetExtent (IOleObject)
 715  *
 716  * This method is meaningless if the server is not running
 717  *
 718  * See Windows documentation for more details on IOleObject methods.
 719  */
 720 static HRESULT WINAPI DefaultHandler_SetExtent(
 721             IOleObject*        iface,
 722             DWORD              dwDrawAspect,
 723             SIZEL*             psizel)
 724 {
 725   DefaultHandler *This = impl_from_IOleObject(iface);
 726
 727   TRACE("(%p, %x, (%d x %d))\n", iface,
 728         dwDrawAspect, psizel->cx, psizel->cy);
 729
 730   if (object_is_running(This))
 731     return IOleObject_SetExtent(This->pOleDelegate, dwDrawAspect, psizel);
 732
 733   return OLE_E_NOTRUNNING;
 734 }
 735
 736 /************************************************************************
 737  * DefaultHandler_GetExtent (IOleObject)
 738  *
 739  * The default handler's implementation of this method returns uses
 740  * the cache to locate the aspect and extract the extent from it.
 741  *
 742  * See Windows documentation for more details on IOleObject methods.
 743  */
 744 static HRESULT WINAPI DefaultHandler_GetExtent(
 745             IOleObject*        iface,
 746             DWORD              dwDrawAspect,
 747             SIZEL*             psizel)
 748 {
 749   DVTARGETDEVICE* targetDevice;
 750   IViewObject2*   cacheView = NULL;
 751   HRESULT         hres;
 752
 753   DefaultHandler *This = impl_from_IOleObject(iface);
 754
 755   TRACE("(%p, %x, %p)\n", iface, dwDrawAspect, psizel);
 756
 757   if (object_is_running(This))
 758     return IOleObject_GetExtent(This->pOleDelegate, dwDrawAspect, psizel);
 759
 760   hres = IUnknown_QueryInterface(This->dataCache, &IID_IViewObject2, (void**)&cacheView);
 761   if (FAILED(hres))
 762     return E_UNEXPECTED;
 763
 764   /*
 765    * Prepare the call to the cache's GetExtent method.
 766    *
 767    * Here we would build a valid DVTARGETDEVICE structure
 768    * but, since we are calling into the data cache, we
 769    * know its implementation and we'll skip this
 770    * extra work until later.
 771    */
 772   targetDevice = NULL;
 773
 774   hres = IViewObject2_GetExtent(cacheView,
 775                                 dwDrawAspect,
 776                                 -1,
 777                                 targetDevice,
 778                                 psizel);
 779
 780   IViewObject2_Release(cacheView);
 781
 782   return hres;
 783 }
 784
 785 /************************************************************************
 786  * DefaultHandler_Advise (IOleObject)
 787  *
 788  * The default handler's implementation of this method simply
 789  * delegates to the OleAdviseHolder.
 790  *
 791  * See Windows documentation for more details on IOleObject methods.
 792  */
 793 static HRESULT WINAPI DefaultHandler_Advise(
 794             IOleObject*        iface,
 795             IAdviseSink*       pAdvSink,
 796             DWORD*             pdwConnection)
 797 {
 798   HRESULT hres = S_OK;
 799   DefaultHandler *This = impl_from_IOleObject(iface);
 800
 801   TRACE("(%p, %p, %p)\n", iface, pAdvSink, pdwConnection);
 802
 803   /* Make sure we have an advise holder before we start. */
 804   if (!This->oleAdviseHolder)
 805     hres = CreateOleAdviseHolder(&This->oleAdviseHolder);
 806
 807   if (SUCCEEDED(hres))
 808     hres = IOleAdviseHolder_Advise(This->oleAdviseHolder,
 809                                    pAdvSink,
 810                                    pdwConnection);
 811
 812   return hres;
 813 }
 814
 815 /************************************************************************
 816  * DefaultHandler_Unadvise (IOleObject)
 817  *
 818  * The default handler's implementation of this method simply
 819  * delegates to the OleAdviseHolder.
 820  *
 821  * See Windows documentation for more details on IOleObject methods.
 822  */
 823 static HRESULT WINAPI DefaultHandler_Unadvise(
 824             IOleObject*        iface,
 825             DWORD              dwConnection)
 826 {
 827   DefaultHandler *This = impl_from_IOleObject(iface);
 828
 829   TRACE("(%p, %d)\n", iface, dwConnection);
 830
 831   /*
 832    * If we don't have an advise holder yet, it means we don't have
 833    * a connection.
 834    */
 835   if (!This->oleAdviseHolder)
 836     return OLE_E_NOCONNECTION;
 837
 838   return IOleAdviseHolder_Unadvise(This->oleAdviseHolder,
 839                                    dwConnection);
 840 }
 841
 842 /************************************************************************
 843  * DefaultHandler_EnumAdvise (IOleObject)
 844  *
 845  * The default handler's implementation of this method simply
 846  * delegates to the OleAdviseHolder.
 847  *
 848  * See Windows documentation for more details on IOleObject methods.
 849  */
 850 static HRESULT WINAPI DefaultHandler_EnumAdvise(
 851             IOleObject*        iface,
 852             IEnumSTATDATA**    ppenumAdvise)
 853 {
 854   DefaultHandler *This = impl_from_IOleObject(iface);
 855
 856   TRACE("(%p, %p)\n", iface, ppenumAdvise);
 857
 858   if (!ppenumAdvise)
 859     return E_POINTER;
 860
 861   *ppenumAdvise = NULL;
 862
 863   if (!This->oleAdviseHolder)
 864       return S_OK;
 865
 866   return IOleAdviseHolder_EnumAdvise(This->oleAdviseHolder, ppenumAdvise);
 867 }
 868
 869 /************************************************************************
 870  * DefaultHandler_GetMiscStatus (IOleObject)
 871  *
 872  * The default handler's implementation of this method simply delegates
 873  * to OleRegGetMiscStatus.
 874  *
 875  * See Windows documentation for more details on IOleObject methods.
 876  */
 877 static HRESULT WINAPI DefaultHandler_GetMiscStatus(
 878             IOleObject*        iface,
 879             DWORD              dwAspect,
 880             DWORD*             pdwStatus)
 881 {
 882   HRESULT hres;
 883   DefaultHandler *This = impl_from_IOleObject(iface);
 884
 885   TRACE("(%p, %x, %p)\n", iface, dwAspect, pdwStatus);
 886
 887   if (object_is_running(This))
 888     return IOleObject_GetMiscStatus(This->pOleDelegate, dwAspect, pdwStatus);
 889
 890   hres = OleRegGetMiscStatus(&This->clsid, dwAspect, pdwStatus);
 891
 892   if (FAILED(hres))
 893     *pdwStatus = 0;
 894
 895   return S_OK;
 896 }
 897
 898 /************************************************************************
 899  * DefaultHandler_SetColorScheme (IOleObject)
 900  *
 901  * This method is meaningless if the server is not running
 902  *
 903  * See Windows documentation for more details on IOleObject methods.
 904  */
 905 static HRESULT WINAPI DefaultHandler_SetColorScheme(
 906             IOleObject*           iface,
 907             struct tagLOGPALETTE* pLogpal)
 908 {
 909   DefaultHandler *This = impl_from_IOleObject(iface);
 910
 911   TRACE("(%p, %p))\n", iface, pLogpal);
 912
 913   if (object_is_running(This))
 914     return IOleObject_SetColorScheme(This->pOleDelegate, pLogpal);
 915
 916   return OLE_E_NOTRUNNING;
 917 }
 918
 919 /*********************************************************
 920  * Methods implementation for the IDataObject part of
 921  * the DefaultHandler class.
 922  */
 923
 924 /************************************************************************
 925  * DefaultHandler_IDataObject_QueryInterface (IUnknown)
 926  *
 927  * See Windows documentation for more details on IUnknown methods.
 928  */
 929 static HRESULT WINAPI DefaultHandler_IDataObject_QueryInterface(
 930             IDataObject*     iface,
 931            REFIID           riid,
 932             void**           ppvObject)
 933 {
 934   DefaultHandler *This = impl_from_IDataObject(iface);
 935
 936   return IUnknown_QueryInterface(This->outerUnknown, riid, ppvObject);
 937 }
 938
 939 /************************************************************************
 940  * DefaultHandler_IDataObject_AddRef (IUnknown)
 941  *
 942  * See Windows documentation for more details on IUnknown methods.
 943  */
 944 static ULONG WINAPI DefaultHandler_IDataObject_AddRef(
 945             IDataObject*     iface)
 946 {
 947   DefaultHandler *This = impl_from_IDataObject(iface);
 948
 949   return IUnknown_AddRef(This->outerUnknown);
 950 }
 951
 952 /************************************************************************
 953  * DefaultHandler_IDataObject_Release (IUnknown)
 954  *
 955  * See Windows documentation for more details on IUnknown methods.
 956  */
 957 static ULONG WINAPI DefaultHandler_IDataObject_Release(
 958             IDataObject*     iface)
 959 {
 960   DefaultHandler *This = impl_from_IDataObject(iface);
 961
 962   return IUnknown_Release(This->outerUnknown);
 963 }
 964
 965 /************************************************************************
 966  * DefaultHandler_GetData
 967  *
 968  * Get Data from a source dataobject using format pformatetcIn->cfFormat
 969  * See Windows documentation for more details on GetData.
 970  * Default handler's implementation of this method delegates to the cache.
 971  */
 972 static HRESULT WINAPI DefaultHandler_GetData(
 973             IDataObject*     iface,
 974             LPFORMATETC      pformatetcIn,
 975             STGMEDIUM*       pmedium)
 976 {
 977   IDataObject* cacheDataObject = NULL;
 978   HRESULT      hres;
 979
 980   DefaultHandler *This = impl_from_IDataObject(iface);
 981
 982   TRACE("(%p, %p, %p)\n", iface, pformatetcIn, pmedium);
 983
 984   hres = IUnknown_QueryInterface(This->dataCache,
 985                                  &IID_IDataObject,
 986                                  (void**)&cacheDataObject);
 987
 988   if (FAILED(hres))
 989     return E_UNEXPECTED;
 990
 991   hres = IDataObject_GetData(cacheDataObject,
 992                              pformatetcIn,
 993                              pmedium);
 994
 995   IDataObject_Release(cacheDataObject);
 996
 997   if (FAILED(hres) && This->pDataDelegate)
 998     hres = IDataObject_GetData(This->pDataDelegate, pformatetcIn, pmedium);
 999
1000   return hres;
1001 }
1002
1003 static HRESULT WINAPI DefaultHandler_GetDataHere(
1004             IDataObject*     iface,
1005             LPFORMATETC      pformatetc,
1006             STGMEDIUM*       pmedium)
1007 {
1008   FIXME(": Stub\n");
1009   return E_NOTIMPL;
1010 }
1011
1012 /************************************************************************
1013  * DefaultHandler_QueryGetData (IDataObject)
1014  *
1015  * The default handler's implementation of this method delegates to
1016  * the cache.
1017  *
1018  * See Windows documentation for more details on IDataObject methods.
1019  */
1020 static HRESULT WINAPI DefaultHandler_QueryGetData(
1021             IDataObject*     iface,
1022             LPFORMATETC      pformatetc)
1023 {
1024   IDataObject* cacheDataObject = NULL;
1025   HRESULT      hres;
1026
1027   DefaultHandler *This = impl_from_IDataObject(iface);
1028
1029   TRACE("(%p, %p)\n", iface, pformatetc);
1030
1031   hres = IUnknown_QueryInterface(This->dataCache,
1032                                  &IID_IDataObject,
1033                                  (void**)&cacheDataObject);
1034
1035   if (FAILED(hres))
1036     return E_UNEXPECTED;
1037
1038   hres = IDataObject_QueryGetData(cacheDataObject,
1039                                   pformatetc);
1040
1041   IDataObject_Release(cacheDataObject);
1042
1043   if (FAILED(hres) && This->pDataDelegate)
1044     hres = IDataObject_QueryGetData(This->pDataDelegate, pformatetc);
1045
1046   return hres;
1047 }
1048
1049 /************************************************************************
1050  * DefaultHandler_GetCanonicalFormatEtc (IDataObject)
1051  *
1052  * This method is meaningless if the server is not running
1053  *
1054  * See Windows documentation for more details on IDataObject methods.
1055  */
1056 static HRESULT WINAPI DefaultHandler_GetCanonicalFormatEtc(
1057             IDataObject*     iface,
1058             LPFORMATETC      pformatetcIn,
1059             LPFORMATETC      pformatetcOut)
1060 {
1061   DefaultHandler *This = impl_from_IDataObject(iface);
1062
1063   TRACE("(%p, %p, %p)\n", iface, pformatetcIn, pformatetcOut);
1064
1065   if (!This->pDataDelegate)
1066     return OLE_E_NOTRUNNING;
1067
1068   return IDataObject_GetCanonicalFormatEtc(This->pDataDelegate, pformatetcIn, pformatetcOut);
1069 }
1070
1071 /************************************************************************
1072  * DefaultHandler_SetData (IDataObject)
1073  *
1074  * The default handler's implementation of this method delegates to
1075  * the cache.
1076  *
1077  * See Windows documentation for more details on IDataObject methods.
1078  */
1079 static HRESULT WINAPI DefaultHandler_SetData(
1080             IDataObject*     iface,
1081             LPFORMATETC      pformatetc,
1082             STGMEDIUM*       pmedium,
1083             BOOL             fRelease)
1084 {
1085   DefaultHandler *This = impl_from_IDataObject(iface);
1086   IDataObject* cacheDataObject = NULL;
1087   HRESULT      hres;
1088
1089   TRACE("(%p, %p, %p, %d)\n", iface, pformatetc, pmedium, fRelease);
1090
1091   hres = IUnknown_QueryInterface(This->dataCache,
1092                                  &IID_IDataObject,
1093                                  (void**)&cacheDataObject);
1094
1095   if (FAILED(hres))
1096     return E_UNEXPECTED;
1097
1098   hres = IDataObject_SetData(cacheDataObject,
1099                              pformatetc,
1100                              pmedium,
1101                              fRelease);
1102
1103   IDataObject_Release(cacheDataObject);
1104
1105   return hres;
1106 }
1107
1108 /************************************************************************
1109  * DefaultHandler_EnumFormatEtc (IDataObject)
1110  *
1111  * The default handler's implementation of This method simply delegates
1112  * to OleRegEnumFormatEtc.
1113  *
1114  * See Windows documentation for more details on IDataObject methods.
1115  */
1116 static HRESULT WINAPI DefaultHandler_EnumFormatEtc(
1117             IDataObject*     iface,
1118             DWORD            dwDirection,
1119             IEnumFORMATETC** ppenumFormatEtc)
1120 {
1121   HRESULT hres;
1122   DefaultHandler *This = impl_from_IDataObject(iface);
1123
1124   TRACE("(%p, %x, %p)\n", iface, dwDirection, ppenumFormatEtc);
1125
1126   hres = OleRegEnumFormatEtc(&This->clsid, dwDirection, ppenumFormatEtc);
1127
1128   return hres;
1129 }
1130
1131 /************************************************************************
1132  * DefaultHandler_DAdvise (IDataObject)
1133  *
1134  * The default handler's implementation of this method simply
1135  * delegates to the DataAdviseHolder.
1136  *
1137  * See Windows documentation for more details on IDataObject methods.
1138  */
1139 static HRESULT WINAPI DefaultHandler_DAdvise(
1140             IDataObject*     iface,
1141             FORMATETC*       pformatetc,
1142             DWORD            advf,
1143             IAdviseSink*     pAdvSink,
1144             DWORD*           pdwConnection)
1145 {
1146   HRESULT hres = S_OK;
1147   DefaultHandler *This = impl_from_IDataObject(iface);
1148
1149   TRACE("(%p, %p, %d, %p, %p)\n",
1150         iface, pformatetc, advf, pAdvSink, pdwConnection);
1151
1152   /* Make sure we have a data advise holder before we start. */
1153   if (!This->dataAdviseHolder)
1154   {
1155     hres = CreateDataAdviseHolder(&This->dataAdviseHolder);
1156     if (SUCCEEDED(hres) && This->pDataDelegate)
1157       DataAdviseHolder_OnConnect(This->dataAdviseHolder, This->pDataDelegate);
1158   }
1159
1160   if (SUCCEEDED(hres))
1161     hres = IDataAdviseHolder_Advise(This->dataAdviseHolder,
1162                                     iface,
1163                                     pformatetc,
1164                                     advf,
1165                                     pAdvSink,
1166                                     pdwConnection);
1167
1168   return hres;
1169 }
1170
1171 /************************************************************************
1172  * DefaultHandler_DUnadvise (IDataObject)
1173  *
1174  * The default handler's implementation of this method simply
1175  * delegates to the DataAdviseHolder.
1176  *
1177  * See Windows documentation for more details on IDataObject methods.
1178  */
1179 static HRESULT WINAPI DefaultHandler_DUnadvise(
1180             IDataObject*     iface,
1181             DWORD            dwConnection)
1182 {
1183   DefaultHandler *This = impl_from_IDataObject(iface);
1184
1185   TRACE("(%p, %d)\n", iface, dwConnection);
1186
1187   /*
1188    * If we don't have a data advise holder yet, it means that
1189    * we don't have any connections..
1190    */
1191   if (!This->dataAdviseHolder)
1192     return OLE_E_NOCONNECTION;
1193
1194   return IDataAdviseHolder_Unadvise(This->dataAdviseHolder,
1195                                     dwConnection);
1196 }
1197
1198 /************************************************************************
1199  * DefaultHandler_EnumDAdvise (IDataObject)
1200  *
1201  * The default handler's implementation of this method simply
1202  * delegates to the DataAdviseHolder.
1203  *
1204  * See Windows documentation for more details on IDataObject methods.
1205  */
1206 static HRESULT WINAPI DefaultHandler_EnumDAdvise(
1207             IDataObject*     iface,
1208             IEnumSTATDATA**  ppenumAdvise)
1209 {
1210   DefaultHandler *This = impl_from_IDataObject(iface);
1211
1212   TRACE("(%p, %p)\n", iface, ppenumAdvise);
1213
1214   if (!ppenumAdvise)
1215     return E_POINTER;
1216
1217   *ppenumAdvise = NULL;
1218
1219   /* If we have a data advise holder object, delegate. */
1220   if (This->dataAdviseHolder)
1221     return IDataAdviseHolder_EnumAdvise(This->dataAdviseHolder,
1222                                         ppenumAdvise);
1223
1224   return S_OK;
1225 }
1226
1227 /*********************************************************
1228  * Methods implementation for the IRunnableObject part
1229  * of the DefaultHandler class.
1230  */
1231
1232 /************************************************************************
1233  * DefaultHandler_IRunnableObject_QueryInterface (IUnknown)
1234  *
1235  * See Windows documentation for more details on IUnknown methods.
1236  */
1237 static HRESULT WINAPI DefaultHandler_IRunnableObject_QueryInterface(
1238             IRunnableObject*     iface,
1239             REFIID               riid,
1240             void**               ppvObject)
1241 {
1242   DefaultHandler *This = impl_from_IRunnableObject(iface);
1243
1244   return IUnknown_QueryInterface(This->outerUnknown, riid, ppvObject);
1245 }
1246
1247 /************************************************************************
1248  * DefaultHandler_IRunnableObject_AddRef (IUnknown)
1249  *
1250  * See Windows documentation for more details on IUnknown methods.
1251  */
1252 static ULONG WINAPI DefaultHandler_IRunnableObject_AddRef(
1253             IRunnableObject*     iface)
1254 {
1255   DefaultHandler *This = impl_from_IRunnableObject(iface);
1256
1257   return IUnknown_AddRef(This->outerUnknown);
1258 }
1259
1260 /************************************************************************
1261  * DefaultHandler_IRunnableObject_Release (IUnknown)
1262  *
1263  * See Windows documentation for more details on IUnknown methods.
1264  */
1265 static ULONG WINAPI DefaultHandler_IRunnableObject_Release(
1266             IRunnableObject*     iface)
1267 {
1268   DefaultHandler *This = impl_from_IRunnableObject(iface);
1269
1270   return IUnknown_Release(This->outerUnknown);
1271 }
1272
1273 /************************************************************************
1274  * DefaultHandler_GetRunningClass (IRunnableObject)
1275  *
1276  * See Windows documentation for more details on IRunnableObject methods.
1277  */
1278 static HRESULT WINAPI DefaultHandler_GetRunningClass(
1279             IRunnableObject*     iface,
1280             LPCLSID              lpClsid)
1281 {
1282   FIXME("()\n");
1283   return S_OK;
1284 }
1285
1286 static HRESULT WINAPI DefaultHandler_Run(
1287             IRunnableObject*     iface,
1288             IBindCtx*            pbc)
1289 {
1290   DefaultHandler *This = impl_from_IRunnableObject(iface);
1291   HRESULT hr;
1292
1293   FIXME("(%p): semi-stub\n", pbc);
1294
1295   /* already running? if so nothing to do */
1296   if (object_is_running(This))
1297     return S_OK;
1298
1299   hr = CoCreateInstance(&This->clsid, NULL, CLSCTX_LOCAL_SERVER,
1300                         &IID_IOleObject, (void **)&This->pOleDelegate);
1301   if (FAILED(hr))
1302     return hr;
1303
1304   hr = IOleObject_Advise(This->pOleDelegate,
1305                          (IAdviseSink *)&This->lpvtblIAdviseSink,
1306                          &This->dwAdvConn);
1307
1308   if (SUCCEEDED(hr) && This->clientSite)
1309     hr = IOleObject_SetClientSite(This->pOleDelegate, This->clientSite);
1310
1311   if (SUCCEEDED(hr))
1312   {
1313     IOleObject_QueryInterface(This->pOleDelegate, &IID_IPersistStorage,
1314                               (void **)&This->pPSDelegate);
1315     if (This->pPSDelegate)
1316     {
1317       if(This->storage_state == storage_state_initialised)
1318         hr = IPersistStorage_InitNew(This->pPSDelegate, This->storage);
1319       else if(This->storage_state == storage_state_loaded)
1320         hr = IPersistStorage_Load(This->pPSDelegate, This->storage);
1321     }
1322   }
1323
1324   if (SUCCEEDED(hr) && This->containerApp)
1325     hr = IOleObject_SetHostNames(This->pOleDelegate, This->containerApp,
1326                                  This->containerObj);
1327
1328   /* FIXME: do more stuff here:
1329    * - IOleObject_GetMiscStatus
1330    * - IOleObject_GetMoniker
1331    * - IOleCache_OnRun
1332    */
1333
1334   if (SUCCEEDED(hr))
1335     hr = IOleObject_QueryInterface(This->pOleDelegate, &IID_IDataObject,
1336                                    (void **)&This->pDataDelegate);
1337
1338   if (SUCCEEDED(hr) && This->dataAdviseHolder)
1339     hr = DataAdviseHolder_OnConnect(This->dataAdviseHolder, This->pDataDelegate);
1340
1341   if (FAILED(hr))
1342     DefaultHandler_Stop(This);
1343
1344   return hr;
1345 }
1346
1347 /************************************************************************
1348  * DefaultHandler_IsRunning (IRunnableObject)
1349  *
1350  * See Windows documentation for more details on IRunnableObject methods.
1351  */
1352 static BOOL    WINAPI DefaultHandler_IsRunning(
1353             IRunnableObject*     iface)
1354 {
1355   DefaultHandler *This = impl_from_IRunnableObject(iface);
1356
1357   TRACE("()\n");
1358
1359   if (This->pOleDelegate)
1360     return TRUE;
1361   else
1362     return FALSE;
1363 }
1364
1365 /************************************************************************
1366  * DefaultHandler_LockRunning (IRunnableObject)
1367  *
1368  * See Windows documentation for more details on IRunnableObject methods.
1369  */
1370 static HRESULT WINAPI DefaultHandler_LockRunning(
1371             IRunnableObject*     iface,
1372             BOOL                 fLock,
1373             BOOL                 fLastUnlockCloses)
1374 {
1375   FIXME("()\n");
1376   return S_OK;
1377 }
1378
1379 /************************************************************************
1380  * DefaultHandler_SetContainedObject (IRunnableObject)
1381  *
1382  * See Windows documentation for more details on IRunnableObject methods.
1383  */
1384 static HRESULT WINAPI DefaultHandler_SetContainedObject(
1385             IRunnableObject*     iface,
1386             BOOL                 fContained)
1387 {
1388   FIXME("()\n");
1389   return S_OK;
1390 }
1391
1392 static HRESULT WINAPI DefaultHandler_IAdviseSink_QueryInterface(
1393     IAdviseSink *iface,
1394     REFIID riid,
1395     void **ppvObject)
1396 {
1397     if (IsEqualIID(riid, &IID_IUnknown) ||
1398         IsEqualIID(riid, &IID_IAdviseSink))
1399     {
1400         *ppvObject = iface;
1401         IAdviseSink_AddRef(iface);
1402         return S_OK;
1403     }
1404
1405     return E_NOINTERFACE;
1406 }
1407
1408 static ULONG WINAPI DefaultHandler_IAdviseSink_AddRef(
1409     IAdviseSink *iface)
1410 {
1411     DefaultHandler *This = impl_from_IAdviseSink(iface);
1412
1413     return IUnknown_AddRef((IUnknown *)&This->lpvtblIUnknown);
1414 }
1415
1416 static ULONG WINAPI DefaultHandler_IAdviseSink_Release(
1417             IAdviseSink *iface)
1418 {
1419     DefaultHandler *This = impl_from_IAdviseSink(iface);
1420
1421     return IUnknown_Release((IUnknown *)&This->lpvtblIUnknown);
1422 }
1423
1424 static void WINAPI DefaultHandler_IAdviseSink_OnDataChange(
1425     IAdviseSink *iface,
1426     FORMATETC *pFormatetc,
1427     STGMEDIUM *pStgmed)
1428 {
1429     FIXME(": stub\n");
1430 }
1431
1432 static void WINAPI DefaultHandler_IAdviseSink_OnViewChange(
1433     IAdviseSink *iface,
1434     DWORD dwAspect,
1435     LONG lindex)
1436 {
1437     FIXME(": stub\n");
1438 }
1439
1440 static void WINAPI DefaultHandler_IAdviseSink_OnRename(
1441     IAdviseSink *iface,
1442     IMoniker *pmk)
1443 {
1444     DefaultHandler *This = impl_from_IAdviseSink(iface);
1445
1446     TRACE("(%p)\n", pmk);
1447
1448     if (This->oleAdviseHolder)
1449         IOleAdviseHolder_SendOnRename(This->oleAdviseHolder, pmk);
1450 }
1451
1452 static void WINAPI DefaultHandler_IAdviseSink_OnSave(
1453     IAdviseSink *iface)
1454 {
1455     DefaultHandler *This = impl_from_IAdviseSink(iface);
1456
1457     TRACE("()\n");
1458
1459     if (This->oleAdviseHolder)
1460         IOleAdviseHolder_SendOnSave(This->oleAdviseHolder);
1461 }
1462
1463 static void WINAPI DefaultHandler_IAdviseSink_OnClose(
1464     IAdviseSink *iface)
1465 {
1466     DefaultHandler *This = impl_from_IAdviseSink(iface);
1467
1468     TRACE("()\n");
1469
1470     if (This->oleAdviseHolder)
1471         IOleAdviseHolder_SendOnClose(This->oleAdviseHolder);
1472
1473     DefaultHandler_Stop(This);
1474 }
1475
1476
1477 /************************************************************************
1478  * DefaultHandler_IPersistStorage_QueryInterface
1479  *
1480  */
1481 static HRESULT WINAPI DefaultHandler_IPersistStorage_QueryInterface(
1482             IPersistStorage*     iface,
1483             REFIID               riid,
1484             void**               ppvObject)
1485 {
1486   DefaultHandler *This = impl_from_IPersistStorage(iface);
1487
1488   return IUnknown_QueryInterface(This->outerUnknown, riid, ppvObject);
1489 }
1490
1491 /************************************************************************
1492  * DefaultHandler_IPersistStorage_AddRef
1493  *
1494  */
1495 static ULONG WINAPI DefaultHandler_IPersistStorage_AddRef(
1496             IPersistStorage*     iface)
1497 {
1498   DefaultHandler *This = impl_from_IPersistStorage(iface);
1499
1500   return IUnknown_AddRef(This->outerUnknown);
1501 }
1502
1503 /************************************************************************
1504  * DefaultHandler_IPersistStorage_Release
1505  *
1506  */
1507 static ULONG WINAPI DefaultHandler_IPersistStorage_Release(
1508             IPersistStorage*     iface)
1509 {
1510   DefaultHandler *This = impl_from_IPersistStorage(iface);
1511
1512   return IUnknown_Release(This->outerUnknown);
1513 }
1514
1515 /************************************************************************
1516  * DefaultHandler_IPersistStorage_GetClassID
1517  *
1518  */
1519 static HRESULT WINAPI DefaultHandler_IPersistStorage_GetClassID(
1520             IPersistStorage*     iface,
1521             CLSID*               clsid)
1522 {
1523     DefaultHandler *This = impl_from_IPersistStorage(iface);
1524     HRESULT hr;
1525
1526     TRACE("(%p)->(%p)\n", iface, clsid);
1527
1528     if(object_is_running(This))
1529         hr = IPersistStorage_GetClassID(This->pPSDelegate, clsid);
1530     else
1531         hr = IPersistStorage_GetClassID(This->dataCache_PersistStg, clsid);
1532
1533     return hr;
1534 }
1535
1536 /************************************************************************
1537  * DefaultHandler_IPersistStorage_IsDirty
1538  *
1539  */
1540 static HRESULT WINAPI DefaultHandler_IPersistStorage_IsDirty(
1541             IPersistStorage*     iface)
1542 {
1543     DefaultHandler *This = impl_from_IPersistStorage(iface);
1544     HRESULT hr;
1545
1546     TRACE("(%p)\n", iface);
1547
1548     hr = IPersistStorage_IsDirty(This->dataCache_PersistStg);
1549     if(hr != S_FALSE) return hr;
1550
1551     if(object_is_running(This))
1552         hr = IPersistStorage_IsDirty(This->pPSDelegate);
1553
1554     return hr;
1555 }
1556
1557 /***********************************************************************
1558  *   init_ole_stream
1559  *
1560  * Creates the '\1Ole' stream.
1561  * The format of this stream is as follows:
1562  *
1563  * DWORD Version == 0x02000001
1564  * DWORD Flags - low bit set indicates the object is a link otherwise it's embedded.
1565  * DWORD LinkupdateOption - [MS-OLEDS describes this as an implementation specific hint
1566  *                           supplied by the app that creates the data structure.  May be
1567  *                           ignored on processing].
1568  *
1569  * DWORD Reserved == 0
1570  * DWORD MonikerStreamSize - size of the rest of the data (ie CLSID + moniker stream data).
1571  * CLSID clsid - class id of object capable of processing the moniker
1572  * BYTE  data[] - moniker data for a link
1573  */
1574
1575 static const WCHAR OleStream[] = {1,'O','l','e',0};
1576 typedef struct
1577 {
1578     DWORD version;
1579     DWORD flags;
1580     DWORD link_update_opt;
1581     DWORD res;
1582     DWORD moniker_size;
1583 } ole_stream_header_t;
1584 static const DWORD ole_stream_version = 0x02000001;
1585
1586 static void init_ole_stream(IStorage *storage)
1587 {
1588     HRESULT hr;
1589     IStream *stream;
1590
1591     hr = IStorage_CreateStream(storage, OleStream, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stream);
1592     if(SUCCEEDED(hr))
1593     {
1594         DWORD written;
1595         ole_stream_header_t header;
1596
1597         header.version         = ole_stream_version;
1598         header.flags           = 0;
1599         header.link_update_opt = 0;
1600         header.res             = 0;
1601         header.moniker_size    = 0;
1602
1603         IStream_Write(stream, &header, sizeof(header), &written);
1604         IStream_Release(stream);
1605     }
1606     return;
1607 }
1608
1609 static HRESULT load_ole_stream(DefaultHandler *This, IStorage *storage)
1610 {
1611     IStream *stream;
1612     HRESULT hr;
1613
1614     hr = IStorage_OpenStream(storage, OleStream, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stream);
1615
1616     if(SUCCEEDED(hr))
1617     {
1618         DWORD read;
1619         ole_stream_header_t header;
1620
1621         hr = IStream_Read(stream, &header, sizeof(header), &read);
1622         if(hr == S_OK && read == sizeof(header) && header.version == ole_stream_version)
1623         {
1624             if(header.flags & 1)
1625             {
1626                 /* FIXME: Read the moniker and deal with the link */
1627                 FIXME("Linked objects are not supported yet\n");
1628             }
1629         }
1630         else
1631         {
1632             WARN("Incorrect OleStream header\n");
1633             hr = DV_E_CLIPFORMAT;
1634         }
1635         IStream_Release(stream);
1636     }
1637     else
1638     {
1639         init_ole_stream(storage);
1640         hr = S_OK;
1641     }
1642     return hr;
1643 }
1644
1645 /************************************************************************
1646  * DefaultHandler_IPersistStorage_InitNew
1647  *
1648  */
1649 static HRESULT WINAPI DefaultHandler_IPersistStorage_InitNew(
1650            IPersistStorage*     iface,
1651            IStorage*            pStg)
1652 {
1653     DefaultHandler *This = impl_from_IPersistStorage(iface);
1654     HRESULT hr;
1655
1656     TRACE("(%p)->(%p)\n", iface, pStg);
1657     init_ole_stream(pStg);
1658
1659     hr = IPersistStorage_InitNew(This->dataCache_PersistStg, pStg);
1660
1661     if(SUCCEEDED(hr) && object_is_running(This))
1662         hr = IPersistStorage_InitNew(This->pPSDelegate, pStg);
1663
1664     if(SUCCEEDED(hr))
1665     {
1666         IStorage_AddRef(pStg);
1667         This->storage = pStg;
1668         This->storage_state = storage_state_initialised;
1669     }
1670
1671     return hr;
1672 }
1673
1674
1675 /************************************************************************
1676  * DefaultHandler_IPersistStorage_Load
1677  *
1678  */
1679 static HRESULT WINAPI DefaultHandler_IPersistStorage_Load(
1680            IPersistStorage*     iface,
1681            IStorage*            pStg)
1682 {
1683     DefaultHandler *This = impl_from_IPersistStorage(iface);
1684     HRESULT hr;
1685
1686     TRACE("(%p)->(%p)\n", iface, pStg);
1687
1688     hr = load_ole_stream(This, pStg);
1689
1690     if(SUCCEEDED(hr))
1691         hr = IPersistStorage_Load(This->dataCache_PersistStg, pStg);
1692
1693     if(SUCCEEDED(hr) && object_is_running(This))
1694         hr = IPersistStorage_Load(This->pPSDelegate, pStg);
1695
1696     if(SUCCEEDED(hr))
1697     {
1698         IStorage_AddRef(pStg);
1699         This->storage = pStg;
1700         This->storage_state = storage_state_loaded;
1701     }
1702     return hr;
1703 }
1704
1705
1706 /************************************************************************
1707  * DefaultHandler_IPersistStorage_Save
1708  *
1709  */
1710 static HRESULT WINAPI DefaultHandler_IPersistStorage_Save(
1711            IPersistStorage*     iface,
1712            IStorage*            pStgSave,
1713            BOOL                 fSameAsLoad)
1714 {
1715     DefaultHandler *This = impl_from_IPersistStorage(iface);
1716     HRESULT hr;
1717
1718     TRACE("(%p)->(%p, %d)\n", iface, pStgSave, fSameAsLoad);
1719
1720     hr = IPersistStorage_Save(This->dataCache_PersistStg, pStgSave, fSameAsLoad);
1721     if(SUCCEEDED(hr) && object_is_running(This))
1722         hr = IPersistStorage_Save(This->pPSDelegate, pStgSave, fSameAsLoad);
1723
1724     return hr;
1725 }
1726
1727
1728 /************************************************************************
1729  * DefaultHandler_IPersistStorage_SaveCompleted
1730  *
1731  */
1732 static HRESULT WINAPI DefaultHandler_IPersistStorage_SaveCompleted(
1733            IPersistStorage*     iface,
1734            IStorage*            pStgNew)
1735 {
1736     DefaultHandler *This = impl_from_IPersistStorage(iface);
1737     HRESULT hr;
1738
1739     TRACE("(%p)->(%p)\n", iface, pStgNew);
1740
1741     hr = IPersistStorage_SaveCompleted(This->dataCache_PersistStg, pStgNew);
1742
1743     if(SUCCEEDED(hr) && object_is_running(This))
1744         hr = IPersistStorage_SaveCompleted(This->pPSDelegate, pStgNew);
1745
1746     if(pStgNew)
1747     {
1748         IStorage_AddRef(pStgNew);
1749         if(This->storage) IStorage_Release(This->storage);
1750         This->storage = pStgNew;
1751         This->storage_state = storage_state_loaded;
1752     }
1753
1754     return hr;
1755 }
1756
1757
1758 /************************************************************************
1759  * DefaultHandler_IPersistStorage_HandsOffStorage
1760  *
1761  */
1762 static HRESULT WINAPI DefaultHandler_IPersistStorage_HandsOffStorage(
1763             IPersistStorage*     iface)
1764 {
1765     DefaultHandler *This = impl_from_IPersistStorage(iface);
1766     HRESULT hr;
1767
1768     TRACE("(%p)\n", iface);
1769
1770     hr = IPersistStorage_HandsOffStorage(This->dataCache_PersistStg);
1771
1772     if(SUCCEEDED(hr) && object_is_running(This))
1773         hr = IPersistStorage_HandsOffStorage(This->pPSDelegate);
1774
1775     if(This->storage) IStorage_Release(This->storage);
1776     This->storage = NULL;
1777     This->storage_state = storage_state_uninitialised;
1778
1779     return hr;
1780 }
1781
1782
1783 /*
1784  * Virtual function tables for the DefaultHandler class.
1785  */
1786 static const IOleObjectVtbl DefaultHandler_IOleObject_VTable =
1787 {
1788   DefaultHandler_QueryInterface,
1789   DefaultHandler_AddRef,
1790   DefaultHandler_Release,
1791   DefaultHandler_SetClientSite,
1792   DefaultHandler_GetClientSite,
1793   DefaultHandler_SetHostNames,
1794   DefaultHandler_Close,
1795   DefaultHandler_SetMoniker,
1796   DefaultHandler_GetMoniker,
1797   DefaultHandler_InitFromData,
1798   DefaultHandler_GetClipboardData,
1799   DefaultHandler_DoVerb,
1800   DefaultHandler_EnumVerbs,
1801   DefaultHandler_Update,
1802   DefaultHandler_IsUpToDate,
1803   DefaultHandler_GetUserClassID,
1804   DefaultHandler_GetUserType,
1805   DefaultHandler_SetExtent,
1806   DefaultHandler_GetExtent,
1807   DefaultHandler_Advise,
1808   DefaultHandler_Unadvise,
1809   DefaultHandler_EnumAdvise,
1810   DefaultHandler_GetMiscStatus,
1811   DefaultHandler_SetColorScheme
1812 };
1813
1814 static const IUnknownVtbl DefaultHandler_NDIUnknown_VTable =
1815 {
1816   DefaultHandler_NDIUnknown_QueryInterface,
1817   DefaultHandler_NDIUnknown_AddRef,
1818   DefaultHandler_NDIUnknown_Release,
1819 };
1820
1821 static const IDataObjectVtbl DefaultHandler_IDataObject_VTable =
1822 {
1823   DefaultHandler_IDataObject_QueryInterface,
1824   DefaultHandler_IDataObject_AddRef,
1825   DefaultHandler_IDataObject_Release,
1826   DefaultHandler_GetData,
1827   DefaultHandler_GetDataHere,
1828   DefaultHandler_QueryGetData,
1829   DefaultHandler_GetCanonicalFormatEtc,
1830   DefaultHandler_SetData,
1831   DefaultHandler_EnumFormatEtc,
1832   DefaultHandler_DAdvise,
1833   DefaultHandler_DUnadvise,
1834   DefaultHandler_EnumDAdvise
1835 };
1836
1837 static const IRunnableObjectVtbl DefaultHandler_IRunnableObject_VTable =
1838 {
1839   DefaultHandler_IRunnableObject_QueryInterface,
1840   DefaultHandler_IRunnableObject_AddRef,
1841   DefaultHandler_IRunnableObject_Release,
1842   DefaultHandler_GetRunningClass,
1843   DefaultHandler_Run,
1844   DefaultHandler_IsRunning,
1845   DefaultHandler_LockRunning,
1846   DefaultHandler_SetContainedObject
1847 };
1848
1849 static const IAdviseSinkVtbl DefaultHandler_IAdviseSink_VTable =
1850 {
1851   DefaultHandler_IAdviseSink_QueryInterface,
1852   DefaultHandler_IAdviseSink_AddRef,
1853   DefaultHandler_IAdviseSink_Release,
1854   DefaultHandler_IAdviseSink_OnDataChange,
1855   DefaultHandler_IAdviseSink_OnViewChange,
1856   DefaultHandler_IAdviseSink_OnRename,
1857   DefaultHandler_IAdviseSink_OnSave,
1858   DefaultHandler_IAdviseSink_OnClose
1859 };
1860
1861 static const IPersistStorageVtbl DefaultHandler_IPersistStorage_VTable =
1862 {
1863   DefaultHandler_IPersistStorage_QueryInterface,
1864   DefaultHandler_IPersistStorage_AddRef,
1865   DefaultHandler_IPersistStorage_Release,
1866   DefaultHandler_IPersistStorage_GetClassID,
1867   DefaultHandler_IPersistStorage_IsDirty,
1868   DefaultHandler_IPersistStorage_InitNew,
1869   DefaultHandler_IPersistStorage_Load,
1870   DefaultHandler_IPersistStorage_Save,
1871   DefaultHandler_IPersistStorage_SaveCompleted,
1872   DefaultHandler_IPersistStorage_HandsOffStorage
1873 };
1874
1875 /*********************************************************
1876  * Methods implementation for the DefaultHandler class.
1877  */
1878 static DefaultHandler* DefaultHandler_Construct(
1879   REFCLSID  clsid,
1880   LPUNKNOWN pUnkOuter)
1881 {
1882   DefaultHandler* This = NULL;
1883   HRESULT hr;
1884
1885   This = HeapAlloc(GetProcessHeap(), 0, sizeof(DefaultHandler));
1886
1887   if (!This)
1888     return This;
1889
1890   This->lpVtbl = &DefaultHandler_IOleObject_VTable;
1891   This->lpvtblIUnknown = &DefaultHandler_NDIUnknown_VTable;
1892   This->lpvtblIDataObject = &DefaultHandler_IDataObject_VTable;
1893   This->lpvtblIRunnableObject = &DefaultHandler_IRunnableObject_VTable;
1894   This->lpvtblIAdviseSink = &DefaultHandler_IAdviseSink_VTable;
1895   This->lpvtblIPersistStorage = &DefaultHandler_IPersistStorage_VTable;
1896
1897   /*
1898    * Start with one reference count. The caller of this function
1899    * must release the interface pointer when it is done.
1900    */
1901   This->ref = 1;
1902
1903   /*
1904    * Initialize the outer unknown
1905    * We don't keep a reference on the outer unknown since, the way
1906    * aggregation works, our lifetime is at least as large as its
1907    * lifetime.
1908    */
1909   if (!pUnkOuter)
1910     pUnkOuter = (IUnknown*)&This->lpvtblIUnknown;
1911
1912   This->outerUnknown = pUnkOuter;
1913
1914   /*
1915    * Create a datacache object.
1916    * We aggregate with the datacache. Make sure we pass our outer
1917    * unknown as the datacache's outer unknown.
1918    */
1919   hr = CreateDataCache(This->outerUnknown,
1920                        clsid,
1921                        &IID_IUnknown,
1922                        (void**)&This->dataCache);
1923   if(SUCCEEDED(hr))
1924     hr = IUnknown_QueryInterface(This->dataCache, &IID_IPersistStorage, (void**)&This->dataCache_PersistStg);
1925   if(FAILED(hr))
1926     ERR("Unexpected error creating data cache\n");
1927
1928   This->clsid = *clsid;
1929   This->clientSite = NULL;
1930   This->oleAdviseHolder = NULL;
1931   This->dataAdviseHolder = NULL;
1932   This->containerApp = NULL;
1933   This->containerObj = NULL;
1934   This->pOleDelegate = NULL;
1935   This->pPSDelegate = NULL;
1936   This->pDataDelegate = NULL;
1937
1938   This->dwAdvConn = 0;
1939   This->storage = NULL;
1940   This->storage_state = storage_state_uninitialised;
1941
1942   return This;
1943 }
1944
1945 static void DefaultHandler_Destroy(
1946   DefaultHandler* This)
1947 {
1948   /* release delegates */
1949   DefaultHandler_Stop(This);
1950
1951   HeapFree( GetProcessHeap(), 0, This->containerApp );
1952   This->containerApp = NULL;
1953   HeapFree( GetProcessHeap(), 0, This->containerObj );
1954   This->containerObj = NULL;
1955
1956   if (This->dataCache)
1957   {
1958     IPersistStorage_Release(This->dataCache_PersistStg);
1959     IUnknown_Release(This->dataCache);
1960     This->dataCache_PersistStg = NULL;
1961     This->dataCache = NULL;
1962   }
1963
1964   if (This->clientSite)
1965   {
1966     IOleClientSite_Release(This->clientSite);
1967     This->clientSite = NULL;
1968   }
1969
1970   if (This->oleAdviseHolder)
1971   {
1972     IOleAdviseHolder_Release(This->oleAdviseHolder);
1973     This->oleAdviseHolder = NULL;
1974   }
1975
1976   if (This->dataAdviseHolder)
1977   {
1978     IDataAdviseHolder_Release(This->dataAdviseHolder);
1979     This->dataAdviseHolder = NULL;
1980   }
1981
1982   if (This->storage)
1983   {
1984     IStorage_Release(This->storage);
1985     This->storage = NULL;
1986   }
1987
1988   HeapFree(GetProcessHeap(), 0, This);
1989 }
1990
1991 /******************************************************************************
1992  * OleCreateDefaultHandler [OLE32.@]
1993  */
1994 HRESULT WINAPI OleCreateDefaultHandler(
1995   REFCLSID  clsid,
1996   LPUNKNOWN pUnkOuter,
1997   REFIID    riid,
1998   LPVOID*   ppvObj)
1999 {
2000   DefaultHandler* newHandler = NULL;
2001   HRESULT         hr         = S_OK;
2002
2003   TRACE("(%s, %p, %s, %p)\n", debugstr_guid(clsid), pUnkOuter, debugstr_guid(riid), ppvObj);
2004
2005   if (!ppvObj)
2006     return E_POINTER;
2007
2008   *ppvObj = NULL;
2009
2010   /*
2011    * If This handler is constructed for aggregation, make sure
2012    * the caller is requesting the IUnknown interface.
2013    * This is necessary because it's the only time the non-delegating
2014    * IUnknown pointer can be returned to the outside.
2015    */
2016   if (pUnkOuter && !IsEqualIID(&IID_IUnknown, riid))
2017     return CLASS_E_NOAGGREGATION;
2018
2019   /*
2020    * Try to construct a new instance of the class.
2021    */
2022   newHandler = DefaultHandler_Construct(clsid, pUnkOuter);
2023
2024   if (!newHandler)
2025     return E_OUTOFMEMORY;
2026
2027   /*
2028    * Make sure it supports the interface required by the caller.
2029    */
2030   hr = IUnknown_QueryInterface((IUnknown*)&newHandler->lpvtblIUnknown, riid, ppvObj);
2031
2032   /*
2033    * Release the reference obtained in the constructor. If
2034    * the QueryInterface was unsuccessful, it will free the class.
2035    */
2036   IUnknown_Release((IUnknown*)&newHandler->lpvtblIUnknown);
2037
2038   return hr;
2039 }