oleaut32: Uncomment a line to implement conversion from VT_DISPATCH to VT_BSTR.
[wine] / dlls / oleaut32 / connpt.c
1 /*
2  * Implementation of a generic ConnectionPoint object.
3  *
4  * Copyright 2000 Huw D M Davies for CodeWeavers
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  *
20  * NOTES:
21  * See one exported function here is CreateConnectionPoint, see
22  * comments just above that function for information.
23  */
24
25 #include <assert.h>
26 #include <stdarg.h>
27 #include <string.h>
28
29 #define COBJMACROS
30
31 #include "winerror.h"
32 #include "windef.h"
33 #include "winbase.h"
34 #include "wingdi.h"
35 #include "winuser.h"
36 #include "ole2.h"
37 #include "olectl.h"
38 #include "connpt.h"
39
40 #include "wine/debug.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(ole);
43
44 #define MAXSINKS 10
45
46 /************************************************************************
47  * Implementation of IConnectionPoint
48  */
49 typedef struct ConnectionPointImpl {
50
51   const IConnectionPointVtbl *lpvtbl;
52
53   /* IUnknown of our main object*/
54   IUnknown *Obj;
55
56   /* Reference count */
57   LONG ref;
58
59   /* IID of sink interface */
60   IID iid;
61
62   /* Array of sink IUnknowns */
63   IUnknown **sinks;
64   DWORD maxSinks;
65
66   DWORD nSinks;
67 } ConnectionPointImpl;
68
69 static const IConnectionPointVtbl ConnectionPointImpl_VTable;
70
71
72 /************************************************************************
73  * Implementation of IEnumConnections
74  */
75 typedef struct EnumConnectionsImpl {
76
77   const IEnumConnectionsVtbl *lpvtbl;
78
79   LONG ref;
80
81   /* IUnknown of ConnectionPoint, used for ref counting */
82   IUnknown *pUnk;
83
84   /* Connection Data */
85   CONNECTDATA *pCD;
86   DWORD nConns;
87
88   /* Next connection to enumerate from */
89   DWORD nCur;
90
91 } EnumConnectionsImpl;
92
93 static EnumConnectionsImpl *EnumConnectionsImpl_Construct(IUnknown *pUnk,
94                                                           DWORD nSinks,
95                                                           CONNECTDATA *pCD);
96
97
98 /************************************************************************
99  * ConnectionPointImpl_Construct
100  */
101 static ConnectionPointImpl *ConnectionPointImpl_Construct(IUnknown *pUnk,
102                                                           REFIID riid)
103 {
104   ConnectionPointImpl *Obj;
105
106   Obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*Obj));
107   Obj->lpvtbl = &ConnectionPointImpl_VTable;
108   Obj->Obj = pUnk;
109   Obj->ref = 1;
110   Obj->iid =  *riid;
111   Obj->maxSinks = MAXSINKS;
112   Obj->sinks = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
113                          sizeof(IUnknown*) * MAXSINKS);
114   Obj->nSinks = 0;
115   return Obj;
116 }
117
118 /************************************************************************
119  * ConnectionPointImpl_Destroy
120  */
121 static void ConnectionPointImpl_Destroy(ConnectionPointImpl *Obj)
122 {
123   DWORD i;
124   for(i = 0; i < Obj->maxSinks; i++) {
125     if(Obj->sinks[i]) {
126       IUnknown_Release(Obj->sinks[i]);
127       Obj->sinks[i] = NULL;
128     }
129   }
130   HeapFree(GetProcessHeap(), 0, Obj->sinks);
131   HeapFree(GetProcessHeap(), 0, Obj);
132   return;
133 }
134
135 static ULONG WINAPI ConnectionPointImpl_AddRef(IConnectionPoint* iface);
136 /************************************************************************
137  * ConnectionPointImpl_QueryInterface (IUnknown)
138  *
139  * See Windows documentation for more details on IUnknown methods.
140  */
141 static HRESULT WINAPI ConnectionPointImpl_QueryInterface(
142   IConnectionPoint*  iface,
143   REFIID  riid,
144   void**  ppvObject)
145 {
146   ConnectionPointImpl *This = (ConnectionPointImpl *)iface;
147   TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObject);
148
149   /*
150    * Perform a sanity check on the parameters.
151    */
152   if ( (This==0) || (ppvObject==0) )
153     return E_INVALIDARG;
154
155   /*
156    * Initialize the return parameter.
157    */
158   *ppvObject = 0;
159
160   /*
161    * Compare the riid with the interface IDs implemented by this object.
162    */
163   if (IsEqualIID(&IID_IUnknown, riid))
164     *ppvObject = (IConnectionPoint*)This;
165   else if (IsEqualIID(&IID_IConnectionPoint, riid))
166     *ppvObject = (IConnectionPoint*)This;
167
168   /*
169    * Check that we obtained an interface.
170    */
171   if ((*ppvObject)==0)
172   {
173     FIXME("() : asking for un supported interface %s\n",debugstr_guid(riid));
174     return E_NOINTERFACE;
175   }
176
177   /*
178    * Query Interface always increases the reference count by one when it is
179    * successful
180    */
181   ConnectionPointImpl_AddRef((IConnectionPoint*)This);
182
183   return S_OK;
184 }
185
186
187 /************************************************************************
188  * ConnectionPointImpl_AddRef (IUnknown)
189  *
190  * See Windows documentation for more details on IUnknown methods.
191  */
192 static ULONG WINAPI ConnectionPointImpl_AddRef(IConnectionPoint* iface)
193 {
194   ConnectionPointImpl *This = (ConnectionPointImpl *)iface;
195   ULONG refCount = InterlockedIncrement(&This->ref);
196
197   TRACE("(%p)->(ref before=%ld)\n", This, refCount - 1);
198
199   return refCount;
200 }
201
202 /************************************************************************
203  * ConnectionPointImpl_Release (IUnknown)
204  *
205  * See Windows documentation for more details on IUnknown methods.
206  */
207 static ULONG WINAPI ConnectionPointImpl_Release(
208       IConnectionPoint* iface)
209 {
210   ConnectionPointImpl *This = (ConnectionPointImpl *)iface;
211   ULONG refCount = InterlockedDecrement(&This->ref);
212
213   TRACE("(%p)->(ref before=%ld)\n", This, refCount + 1);
214
215   /*
216    * If the reference count goes down to 0, perform suicide.
217    */
218   if (!refCount) ConnectionPointImpl_Destroy(This);
219
220   return refCount;
221 }
222
223 /************************************************************************
224  * ConnectionPointImpl_GetConnectionInterface (IConnectionPoint)
225  *
226  */
227 static HRESULT WINAPI ConnectionPointImpl_GetConnectionInterface(
228                                                IConnectionPoint *iface,
229                                                IID              *piid)
230 {
231   ConnectionPointImpl *This = (ConnectionPointImpl *)iface;
232   TRACE("(%p)->(%p) returning %s\n", This, piid, debugstr_guid(&(This->iid)));
233   *piid = This->iid;
234   return S_OK;
235 }
236
237 /************************************************************************
238  * ConnectionPointImpl_GetConnectionPointContainer (IConnectionPoint)
239  *
240  */
241 static HRESULT WINAPI ConnectionPointImpl_GetConnectionPointContainer(
242                                       IConnectionPoint           *iface,
243                                       IConnectionPointContainer  **ppCPC)
244 {
245   ConnectionPointImpl *This = (ConnectionPointImpl *)iface;
246   TRACE("(%p)->(%p)\n", This, ppCPC);
247
248   return IUnknown_QueryInterface(This->Obj,
249                                  &IID_IConnectionPointContainer,
250                                  (LPVOID)ppCPC);
251 }
252
253 /************************************************************************
254  * ConnectionPointImpl_Advise (IConnectionPoint)
255  *
256  */
257 static HRESULT WINAPI ConnectionPointImpl_Advise(IConnectionPoint *iface,
258                                                  IUnknown *lpUnk,
259                                                  DWORD *pdwCookie)
260 {
261   DWORD i;
262   ConnectionPointImpl *This = (ConnectionPointImpl *)iface;
263   IUnknown *lpSink;
264   TRACE("(%p)->(%p, %p)\n", This, lpUnk, pdwCookie);
265
266   *pdwCookie = 0;
267   if(FAILED(IUnknown_QueryInterface(lpUnk, &This->iid, (LPVOID)&lpSink)))
268     return CONNECT_E_CANNOTCONNECT;
269
270   for(i = 0; i < This->maxSinks; i++) {
271     if(This->sinks[i] == NULL)
272       break;
273   }
274   if(i == This->maxSinks) {
275     This->maxSinks += MAXSINKS;
276     This->sinks = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->sinks,
277                               This->maxSinks * sizeof(IUnknown *));
278   }
279   This->sinks[i] = lpSink;
280   This->nSinks++;
281   *pdwCookie = i + 1;
282   return S_OK;
283 }
284
285
286 /************************************************************************
287  * ConnectionPointImpl_Unadvise (IConnectionPoint)
288  *
289  */
290 static HRESULT WINAPI ConnectionPointImpl_Unadvise(IConnectionPoint *iface,
291                                                    DWORD dwCookie)
292 {
293   ConnectionPointImpl *This = (ConnectionPointImpl *)iface;
294   TRACE("(%p)->(%ld)\n", This, dwCookie);
295
296   if(dwCookie == 0 || dwCookie > This->maxSinks) return E_INVALIDARG;
297
298   if(This->sinks[dwCookie-1] == NULL) return CONNECT_E_NOCONNECTION;
299
300   IUnknown_Release(This->sinks[dwCookie-1]);
301   This->sinks[dwCookie-1] = NULL;
302   This->nSinks--;
303   return S_OK;
304 }
305
306 /************************************************************************
307  * ConnectionPointImpl_EnumConnections (IConnectionPoint)
308  *
309  */
310 static HRESULT WINAPI ConnectionPointImpl_EnumConnections(
311                                                     IConnectionPoint *iface,
312                                                     LPENUMCONNECTIONS *ppEnum)
313 {
314   ConnectionPointImpl *This = (ConnectionPointImpl *)iface;
315   CONNECTDATA *pCD;
316   DWORD i, nextslot;
317   EnumConnectionsImpl *EnumObj;
318   HRESULT hr;
319
320   TRACE("(%p)->(%p)\n", This, ppEnum);
321
322   *ppEnum = NULL;
323
324   if(This->nSinks == 0) return OLE_E_NOCONNECTION;
325
326   pCD = HeapAlloc(GetProcessHeap(), 0, sizeof(CONNECTDATA) * This->nSinks);
327
328   for(i = 0, nextslot = 0; i < This->maxSinks; i++) {
329     if(This->sinks[i] != NULL) {
330       pCD[nextslot].pUnk = This->sinks[i];
331       pCD[nextslot].dwCookie = i + 1;
332       nextslot++;
333     }
334   }
335   assert(nextslot == This->nSinks);
336
337   /* Bump the ref count of this object up by one.  It gets Released in
338      IEnumConnections_Release */
339   IUnknown_AddRef((IUnknown*)This);
340
341   EnumObj = EnumConnectionsImpl_Construct((IUnknown*)This, This->nSinks, pCD);
342   hr = IEnumConnections_QueryInterface((IEnumConnections*)EnumObj,
343                                   &IID_IEnumConnections, (LPVOID)ppEnum);
344   IEnumConnections_Release((IEnumConnections*)EnumObj);
345
346   HeapFree(GetProcessHeap(), 0, pCD);
347   return hr;
348 }
349
350 static const IConnectionPointVtbl ConnectionPointImpl_VTable =
351 {
352   ConnectionPointImpl_QueryInterface,
353   ConnectionPointImpl_AddRef,
354   ConnectionPointImpl_Release,
355   ConnectionPointImpl_GetConnectionInterface,
356   ConnectionPointImpl_GetConnectionPointContainer,
357   ConnectionPointImpl_Advise,
358   ConnectionPointImpl_Unadvise,
359   ConnectionPointImpl_EnumConnections
360 };
361
362
363 static const IEnumConnectionsVtbl EnumConnectionsImpl_VTable;
364 static ULONG WINAPI EnumConnectionsImpl_AddRef(IEnumConnections* iface);
365
366 /************************************************************************
367  * EnumConnectionsImpl_Construct
368  */
369 static EnumConnectionsImpl *EnumConnectionsImpl_Construct(IUnknown *pUnk,
370                                                           DWORD nSinks,
371                                                           CONNECTDATA *pCD)
372 {
373   EnumConnectionsImpl *Obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*Obj));
374   DWORD i;
375
376   Obj->lpvtbl = &EnumConnectionsImpl_VTable;
377   Obj->ref = 1;
378   Obj->pUnk = pUnk;
379   Obj->pCD = HeapAlloc(GetProcessHeap(), 0, nSinks * sizeof(CONNECTDATA));
380   Obj->nConns = nSinks;
381   Obj->nCur = 0;
382
383   for(i = 0; i < nSinks; i++) {
384     Obj->pCD[i] = pCD[i];
385     IUnknown_AddRef(Obj->pCD[i].pUnk);
386   }
387   return Obj;
388 }
389
390 /************************************************************************
391  * EnumConnectionsImpl_Destroy
392  */
393 static void EnumConnectionsImpl_Destroy(EnumConnectionsImpl *Obj)
394 {
395   DWORD i;
396
397   for(i = 0; i < Obj->nConns; i++)
398     IUnknown_Release(Obj->pCD[i].pUnk);
399
400   HeapFree(GetProcessHeap(), 0, Obj->pCD);
401   HeapFree(GetProcessHeap(), 0, Obj);
402   return;
403 }
404
405 /************************************************************************
406  * EnumConnectionsImpl_QueryInterface (IUnknown)
407  *
408  * See Windows documentation for more details on IUnknown methods.
409  */
410 static HRESULT WINAPI EnumConnectionsImpl_QueryInterface(
411   IEnumConnections*  iface,
412   REFIID  riid,
413   void**  ppvObject)
414 {
415   ConnectionPointImpl *This = (ConnectionPointImpl *)iface;
416   TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObject);
417
418   /*
419    * Perform a sanity check on the parameters.
420    */
421   if ( (This==0) || (ppvObject==0) )
422     return E_INVALIDARG;
423
424   /*
425    * Initialize the return parameter.
426    */
427   *ppvObject = 0;
428
429   /*
430    * Compare the riid with the interface IDs implemented by this object.
431    */
432   if (IsEqualIID(&IID_IUnknown, riid))
433     *ppvObject = (IEnumConnections*)This;
434   else if (IsEqualIID(&IID_IEnumConnections, riid))
435     *ppvObject = (IEnumConnections*)This;
436
437   /*
438    * Check that we obtained an interface.
439    */
440   if ((*ppvObject)==0)
441   {
442     FIXME("() : asking for un supported interface %s\n",debugstr_guid(riid));
443     return E_NOINTERFACE;
444   }
445
446   /*
447    * Query Interface always increases the reference count by one when it is
448    * successful
449    */
450   EnumConnectionsImpl_AddRef((IEnumConnections*)This);
451
452   return S_OK;
453 }
454
455
456 /************************************************************************
457  * EnumConnectionsImpl_AddRef (IUnknown)
458  *
459  * See Windows documentation for more details on IUnknown methods.
460  */
461 static ULONG WINAPI EnumConnectionsImpl_AddRef(IEnumConnections* iface)
462 {
463   EnumConnectionsImpl *This = (EnumConnectionsImpl *)iface;
464   ULONG refCount = InterlockedIncrement(&This->ref);
465
466   TRACE("(%p)->(ref before=%ld)\n", This, refCount - 1);
467
468   IUnknown_AddRef(This->pUnk);
469   return refCount;
470 }
471
472 /************************************************************************
473  * EnumConnectionsImpl_Release (IUnknown)
474  *
475  * See Windows documentation for more details on IUnknown methods.
476  */
477 static ULONG WINAPI EnumConnectionsImpl_Release(IEnumConnections* iface)
478 {
479   EnumConnectionsImpl *This = (EnumConnectionsImpl *)iface;
480   ULONG refCount = InterlockedDecrement(&This->ref);
481
482   TRACE("(%p)->(ref before=%ld)\n", This, refCount + 1);
483
484   IUnknown_Release(This->pUnk);
485
486   /*
487    * If the reference count goes down to 0, perform suicide.
488    */
489   if (!refCount) EnumConnectionsImpl_Destroy(This);
490
491   return refCount;
492 }
493
494 /************************************************************************
495  * EnumConnectionsImpl_Next (IEnumConnections)
496  *
497  */
498 static HRESULT WINAPI EnumConnectionsImpl_Next(IEnumConnections* iface,
499                                                ULONG cConn, LPCONNECTDATA pCD,
500                                                ULONG *pEnum)
501 {
502   EnumConnectionsImpl *This = (EnumConnectionsImpl *)iface;
503   DWORD nRet = 0;
504   TRACE("(%p)->(%ld, %p, %p)\n", This, cConn, pCD, pEnum);
505
506   if(pEnum == NULL) {
507     if(cConn != 1)
508       return E_POINTER;
509   } else
510     *pEnum = 0;
511
512   if(This->nCur >= This->nConns)
513     return S_FALSE;
514
515   while(This->nCur < This->nConns && cConn) {
516     *pCD++ = This->pCD[This->nCur];
517     IUnknown_AddRef(This->pCD[This->nCur].pUnk);
518     This->nCur++;
519     cConn--;
520     nRet++;
521   }
522
523   if(pEnum)
524     *pEnum = nRet;
525
526   return S_OK;
527 }
528
529
530 /************************************************************************
531  * EnumConnectionsImpl_Skip (IEnumConnections)
532  *
533  */
534 static HRESULT WINAPI EnumConnectionsImpl_Skip(IEnumConnections* iface,
535                                                ULONG cSkip)
536 {
537   EnumConnectionsImpl *This = (EnumConnectionsImpl *)iface;
538   TRACE("(%p)->(%ld)\n", This, cSkip);
539
540   if(This->nCur + cSkip >= This->nConns)
541     return S_FALSE;
542
543   This->nCur += cSkip;
544
545   return S_OK;
546 }
547
548
549 /************************************************************************
550  * EnumConnectionsImpl_Reset (IEnumConnections)
551  *
552  */
553 static HRESULT WINAPI EnumConnectionsImpl_Reset(IEnumConnections* iface)
554 {
555   EnumConnectionsImpl *This = (EnumConnectionsImpl *)iface;
556   TRACE("(%p)\n", This);
557
558   This->nCur = 0;
559
560   return S_OK;
561 }
562
563
564 /************************************************************************
565  * EnumConnectionsImpl_Clone (IEnumConnections)
566  *
567  */
568 static HRESULT WINAPI EnumConnectionsImpl_Clone(IEnumConnections* iface,
569                                                 LPENUMCONNECTIONS *ppEnum)
570 {
571   EnumConnectionsImpl *This = (EnumConnectionsImpl *)iface;
572   EnumConnectionsImpl *newObj;
573   TRACE("(%p)->(%p)\n", This, ppEnum);
574
575   newObj = EnumConnectionsImpl_Construct(This->pUnk, This->nConns, This->pCD);
576   newObj->nCur = This->nCur;
577   *ppEnum = (LPENUMCONNECTIONS)newObj;
578   IUnknown_AddRef(This->pUnk);
579   return S_OK;
580 }
581
582 static const IEnumConnectionsVtbl EnumConnectionsImpl_VTable =
583 {
584   EnumConnectionsImpl_QueryInterface,
585   EnumConnectionsImpl_AddRef,
586   EnumConnectionsImpl_Release,
587   EnumConnectionsImpl_Next,
588   EnumConnectionsImpl_Skip,
589   EnumConnectionsImpl_Reset,
590   EnumConnectionsImpl_Clone
591 };
592
593 /************************************************************************
594  *
595  *  The exported function to create the connection point.
596  *  NB not a windows API
597  *
598  * PARAMS
599  * pUnk [in] IUnknown of object to which the ConnectionPoint is associated.
600  *           Needed to access IConnectionPointContainer.
601  *
602  * riid [in] IID of sink interface that this ConnectionPoint manages
603  *
604  * pCP [out] returns IConnectionPoint
605  *
606  */
607 HRESULT CreateConnectionPoint(IUnknown *pUnk, REFIID riid,
608                               IConnectionPoint **pCP)
609 {
610   ConnectionPointImpl *Obj;
611   HRESULT hr;
612
613   Obj = ConnectionPointImpl_Construct(pUnk, riid);
614   if(!Obj) return E_OUTOFMEMORY;
615
616   hr = IConnectionPoint_QueryInterface((IConnectionPoint *)Obj,
617                                        &IID_IConnectionPoint, (LPVOID)pCP);
618   IConnectionPoint_Release((IConnectionPoint *)Obj);
619   return hr;
620 }