source: trunk/src/ole32/oleobj.cpp@ 1036

Last change on this file since 1036 was 1033, checked in by davidr, 26 years ago

Ported remaining files pertaining to OLE32 from WINE
File size: 14.8 KB
Line 
1/* $Id: oleobj.cpp,v 1.1 1999-09-24 21:49:44 davidr Exp $ */
2/*
3 * OLE2 COM objects
4 *
5 * 21/9/99
6 *
7 * Copyright 1999 David J. Raison
8 *
9 * Direct port of Wine Implementation
10 *
11 * Copyright 1998 Eric Kohl
12 * Copyright 1999 Francis Beaudet
13 */
14
15#include "ole32.h"
16#include "debugtools.h"
17
18DEFAULT_DEBUG_CHANNEL(ole)
19
20
21/**************************************************************************
22 * OleAdviseHolderImpl Implementation
23 */
24typedef struct OleAdviseHolderImpl
25{
26 ICOM_VTABLE(IOleAdviseHolder)* lpvtbl;
27
28 DWORD ref;
29
30 DWORD maxSinks;
31 IAdviseSink** arrayOfSinks;
32
33} OleAdviseHolderImpl;
34
35static LPOLEADVISEHOLDER OleAdviseHolderImpl_Constructor();
36static void OleAdviseHolderImpl_Destructor(OleAdviseHolderImpl* ptrToDestroy);
37static HRESULT WINAPI OleAdviseHolderImpl_QueryInterface(LPOLEADVISEHOLDER,REFIID,LPVOID*);
38static ULONG WINAPI OleAdviseHolderImpl_AddRef(LPOLEADVISEHOLDER);
39static ULONG WINAPI OleAdviseHolderImpl_Release(LPOLEADVISEHOLDER);
40static HRESULT WINAPI OleAdviseHolderImpl_Advise(LPOLEADVISEHOLDER, IAdviseSink*, DWORD*);
41static HRESULT WINAPI OleAdviseHolderImpl_Unadvise (LPOLEADVISEHOLDER, DWORD);
42static HRESULT WINAPI OleAdviseHolderImpl_EnumAdvise (LPOLEADVISEHOLDER, IEnumSTATDATA **);
43static HRESULT WINAPI OleAdviseHolderImpl_SendOnRename (LPOLEADVISEHOLDER, IMoniker *);
44static HRESULT WINAPI OleAdviseHolderImpl_SendOnSave (LPOLEADVISEHOLDER);
45static HRESULT WINAPI OleAdviseHolderImpl_SendOnClose (LPOLEADVISEHOLDER);
46
47
48/**************************************************************************
49 * OleAdviseHolderImpl_VTable
50 */
51static struct ICOM_VTABLE(IOleAdviseHolder) oahvt =
52{
53 OleAdviseHolderImpl_QueryInterface,
54 OleAdviseHolderImpl_AddRef,
55 OleAdviseHolderImpl_Release,
56 OleAdviseHolderImpl_Advise,
57 OleAdviseHolderImpl_Unadvise,
58 OleAdviseHolderImpl_EnumAdvise,
59 OleAdviseHolderImpl_SendOnRename,
60 OleAdviseHolderImpl_SendOnSave,
61 OleAdviseHolderImpl_SendOnClose
62};
63
64/**************************************************************************
65 * OleAdviseHolderImpl_Constructor
66 */
67
68static LPOLEADVISEHOLDER OleAdviseHolderImpl_Constructor()
69{
70 OleAdviseHolderImpl* lpoah;
71 DWORD index;
72
73 lpoah= (OleAdviseHolderImpl*)HeapAlloc(GetProcessHeap(),
74 0,
75 sizeof(OleAdviseHolderImpl));
76
77 lpoah->lpvtbl = &oahvt;
78 lpoah->ref = 1;
79 lpoah->maxSinks = 10;
80 lpoah->arrayOfSinks = (IAdviseSink **)HeapAlloc(GetProcessHeap(),
81 0,
82 lpoah->maxSinks * sizeof(IAdviseSink*));
83
84 for (index = 0; index < lpoah->maxSinks; index++)
85 lpoah->arrayOfSinks[index]=0;
86
87 return (LPOLEADVISEHOLDER)lpoah;
88}
89
90/**************************************************************************
91 * OleAdviseHolderImpl_Destructor
92 */
93static void OleAdviseHolderImpl_Destructor(
94 OleAdviseHolderImpl* ptrToDestroy)
95{
96 DWORD index;
97
98 for (index = 0; index < ptrToDestroy->maxSinks; index++)
99 {
100 if (ptrToDestroy->arrayOfSinks[index]!=0)
101 {
102 IAdviseSink_Release(ptrToDestroy->arrayOfSinks[index]);
103 ptrToDestroy->arrayOfSinks[index] = NULL;
104 }
105 }
106
107 HeapFree(GetProcessHeap(),
108 0,
109 ptrToDestroy->arrayOfSinks);
110
111
112 HeapFree(GetProcessHeap(),
113 0,
114 ptrToDestroy);
115}
116
117/**************************************************************************
118 * OleAdviseHolderImpl_QueryInterface
119 */
120static HRESULT WINAPI OleAdviseHolderImpl_QueryInterface(
121 LPOLEADVISEHOLDER iface,
122 REFIID riid,
123 LPVOID* ppvObj)
124{
125 ICOM_THIS(OleAdviseHolderImpl, iface);
126
127 /*
128 * Sanity check
129 */
130 if (ppvObj==NULL)
131 return E_POINTER;
132
133 *ppvObj = NULL;
134
135 if (IsEqualIID(riid, &IID_IUnknown))
136 {
137 /* IUnknown */
138 *ppvObj = This;
139 }
140 else if(IsEqualIID(riid, &IID_IOleAdviseHolder))
141 {
142 /* IOleAdviseHolder */
143 *ppvObj = (IOleAdviseHolder*) This;
144 }
145
146 if(*ppvObj == NULL)
147 return E_NOINTERFACE;
148
149 /*
150 * A successful QI always increments the reference count.
151 */
152 IUnknown_AddRef((IUnknown*)*ppvObj);
153
154 return S_OK;
155}
156
157/******************************************************************************
158 * OleAdviseHolderImpl_AddRef
159 */
160static ULONG WINAPI OleAdviseHolderImpl_AddRef(
161 LPOLEADVISEHOLDER iface)
162{
163 ICOM_THIS(OleAdviseHolderImpl, iface);
164
165 return ++(This->ref);
166}
167
168/******************************************************************************
169 * OleAdviseHolderImpl_Release
170 */
171static ULONG WINAPI OleAdviseHolderImpl_Release(
172 LPOLEADVISEHOLDER iface)
173{
174 ICOM_THIS(OleAdviseHolderImpl, iface);
175
176 This->ref--;
177
178 if (This->ref == 0)
179 {
180 OleAdviseHolderImpl_Destructor(This);
181
182 return 0;
183 }
184
185 return This->ref;
186}
187
188/******************************************************************************
189 * OleAdviseHolderImpl_Advise
190 */
191static HRESULT WINAPI OleAdviseHolderImpl_Advise(
192 LPOLEADVISEHOLDER iface,
193 IAdviseSink* pAdvise,
194 DWORD* pdwConnection)
195{
196 DWORD index;
197
198 ICOM_THIS(OleAdviseHolderImpl, iface);
199
200 TRACE("(%p, %p, %p)\n", This, pAdvise, pdwConnection);
201
202 /*
203 * Sanity check
204 */
205 if (pdwConnection==NULL)
206 return E_POINTER;
207
208 *pdwConnection = 0;
209
210 /*
211 * Find a free spot in the array.
212 */
213 for (index = 0; index < This->maxSinks; index++)
214 {
215 if (This->arrayOfSinks[index]==NULL)
216 break;
217 }
218
219 /*
220 * If the array is full, we need to grow it.
221 */
222 if (index == This->maxSinks)
223 {
224 DWORD i;
225
226 This->maxSinks+=10;
227
228 This->arrayOfSinks = (IAdviseSink **)HeapReAlloc(GetProcessHeap(),
229 0,
230 This->arrayOfSinks,
231 This->maxSinks*sizeof(IAdviseSink*));
232
233 for (i=index;i < This->maxSinks; i++)
234 This->arrayOfSinks[i]=0;
235 }
236
237 /*
238 * Store the new sink
239 */
240 This->arrayOfSinks[index] = pAdvise;
241
242 if (This->arrayOfSinks[index]!=NULL)
243 IAdviseSink_AddRef(This->arrayOfSinks[index]);
244
245 /*
246 * Return the index as the cookie.
247 * Since 0 is not a valid cookie, we will increment by
248 * 1 the index in the table.
249 */
250 *pdwConnection = index+1;
251
252 return S_OK;
253}
254
255/******************************************************************************
256 * OleAdviseHolderImpl_Unadvise
257 */
258static HRESULT WINAPI OleAdviseHolderImpl_Unadvise(
259 LPOLEADVISEHOLDER iface,
260 DWORD dwConnection)
261{
262 ICOM_THIS(OleAdviseHolderImpl, iface);
263
264 TRACE("(%p, %lu)\n", This, dwConnection);
265
266 /*
267 * So we don't return 0 as a cookie, the index was
268 * incremented by 1 in OleAdviseHolderImpl_Advise
269 * we have to compensate.
270 */
271 dwConnection--;
272
273 /*
274 * Check for invalid cookies.
275 */
276 if ( (dwConnection < 0) ||
277 (dwConnection >= This->maxSinks) )
278 return OLE_E_NOCONNECTION;
279
280 if (This->arrayOfSinks[dwConnection] == NULL)
281 return OLE_E_NOCONNECTION;
282
283 /*
284 * Release the sink and mark the spot in the list as free.
285 */
286 IAdviseSink_Release(This->arrayOfSinks[dwConnection]);
287 This->arrayOfSinks[dwConnection] = NULL;
288
289 return S_OK;
290}
291
292/******************************************************************************
293 * OleAdviseHolderImpl_EnumAdvise
294 */
295static HRESULT WINAPI
296OleAdviseHolderImpl_EnumAdvise (LPOLEADVISEHOLDER iface, IEnumSTATDATA **ppenumAdvise)
297{
298 ICOM_THIS(OleAdviseHolderImpl, iface);
299 FIXME("(%p)->(%p)\n", This, ppenumAdvise);
300
301 *ppenumAdvise = NULL;
302
303 return S_OK;
304}
305
306/******************************************************************************
307 * OleAdviseHolderImpl_SendOnRename
308 */
309static HRESULT WINAPI
310OleAdviseHolderImpl_SendOnRename (LPOLEADVISEHOLDER iface, IMoniker *pmk)
311{
312 ICOM_THIS(OleAdviseHolderImpl, iface);
313 FIXME("(%p)->(%p)\n", This, pmk);
314
315
316 return S_OK;
317}
318
319/******************************************************************************
320 * OleAdviseHolderImpl_SendOnSave
321 */
322static HRESULT WINAPI
323OleAdviseHolderImpl_SendOnSave (LPOLEADVISEHOLDER iface)
324{
325 ICOM_THIS(OleAdviseHolderImpl, iface);
326 FIXME("(%p)\n", This);
327
328
329 return S_OK;
330}
331
332/******************************************************************************
333 * OleAdviseHolderImpl_SendOnClose
334 */
335static HRESULT WINAPI
336OleAdviseHolderImpl_SendOnClose (LPOLEADVISEHOLDER iface)
337{
338 ICOM_THIS(OleAdviseHolderImpl, iface);
339 FIXME("(%p)\n", This);
340
341
342 return S_OK;
343}
344
345/**************************************************************************
346 * DataAdviseHolder Implementation
347 */
348typedef struct DataAdviseHolder
349{
350 ICOM_VTABLE(IDataAdviseHolder)* lpvtbl;
351
352 DWORD ref;
353} DataAdviseHolder;
354
355/**************************************************************************
356 * DataAdviseHolder method prototypes
357 */
358static IDataAdviseHolder* DataAdviseHolder_Constructor();
359static void DataAdviseHolder_Destructor(DataAdviseHolder* ptrToDestroy);
360static HRESULT WINAPI DataAdviseHolder_QueryInterface(
361 IDataAdviseHolder* iface,
362 REFIID riid,
363 void** ppvObject);
364static ULONG WINAPI DataAdviseHolder_AddRef(
365 IDataAdviseHolder* iface);
366static ULONG WINAPI DataAdviseHolder_Release(
367 IDataAdviseHolder* iface);
368static HRESULT WINAPI DataAdviseHolder_Advise(
369 IDataAdviseHolder* iface,
370 IDataObject* pDataObject,
371 FORMATETC* pFetc,
372 DWORD advf,
373 IAdviseSink* pAdvise,
374 DWORD* pdwConnection);
375static HRESULT WINAPI DataAdviseHolder_Unadvise(
376 IDataAdviseHolder* iface,
377 DWORD dwConnection);
378static HRESULT WINAPI DataAdviseHolder_EnumAdvise(
379 IDataAdviseHolder* iface,
380 IEnumSTATDATA** ppenumAdvise);
381static HRESULT WINAPI DataAdviseHolder_SendOnDataChange(
382 IDataAdviseHolder* iface,
383 IDataObject* pDataObject,
384 DWORD dwReserved,
385 DWORD advf);
386
387/**************************************************************************
388 * DataAdviseHolderImpl_VTable
389 */
390static struct ICOM_VTABLE(IDataAdviseHolder) DataAdviseHolderImpl_VTable =
391{
392 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
393 DataAdviseHolder_QueryInterface,
394 DataAdviseHolder_AddRef,
395 DataAdviseHolder_Release,
396 DataAdviseHolder_Advise,
397 DataAdviseHolder_Unadvise,
398 DataAdviseHolder_EnumAdvise,
399 DataAdviseHolder_SendOnDataChange
400};
401
402/******************************************************************************
403 * DataAdviseHolder_Constructor
404 */
405static IDataAdviseHolder* DataAdviseHolder_Constructor()
406{
407 DataAdviseHolder* newHolder;
408
409 newHolder = (DataAdviseHolder*)HeapAlloc(GetProcessHeap(),
410 0,
411 sizeof(DataAdviseHolder));
412
413 newHolder->lpvtbl = &DataAdviseHolderImpl_VTable;
414 newHolder->ref = 1;
415
416 return (IDataAdviseHolder*)newHolder;
417}
418
419/******************************************************************************
420 * DataAdviseHolder_Destructor
421 */
422static void DataAdviseHolder_Destructor(
423 DataAdviseHolder* ptrToDestroy)
424{
425 HeapFree(GetProcessHeap(),
426 0,
427 ptrToDestroy);
428}
429
430/************************************************************************
431 * DataAdviseHolder_QueryInterface (IUnknown)
432 *
433 * See Windows documentation for more details on IUnknown methods.
434 */
435static HRESULT WINAPI DataAdviseHolder_QueryInterface(
436 IDataAdviseHolder* iface,
437 REFIID riid,
438 void** ppvObject)
439{
440 ICOM_THIS(DataAdviseHolder, iface);
441
442 /*
443 * Perform a sanity check on the parameters.
444 */
445 if ( (This==0) || (ppvObject==0) )
446 return E_INVALIDARG;
447
448 /*
449 * Initialize the return parameter.
450 */
451 *ppvObject = 0;
452
453 /*
454 * Compare the riid with the interface IDs implemented by this object.
455 */
456 if ( (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0) ||
457 (memcmp(&IID_IDataAdviseHolder, riid, sizeof(IID_IDataAdviseHolder)) == 0) )
458 {
459 *ppvObject = iface;
460 }
461
462 /*
463 * Check that we obtained an interface.
464 */
465 if ((*ppvObject)==0)
466 {
467 return E_NOINTERFACE;
468 }
469
470 /*
471 * Query Interface always increases the reference count by one when it is
472 * successful.
473 */
474 IUnknown_AddRef((IUnknown*)*ppvObject);
475
476 return S_OK;;
477}
478
479/************************************************************************
480 * DataAdviseHolder_AddRef (IUnknown)
481 *
482 * See Windows documentation for more details on IUnknown methods.
483 */
484static ULONG WINAPI DataAdviseHolder_AddRef(
485 IDataAdviseHolder* iface)
486{
487 ICOM_THIS(DataAdviseHolder, iface);
488
489 This->ref++;
490
491 return This->ref;
492}
493
494/************************************************************************
495 * DataAdviseHolder_Release (IUnknown)
496 *
497 * See Windows documentation for more details on IUnknown methods.
498 */
499static ULONG WINAPI DataAdviseHolder_Release(
500 IDataAdviseHolder* iface)
501{
502 ICOM_THIS(DataAdviseHolder, iface);
503
504 /*
505 * Decrease the reference count on this object.
506 */
507 This->ref--;
508
509 /*
510 * If the reference count goes down to 0, perform suicide.
511 */
512 if (This->ref==0)
513 {
514 DataAdviseHolder_Destructor(This);
515
516 return 0;
517 }
518
519 return This->ref;
520}
521
522static HRESULT WINAPI DataAdviseHolder_Advise(
523 IDataAdviseHolder* iface,
524 IDataObject* pDataObject,
525 FORMATETC* pFetc,
526 DWORD advf,
527 IAdviseSink* pAdvise,
528 DWORD* pdwConnection)
529{
530 FIXME("(): stub\n");
531 return E_NOTIMPL;
532}
533
534static HRESULT WINAPI DataAdviseHolder_Unadvise(
535 IDataAdviseHolder* iface,
536 DWORD dwConnection)
537{
538 FIXME("(): stub\n");
539 return E_NOTIMPL;
540}
541
542static HRESULT WINAPI DataAdviseHolder_EnumAdvise(
543 IDataAdviseHolder* iface,
544 IEnumSTATDATA** ppenumAdvise)
545{
546 FIXME("(): stub\n");
547 return E_NOTIMPL;
548}
549
550static HRESULT WINAPI DataAdviseHolder_SendOnDataChange(
551 IDataAdviseHolder* iface,
552 IDataObject* pDataObject,
553 DWORD dwReserved,
554 DWORD advf)
555{
556 FIXME("(): stub\n");
557 return E_NOTIMPL;
558}
559
560/***********************************************************************
561 * API functions
562 */
563
564/***********************************************************************
565 * CreateOleAdviseHolder [OLE32.59]
566 */
567HRESULT WINAPI CreateOleAdviseHolder(
568 LPOLEADVISEHOLDER *ppOAHolder)
569{
570 TRACE("(%p)\n", ppOAHolder);
571
572 /*
573 * Sanity check,
574 */
575 if (ppOAHolder==NULL)
576 return E_POINTER;
577
578 *ppOAHolder = OleAdviseHolderImpl_Constructor ();
579
580 if (*ppOAHolder != NULL)
581 return S_OK;
582
583 return E_OUTOFMEMORY;
584}
585
586/******************************************************************************
587 * CreateDataAdviseHolder [OLE32.53]
588 */
589HRESULT WINAPI CreateDataAdviseHolder(
590 LPDATAADVISEHOLDER* ppDAHolder)
591{
592 TRACE("(%p)\n", ppDAHolder);
593
594 /*
595 * Sanity check,
596 */
597 if (ppDAHolder==NULL)
598 return E_POINTER;
599
600 *ppDAHolder = DataAdviseHolder_Constructor();
601
602 if (*ppDAHolder != NULL)
603 return S_OK;
604
605 return E_OUTOFMEMORY;
606}
607
Note: See TracBrowser for help on using the repository browser.