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   IConnectionPoint IConnectionPoint_iface;
  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   IEnumConnections IEnumConnections_iface;
  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 static inline ConnectionPointImpl *impl_from_IConnectionPoint(IConnectionPoint *iface)
  98 {
  99   return CONTAINING_RECORD(iface, ConnectionPointImpl, IConnectionPoint_iface);
 100 }
 101
 102 static inline EnumConnectionsImpl *impl_from_IEnumConnections(IEnumConnections *iface)
 103 {
 104   return CONTAINING_RECORD(iface, EnumConnectionsImpl, IEnumConnections_iface);
 105 }
 106
 107 /************************************************************************
 108  * ConnectionPointImpl_Construct
 109  */
 110 static ConnectionPointImpl *ConnectionPointImpl_Construct(IUnknown *pUnk,
 111                                                           REFIID riid)
 112 {
 113   ConnectionPointImpl *Obj;
 114
 115   Obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*Obj));
 116   Obj->IConnectionPoint_iface.lpVtbl = &ConnectionPointImpl_VTable;
 117   Obj->Obj = pUnk;
 118   Obj->ref = 1;
 119   Obj->iid =  *riid;
 120   Obj->maxSinks = MAXSINKS;
 121   Obj->sinks = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 122                          sizeof(IUnknown*) * MAXSINKS);
 123   Obj->nSinks = 0;
 124   return Obj;
 125 }
 126
 127 /************************************************************************
 128  * ConnectionPointImpl_Destroy
 129  */
 130 static void ConnectionPointImpl_Destroy(ConnectionPointImpl *Obj)
 131 {
 132   DWORD i;
 133   for(i = 0; i < Obj->maxSinks; i++) {
 134     if(Obj->sinks[i]) {
 135       IUnknown_Release(Obj->sinks[i]);
 136       Obj->sinks[i] = NULL;
 137     }
 138   }
 139   HeapFree(GetProcessHeap(), 0, Obj->sinks);
 140   HeapFree(GetProcessHeap(), 0, Obj);
 141   return;
 142 }
 143
 144 static ULONG WINAPI ConnectionPointImpl_AddRef(IConnectionPoint* iface);
 145 /************************************************************************
 146  * ConnectionPointImpl_QueryInterface (IUnknown)
 147  *
 148  * See Windows documentation for more details on IUnknown methods.
 149  */
 150 static HRESULT WINAPI ConnectionPointImpl_QueryInterface(
 151   IConnectionPoint*  iface,
 152   REFIID  riid,
 153   void**  ppvObject)
 154 {
 155   ConnectionPointImpl *This = impl_from_IConnectionPoint(iface);
 156   TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObject);
 157
 158   /*
 159    * Perform a sanity check on the parameters.
 160    */
 161   if ( (This==0) || (ppvObject==0) )
 162     return E_INVALIDARG;
 163
 164   /*
 165    * Initialize the return parameter.
 166    */
 167   *ppvObject = 0;
 168
 169   /*
 170    * Compare the riid with the interface IDs implemented by this object.
 171    */
 172   if (IsEqualIID(&IID_IUnknown, riid))
 173     *ppvObject = This;
 174   else if (IsEqualIID(&IID_IConnectionPoint, riid))
 175     *ppvObject = This;
 176
 177   /*
 178    * Check that we obtained an interface.
 179    */
 180   if ((*ppvObject)==0)
 181   {
 182     FIXME("() : asking for un supported interface %s\n",debugstr_guid(riid));
 183     return E_NOINTERFACE;
 184   }
 185
 186   /*
 187    * Query Interface always increases the reference count by one when it is
 188    * successful
 189    */
 190   ConnectionPointImpl_AddRef(&This->IConnectionPoint_iface);
 191
 192   return S_OK;
 193 }
 194
 195
 196 /************************************************************************
 197  * ConnectionPointImpl_AddRef (IUnknown)
 198  *
 199  * See Windows documentation for more details on IUnknown methods.
 200  */
 201 static ULONG WINAPI ConnectionPointImpl_AddRef(IConnectionPoint* iface)
 202 {
 203   ConnectionPointImpl *This = impl_from_IConnectionPoint(iface);
 204   ULONG refCount = InterlockedIncrement(&This->ref);
 205
 206   TRACE("(%p)->(ref before=%d)\n", This, refCount - 1);
 207
 208   return refCount;
 209 }
 210
 211 /************************************************************************
 212  * ConnectionPointImpl_Release (IUnknown)
 213  *
 214  * See Windows documentation for more details on IUnknown methods.
 215  */
 216 static ULONG WINAPI ConnectionPointImpl_Release(
 217       IConnectionPoint* iface)
 218 {
 219   ConnectionPointImpl *This = impl_from_IConnectionPoint(iface);
 220   ULONG refCount = InterlockedDecrement(&This->ref);
 221
 222   TRACE("(%p)->(ref before=%d)\n", This, refCount + 1);
 223
 224   /*
 225    * If the reference count goes down to 0, perform suicide.
 226    */
 227   if (!refCount) ConnectionPointImpl_Destroy(This);
 228
 229   return refCount;
 230 }
 231
 232 /************************************************************************
 233  * ConnectionPointImpl_GetConnectionInterface (IConnectionPoint)
 234  *
 235  */
 236 static HRESULT WINAPI ConnectionPointImpl_GetConnectionInterface(
 237                                                IConnectionPoint *iface,
 238                                                IID              *piid)
 239 {
 240   ConnectionPointImpl *This = impl_from_IConnectionPoint(iface);
 241   TRACE("(%p)->(%p) returning %s\n", This, piid, debugstr_guid(&(This->iid)));
 242   *piid = This->iid;
 243   return S_OK;
 244 }
 245
 246 /************************************************************************
 247  * ConnectionPointImpl_GetConnectionPointContainer (IConnectionPoint)
 248  *
 249  */
 250 static HRESULT WINAPI ConnectionPointImpl_GetConnectionPointContainer(
 251                                       IConnectionPoint           *iface,
 252                                       IConnectionPointContainer  **ppCPC)
 253 {
 254   ConnectionPointImpl *This = impl_from_IConnectionPoint(iface);
 255   TRACE("(%p)->(%p)\n", This, ppCPC);
 256
 257   return IUnknown_QueryInterface(This->Obj, &IID_IConnectionPointContainer, (void**)ppCPC);
 258 }
 259
 260 /************************************************************************
 261  * ConnectionPointImpl_Advise (IConnectionPoint)
 262  *
 263  */
 264 static HRESULT WINAPI ConnectionPointImpl_Advise(IConnectionPoint *iface,
 265                                                  IUnknown *lpUnk,
 266                                                  DWORD *pdwCookie)
 267 {
 268   DWORD i;
 269   ConnectionPointImpl *This = impl_from_IConnectionPoint(iface);
 270   IUnknown *lpSink;
 271   TRACE("(%p)->(%p, %p)\n", This, lpUnk, pdwCookie);
 272
 273   *pdwCookie = 0;
 274   if(FAILED(IUnknown_QueryInterface(lpUnk, &This->iid, (void**)&lpSink)))
 275     return CONNECT_E_CANNOTCONNECT;
 276
 277   for(i = 0; i < This->maxSinks; i++) {
 278     if(This->sinks[i] == NULL)
 279       break;
 280   }
 281   if(i == This->maxSinks) {
 282     This->maxSinks += MAXSINKS;
 283     This->sinks = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->sinks,
 284                               This->maxSinks * sizeof(IUnknown *));
 285   }
 286   This->sinks[i] = lpSink;
 287   This->nSinks++;
 288   *pdwCookie = i + 1;
 289   return S_OK;
 290 }
 291
 292
 293 /************************************************************************
 294  * ConnectionPointImpl_Unadvise (IConnectionPoint)
 295  *
 296  */
 297 static HRESULT WINAPI ConnectionPointImpl_Unadvise(IConnectionPoint *iface,
 298                                                    DWORD dwCookie)
 299 {
 300   ConnectionPointImpl *This = impl_from_IConnectionPoint(iface);
 301   TRACE("(%p)->(%d)\n", This, dwCookie);
 302
 303   if(dwCookie == 0 || dwCookie > This->maxSinks) return E_INVALIDARG;
 304
 305   if(This->sinks[dwCookie-1] == NULL) return CONNECT_E_NOCONNECTION;
 306
 307   IUnknown_Release(This->sinks[dwCookie-1]);
 308   This->sinks[dwCookie-1] = NULL;
 309   This->nSinks--;
 310   return S_OK;
 311 }
 312
 313 /************************************************************************
 314  * ConnectionPointImpl_EnumConnections (IConnectionPoint)
 315  *
 316  */
 317 static HRESULT WINAPI ConnectionPointImpl_EnumConnections(
 318                                                     IConnectionPoint *iface,
 319                                                     LPENUMCONNECTIONS *ppEnum)
 320 {
 321   ConnectionPointImpl *This = impl_from_IConnectionPoint(iface);
 322   CONNECTDATA *pCD;
 323   DWORD i, nextslot;
 324   EnumConnectionsImpl *EnumObj;
 325   HRESULT hr;
 326
 327   TRACE("(%p)->(%p)\n", This, ppEnum);
 328
 329   *ppEnum = NULL;
 330
 331   if(This->nSinks == 0) return OLE_E_NOCONNECTION;
 332
 333   pCD = HeapAlloc(GetProcessHeap(), 0, sizeof(CONNECTDATA) * This->nSinks);
 334
 335   for(i = 0, nextslot = 0; i < This->maxSinks; i++) {
 336     if(This->sinks[i] != NULL) {
 337       pCD[nextslot].pUnk = This->sinks[i];
 338       pCD[nextslot].dwCookie = i + 1;
 339       nextslot++;
 340     }
 341   }
 342   assert(nextslot == This->nSinks);
 343
 344   /* Bump the ref count of this object up by one.  It gets Released in
 345      IEnumConnections_Release */
 346   IUnknown_AddRef((IUnknown*)This);
 347
 348   EnumObj = EnumConnectionsImpl_Construct((IUnknown*)This, This->nSinks, pCD);
 349   hr = IEnumConnections_QueryInterface(&EnumObj->IEnumConnections_iface,
 350                                        &IID_IEnumConnections, (void**)ppEnum);
 351   IEnumConnections_Release(&EnumObj->IEnumConnections_iface);
 352
 353   HeapFree(GetProcessHeap(), 0, pCD);
 354   return hr;
 355 }
 356
 357 static const IConnectionPointVtbl ConnectionPointImpl_VTable =
 358 {
 359   ConnectionPointImpl_QueryInterface,
 360   ConnectionPointImpl_AddRef,
 361   ConnectionPointImpl_Release,
 362   ConnectionPointImpl_GetConnectionInterface,
 363   ConnectionPointImpl_GetConnectionPointContainer,
 364   ConnectionPointImpl_Advise,
 365   ConnectionPointImpl_Unadvise,
 366   ConnectionPointImpl_EnumConnections
 367 };
 368
 369
 370 static const IEnumConnectionsVtbl EnumConnectionsImpl_VTable;
 371 static ULONG WINAPI EnumConnectionsImpl_AddRef(IEnumConnections* iface);
 372
 373 /************************************************************************
 374  * EnumConnectionsImpl_Construct
 375  */
 376 static EnumConnectionsImpl *EnumConnectionsImpl_Construct(IUnknown *pUnk,
 377                                                           DWORD nSinks,
 378                                                           CONNECTDATA *pCD)
 379 {
 380   EnumConnectionsImpl *Obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*Obj));
 381   DWORD i;
 382
 383   Obj->IEnumConnections_iface.lpVtbl = &EnumConnectionsImpl_VTable;
 384   Obj->ref = 1;
 385   Obj->pUnk = pUnk;
 386   Obj->pCD = HeapAlloc(GetProcessHeap(), 0, nSinks * sizeof(CONNECTDATA));
 387   Obj->nConns = nSinks;
 388   Obj->nCur = 0;
 389
 390   for(i = 0; i < nSinks; i++) {
 391     Obj->pCD[i] = pCD[i];
 392     IUnknown_AddRef(Obj->pCD[i].pUnk);
 393   }
 394   return Obj;
 395 }
 396
 397 /************************************************************************
 398  * EnumConnectionsImpl_Destroy
 399  */
 400 static void EnumConnectionsImpl_Destroy(EnumConnectionsImpl *Obj)
 401 {
 402   DWORD i;
 403
 404   for(i = 0; i < Obj->nConns; i++)
 405     IUnknown_Release(Obj->pCD[i].pUnk);
 406
 407   HeapFree(GetProcessHeap(), 0, Obj->pCD);
 408   HeapFree(GetProcessHeap(), 0, Obj);
 409   return;
 410 }
 411
 412 /************************************************************************
 413  * EnumConnectionsImpl_QueryInterface (IUnknown)
 414  *
 415  * See Windows documentation for more details on IUnknown methods.
 416  */
 417 static HRESULT WINAPI EnumConnectionsImpl_QueryInterface(
 418   IEnumConnections*  iface,
 419   REFIID  riid,
 420   void**  ppvObject)
 421 {
 422   ConnectionPointImpl *This = (ConnectionPointImpl *)iface;
 423   TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObject);
 424
 425   /*
 426    * Perform a sanity check on the parameters.
 427    */
 428   if ( (This==0) || (ppvObject==0) )
 429     return E_INVALIDARG;
 430
 431   /*
 432    * Initialize the return parameter.
 433    */
 434   *ppvObject = 0;
 435
 436   /*
 437    * Compare the riid with the interface IDs implemented by this object.
 438    */
 439   if (IsEqualIID(&IID_IUnknown, riid))
 440     *ppvObject = This;
 441   else if (IsEqualIID(&IID_IEnumConnections, riid))
 442     *ppvObject = This;
 443
 444   /*
 445    * Check that we obtained an interface.
 446    */
 447   if ((*ppvObject)==0)
 448   {
 449     FIXME("() : asking for un supported interface %s\n",debugstr_guid(riid));
 450     return E_NOINTERFACE;
 451   }
 452
 453   /*
 454    * Query Interface always increases the reference count by one when it is
 455    * successful
 456    */
 457   EnumConnectionsImpl_AddRef((IEnumConnections*)This);
 458
 459   return S_OK;
 460 }
 461
 462
 463 /************************************************************************
 464  * EnumConnectionsImpl_AddRef (IUnknown)
 465  *
 466  * See Windows documentation for more details on IUnknown methods.
 467  */
 468 static ULONG WINAPI EnumConnectionsImpl_AddRef(IEnumConnections* iface)
 469 {
 470   EnumConnectionsImpl *This = impl_from_IEnumConnections(iface);
 471   ULONG refCount = InterlockedIncrement(&This->ref);
 472
 473   TRACE("(%p)->(ref before=%d)\n", This, refCount - 1);
 474
 475   IUnknown_AddRef(This->pUnk);
 476   return refCount;
 477 }
 478
 479 /************************************************************************
 480  * EnumConnectionsImpl_Release (IUnknown)
 481  *
 482  * See Windows documentation for more details on IUnknown methods.
 483  */
 484 static ULONG WINAPI EnumConnectionsImpl_Release(IEnumConnections* iface)
 485 {
 486   EnumConnectionsImpl *This = impl_from_IEnumConnections(iface);
 487   ULONG refCount = InterlockedDecrement(&This->ref);
 488
 489   TRACE("(%p)->(ref before=%d)\n", This, refCount + 1);
 490
 491   IUnknown_Release(This->pUnk);
 492
 493   /*
 494    * If the reference count goes down to 0, perform suicide.
 495    */
 496   if (!refCount) EnumConnectionsImpl_Destroy(This);
 497
 498   return refCount;
 499 }
 500
 501 /************************************************************************
 502  * EnumConnectionsImpl_Next (IEnumConnections)
 503  *
 504  */
 505 static HRESULT WINAPI EnumConnectionsImpl_Next(IEnumConnections* iface,
 506                                                ULONG cConn, LPCONNECTDATA pCD,
 507                                                ULONG *pEnum)
 508 {
 509   EnumConnectionsImpl *This = impl_from_IEnumConnections(iface);
 510   DWORD nRet = 0;
 511   TRACE("(%p)->(%d, %p, %p)\n", This, cConn, pCD, pEnum);
 512
 513   if(pEnum == NULL) {
 514     if(cConn != 1)
 515       return E_POINTER;
 516   } else
 517     *pEnum = 0;
 518
 519   if(This->nCur >= This->nConns)
 520     return S_FALSE;
 521
 522   while(This->nCur < This->nConns && cConn) {
 523     *pCD++ = This->pCD[This->nCur];
 524     IUnknown_AddRef(This->pCD[This->nCur].pUnk);
 525     This->nCur++;
 526     cConn--;
 527     nRet++;
 528   }
 529
 530   if(pEnum)
 531     *pEnum = nRet;
 532
 533   return S_OK;
 534 }
 535
 536
 537 /************************************************************************
 538  * EnumConnectionsImpl_Skip (IEnumConnections)
 539  *
 540  */
 541 static HRESULT WINAPI EnumConnectionsImpl_Skip(IEnumConnections* iface,
 542                                                ULONG cSkip)
 543 {
 544   EnumConnectionsImpl *This = impl_from_IEnumConnections(iface);
 545   TRACE("(%p)->(%d)\n", This, cSkip);
 546
 547   if(This->nCur + cSkip >= This->nConns)
 548     return S_FALSE;
 549
 550   This->nCur += cSkip;
 551
 552   return S_OK;
 553 }
 554
 555
 556 /************************************************************************
 557  * EnumConnectionsImpl_Reset (IEnumConnections)
 558  *
 559  */
 560 static HRESULT WINAPI EnumConnectionsImpl_Reset(IEnumConnections* iface)
 561 {
 562   EnumConnectionsImpl *This = impl_from_IEnumConnections(iface);
 563   TRACE("(%p)\n", This);
 564
 565   This->nCur = 0;
 566
 567   return S_OK;
 568 }
 569
 570
 571 /************************************************************************
 572  * EnumConnectionsImpl_Clone (IEnumConnections)
 573  *
 574  */
 575 static HRESULT WINAPI EnumConnectionsImpl_Clone(IEnumConnections* iface,
 576                                                 LPENUMCONNECTIONS *ppEnum)
 577 {
 578   EnumConnectionsImpl *This = impl_from_IEnumConnections(iface);
 579   EnumConnectionsImpl *newObj;
 580   TRACE("(%p)->(%p)\n", This, ppEnum);
 581
 582   newObj = EnumConnectionsImpl_Construct(This->pUnk, This->nConns, This->pCD);
 583   newObj->nCur = This->nCur;
 584   *ppEnum = (LPENUMCONNECTIONS)newObj;
 585   IUnknown_AddRef(This->pUnk);
 586   return S_OK;
 587 }
 588
 589 static const IEnumConnectionsVtbl EnumConnectionsImpl_VTable =
 590 {
 591   EnumConnectionsImpl_QueryInterface,
 592   EnumConnectionsImpl_AddRef,
 593   EnumConnectionsImpl_Release,
 594   EnumConnectionsImpl_Next,
 595   EnumConnectionsImpl_Skip,
 596   EnumConnectionsImpl_Reset,
 597   EnumConnectionsImpl_Clone
 598 };
 599
 600 /************************************************************************
 601  *
 602  *  The exported function to create the connection point.
 603  *  NB not a windows API
 604  *
 605  * PARAMS
 606  * pUnk [in] IUnknown of object to which the ConnectionPoint is associated.
 607  *           Needed to access IConnectionPointContainer.
 608  *
 609  * riid [in] IID of sink interface that this ConnectionPoint manages
 610  *
 611  * pCP [out] returns IConnectionPoint
 612  *
 613  */
 614 HRESULT CreateConnectionPoint(IUnknown *pUnk, REFIID riid,
 615                               IConnectionPoint **pCP)
 616 {
 617   ConnectionPointImpl *Obj;
 618   HRESULT hr;
 619
 620   Obj = ConnectionPointImpl_Construct(pUnk, riid);
 621   if(!Obj) return E_OUTOFMEMORY;
 622
 623   hr = IConnectionPoint_QueryInterface(&Obj->IConnectionPoint_iface,
 624                                        &IID_IConnectionPoint, (void**)pCP);
 625   IConnectionPoint_Release(&Obj->IConnectionPoint_iface);
 626   return hr;
 627 }