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