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