dlls/ole32/oleobj.c

   1 /*
   2  *      OLE2 COM objects
   3  *
   4  *      Copyright 1998 Eric Kohl
   5  *      Copyright 1999 Francis Beaudet
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22
  23 #include <stdarg.h>
  24 #include <string.h>
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winerror.h"
  28 #include "wine/debug.h"
  29 #include "ole2.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  32
  33 #define INITIAL_SINKS 10
  34
  35 /**************************************************************************
  36  *  OleAdviseHolderImpl Implementation
  37  */
  38 typedef struct OleAdviseHolderImpl
  39 {
  40   ICOM_VFIELD(IOleAdviseHolder);
  41
  42   DWORD ref;
  43
  44   DWORD         maxSinks;
  45   IAdviseSink** arrayOfSinks;
  46
  47 } OleAdviseHolderImpl;
  48
  49 static LPOLEADVISEHOLDER OleAdviseHolderImpl_Constructor();
  50 static void              OleAdviseHolderImpl_Destructor(OleAdviseHolderImpl* ptrToDestroy);
  51 static HRESULT WINAPI    OleAdviseHolderImpl_QueryInterface(LPOLEADVISEHOLDER,REFIID,LPVOID*);
  52 static ULONG WINAPI      OleAdviseHolderImpl_AddRef(LPOLEADVISEHOLDER);
  53 static ULONG WINAPI      OleAdviseHolderImpl_Release(LPOLEADVISEHOLDER);
  54 static HRESULT WINAPI    OleAdviseHolderImpl_Advise(LPOLEADVISEHOLDER, IAdviseSink*, DWORD*);
  55 static HRESULT WINAPI    OleAdviseHolderImpl_Unadvise (LPOLEADVISEHOLDER, DWORD);
  56 static HRESULT WINAPI    OleAdviseHolderImpl_EnumAdvise (LPOLEADVISEHOLDER, IEnumSTATDATA **);
  57 static HRESULT WINAPI    OleAdviseHolderImpl_SendOnRename (LPOLEADVISEHOLDER, IMoniker *);
  58 static HRESULT WINAPI    OleAdviseHolderImpl_SendOnSave (LPOLEADVISEHOLDER);
  59 static HRESULT WINAPI    OleAdviseHolderImpl_SendOnClose (LPOLEADVISEHOLDER);
  60
  61
  62 /**************************************************************************
  63  *  OleAdviseHolderImpl_VTable
  64  */
  65 static struct ICOM_VTABLE(IOleAdviseHolder) oahvt =
  66 {
  67     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
  68     OleAdviseHolderImpl_QueryInterface,
  69     OleAdviseHolderImpl_AddRef,
  70     OleAdviseHolderImpl_Release,
  71     OleAdviseHolderImpl_Advise,
  72     OleAdviseHolderImpl_Unadvise,
  73     OleAdviseHolderImpl_EnumAdvise,
  74     OleAdviseHolderImpl_SendOnRename,
  75     OleAdviseHolderImpl_SendOnSave,
  76     OleAdviseHolderImpl_SendOnClose
  77 };
  78
  79 /**************************************************************************
  80  *  OleAdviseHolderImpl_Constructor
  81  */
  82
  83 static LPOLEADVISEHOLDER OleAdviseHolderImpl_Constructor()
  84 {
  85   OleAdviseHolderImpl* lpoah;
  86   DWORD                index;
  87
  88   lpoah= (OleAdviseHolderImpl*)HeapAlloc(GetProcessHeap(),
  89                                          0,
  90                                          sizeof(OleAdviseHolderImpl));
  91
  92   lpoah->lpVtbl = &oahvt;
  93   lpoah->ref = 1;
  94   lpoah->maxSinks = INITIAL_SINKS;
  95   lpoah->arrayOfSinks = HeapAlloc(GetProcessHeap(),
  96                                   0,
  97                                   lpoah->maxSinks * sizeof(IAdviseSink*));
  98
  99   for (index = 0; index < lpoah->maxSinks; index++)
 100     lpoah->arrayOfSinks[index]=0;
 101
 102   TRACE("returning %p\n", lpoah);
 103   return (LPOLEADVISEHOLDER)lpoah;
 104 }
 105
 106 /**************************************************************************
 107  *  OleAdviseHolderImpl_Destructor
 108  */
 109 static void OleAdviseHolderImpl_Destructor(
 110   OleAdviseHolderImpl* ptrToDestroy)
 111 {
 112   DWORD index;
 113   TRACE("%p\n", ptrToDestroy);
 114
 115   for (index = 0; index < ptrToDestroy->maxSinks; index++)
 116   {
 117     if (ptrToDestroy->arrayOfSinks[index]!=0)
 118     {
 119       IAdviseSink_Release(ptrToDestroy->arrayOfSinks[index]);
 120       ptrToDestroy->arrayOfSinks[index] = NULL;
 121     }
 122   }
 123
 124   HeapFree(GetProcessHeap(),
 125            0,
 126            ptrToDestroy->arrayOfSinks);
 127
 128
 129   HeapFree(GetProcessHeap(),
 130            0,
 131            ptrToDestroy);
 132 }
 133
 134 /**************************************************************************
 135  *  OleAdviseHolderImpl_QueryInterface
 136  */
 137 static HRESULT WINAPI OleAdviseHolderImpl_QueryInterface(
 138   LPOLEADVISEHOLDER iface,
 139   REFIID            riid,
 140   LPVOID*           ppvObj)
 141 {
 142   ICOM_THIS(OleAdviseHolderImpl, iface);
 143   TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppvObj);
 144   /*
 145    * Sanity check
 146    */
 147   if (ppvObj==NULL)
 148     return E_POINTER;
 149
 150   *ppvObj = NULL;
 151
 152   if (IsEqualIID(riid, &IID_IUnknown))
 153   {
 154     /* IUnknown */
 155     *ppvObj = This;
 156   }
 157   else if(IsEqualIID(riid, &IID_IOleAdviseHolder))
 158   {
 159     /* IOleAdviseHolder */
 160     *ppvObj = (IOleAdviseHolder*) This;
 161   }
 162
 163   if(*ppvObj == NULL)
 164     return E_NOINTERFACE;
 165
 166   /*
 167    * A successful QI always increments the reference count.
 168    */
 169   IUnknown_AddRef((IUnknown*)*ppvObj);
 170
 171   return S_OK;
 172 }
 173
 174 /******************************************************************************
 175  * OleAdviseHolderImpl_AddRef
 176  */
 177 static ULONG WINAPI OleAdviseHolderImpl_AddRef(
 178   LPOLEADVISEHOLDER iface)
 179 {
 180   ICOM_THIS(OleAdviseHolderImpl, iface);
 181   TRACE("(%p)->(ref=%ld)\n", This, This->ref);
 182   return ++(This->ref);
 183 }
 184
 185 /******************************************************************************
 186  * OleAdviseHolderImpl_Release
 187  */
 188 static ULONG WINAPI OleAdviseHolderImpl_Release(
 189   LPOLEADVISEHOLDER iface)
 190 {
 191   ICOM_THIS(OleAdviseHolderImpl, iface);
 192   TRACE("(%p)->(ref=%ld)\n", This, This->ref);
 193   This->ref--;
 194
 195   if (This->ref == 0)
 196   {
 197     OleAdviseHolderImpl_Destructor(This);
 198
 199     return 0;
 200   }
 201
 202   return This->ref;
 203 }
 204
 205 /******************************************************************************
 206  * OleAdviseHolderImpl_Advise
 207  */
 208 static HRESULT WINAPI OleAdviseHolderImpl_Advise(
 209   LPOLEADVISEHOLDER iface,
 210   IAdviseSink*      pAdvise,
 211   DWORD*            pdwConnection)
 212 {
 213   DWORD index;
 214
 215   ICOM_THIS(OleAdviseHolderImpl, iface);
 216
 217   TRACE("(%p)->(%p, %p)\n", This, pAdvise, pdwConnection);
 218
 219   /*
 220    * Sanity check
 221    */
 222   if (pdwConnection==NULL)
 223     return E_POINTER;
 224
 225   *pdwConnection = 0;
 226
 227   /*
 228    * Find a free spot in the array.
 229    */
 230   for (index = 0; index < This->maxSinks; index++)
 231   {
 232     if (This->arrayOfSinks[index]==NULL)
 233       break;
 234   }
 235
 236   /*
 237    * If the array is full, we need to grow it.
 238    */
 239   if (index == This->maxSinks)
 240   {
 241     DWORD i;
 242
 243     This->maxSinks+=INITIAL_SINKS;
 244
 245     This->arrayOfSinks = HeapReAlloc(GetProcessHeap(),
 246                                      0,
 247                                      This->arrayOfSinks,
 248                                      This->maxSinks*sizeof(IAdviseSink*));
 249
 250     for (i=index;i < This->maxSinks; i++)
 251       This->arrayOfSinks[i]=0;
 252   }
 253
 254   /*
 255    * Store the new sink
 256    */
 257   This->arrayOfSinks[index] = pAdvise;
 258
 259   if (This->arrayOfSinks[index]!=NULL)
 260     IAdviseSink_AddRef(This->arrayOfSinks[index]);
 261
 262   /*
 263    * Return the index as the cookie.
 264    * Since 0 is not a valid cookie, we will increment by
 265    * 1 the index in the table.
 266    */
 267   *pdwConnection = index+1;
 268
 269   return S_OK;
 270 }
 271
 272 /******************************************************************************
 273  * OleAdviseHolderImpl_Unadvise
 274  */
 275 static HRESULT WINAPI OleAdviseHolderImpl_Unadvise(
 276   LPOLEADVISEHOLDER iface,
 277   DWORD             dwConnection)
 278 {
 279   ICOM_THIS(OleAdviseHolderImpl, iface);
 280
 281   TRACE("(%p)->(%lu)\n", This, dwConnection);
 282
 283   /*
 284    * So we don't return 0 as a cookie, the index was
 285    * incremented by 1 in OleAdviseHolderImpl_Advise
 286    * we have to compensate.
 287    */
 288   dwConnection--;
 289
 290   /*
 291    * Check for invalid cookies.
 292    */
 293   if (dwConnection >= This->maxSinks)
 294     return OLE_E_NOCONNECTION;
 295
 296   if (This->arrayOfSinks[dwConnection] == NULL)
 297     return OLE_E_NOCONNECTION;
 298
 299   /*
 300    * Release the sink and mark the spot in the list as free.
 301    */
 302   IAdviseSink_Release(This->arrayOfSinks[dwConnection]);
 303   This->arrayOfSinks[dwConnection] = NULL;
 304
 305   return S_OK;
 306 }
 307
 308 /******************************************************************************
 309  * OleAdviseHolderImpl_EnumAdvise
 310  */
 311 static HRESULT WINAPI
 312 OleAdviseHolderImpl_EnumAdvise (LPOLEADVISEHOLDER iface, IEnumSTATDATA **ppenumAdvise)
 313 {
 314     ICOM_THIS(OleAdviseHolderImpl, iface);
 315     FIXME("(%p)->(%p)\n", This, ppenumAdvise);
 316
 317     *ppenumAdvise = NULL;
 318
 319     return S_OK;
 320 }
 321
 322 /******************************************************************************
 323  * OleAdviseHolderImpl_SendOnRename
 324  */
 325 static HRESULT WINAPI
 326 OleAdviseHolderImpl_SendOnRename (LPOLEADVISEHOLDER iface, IMoniker *pmk)
 327 {
 328     ICOM_THIS(OleAdviseHolderImpl, iface);
 329     FIXME("(%p)->(%p)\n", This, pmk);
 330
 331
 332     return S_OK;
 333 }
 334
 335 /******************************************************************************
 336  * OleAdviseHolderImpl_SendOnSave
 337  */
 338 static HRESULT WINAPI
 339 OleAdviseHolderImpl_SendOnSave (LPOLEADVISEHOLDER iface)
 340 {
 341     ICOM_THIS(OleAdviseHolderImpl, iface);
 342     FIXME("(%p)\n", This);
 343
 344     return S_OK;
 345 }
 346
 347 /******************************************************************************
 348  * OleAdviseHolderImpl_SendOnClose
 349  */
 350 static HRESULT WINAPI
 351 OleAdviseHolderImpl_SendOnClose (LPOLEADVISEHOLDER iface)
 352 {
 353     ICOM_THIS(OleAdviseHolderImpl, iface);
 354     FIXME("(%p)\n", This);
 355
 356
 357     return S_OK;
 358 }
 359
 360 /**************************************************************************
 361  *  DataAdviseHolder Implementation
 362  */
 363 typedef struct DataAdviseConnection {
 364   IAdviseSink *sink;
 365   FORMATETC fmat;
 366   DWORD advf;
 367 } DataAdviseConnection;
 368
 369 typedef struct DataAdviseHolder
 370 {
 371   ICOM_VFIELD(IDataAdviseHolder);
 372
 373   DWORD                 ref;
 374   DWORD                 maxCons;
 375   DataAdviseConnection* Connections;
 376 } DataAdviseHolder;
 377
 378 /**************************************************************************
 379  *  DataAdviseHolder method prototypes
 380  */
 381 static IDataAdviseHolder* DataAdviseHolder_Constructor();
 382 static void               DataAdviseHolder_Destructor(DataAdviseHolder* ptrToDestroy);
 383 static HRESULT WINAPI     DataAdviseHolder_QueryInterface(
 384                             IDataAdviseHolder*      iface,
 385                             REFIID                  riid,
 386                             void**                  ppvObject);
 387 static ULONG WINAPI       DataAdviseHolder_AddRef(
 388                             IDataAdviseHolder*      iface);
 389 static ULONG WINAPI       DataAdviseHolder_Release(
 390                             IDataAdviseHolder*      iface);
 391 static HRESULT WINAPI     DataAdviseHolder_Advise(
 392                             IDataAdviseHolder*      iface,
 393                             IDataObject*            pDataObject,
 394                             FORMATETC*              pFetc,
 395                             DWORD                   advf,
 396                             IAdviseSink*            pAdvise,
 397                             DWORD*                  pdwConnection);
 398 static HRESULT WINAPI     DataAdviseHolder_Unadvise(
 399                             IDataAdviseHolder*      iface,
 400                             DWORD                   dwConnection);
 401 static HRESULT WINAPI     DataAdviseHolder_EnumAdvise(
 402                             IDataAdviseHolder*      iface,
 403                             IEnumSTATDATA**         ppenumAdvise);
 404 static HRESULT WINAPI     DataAdviseHolder_SendOnDataChange(
 405                             IDataAdviseHolder*      iface,
 406                             IDataObject*            pDataObject,
 407                             DWORD                   dwReserved,
 408                             DWORD                   advf);
 409
 410 /**************************************************************************
 411  *  DataAdviseHolderImpl_VTable
 412  */
 413 static struct ICOM_VTABLE(IDataAdviseHolder) DataAdviseHolderImpl_VTable =
 414 {
 415   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 416   DataAdviseHolder_QueryInterface,
 417   DataAdviseHolder_AddRef,
 418   DataAdviseHolder_Release,
 419   DataAdviseHolder_Advise,
 420   DataAdviseHolder_Unadvise,
 421   DataAdviseHolder_EnumAdvise,
 422   DataAdviseHolder_SendOnDataChange
 423 };
 424
 425 /******************************************************************************
 426  * DataAdviseHolder_Constructor
 427  */
 428 static IDataAdviseHolder* DataAdviseHolder_Constructor()
 429 {
 430   DataAdviseHolder* newHolder;
 431
 432   newHolder = (DataAdviseHolder*)HeapAlloc(GetProcessHeap(),
 433                                            0,
 434                                            sizeof(DataAdviseHolder));
 435
 436   newHolder->lpVtbl = &DataAdviseHolderImpl_VTable;
 437   newHolder->ref = 1;
 438   newHolder->maxCons = INITIAL_SINKS;
 439   newHolder->Connections = HeapAlloc(GetProcessHeap(),
 440                                      HEAP_ZERO_MEMORY,
 441                                      newHolder->maxCons *
 442                                      sizeof(DataAdviseConnection));
 443
 444   TRACE("returning %p\n", newHolder);
 445   return (IDataAdviseHolder*)newHolder;
 446 }
 447
 448 /******************************************************************************
 449  * DataAdviseHolder_Destructor
 450  */
 451 static void DataAdviseHolder_Destructor(DataAdviseHolder* ptrToDestroy)
 452 {
 453   DWORD index;
 454   TRACE("%p\n", ptrToDestroy);
 455
 456   for (index = 0; index < ptrToDestroy->maxCons; index++)
 457   {
 458     if (ptrToDestroy->Connections[index].sink != NULL)
 459     {
 460       IAdviseSink_Release(ptrToDestroy->Connections[index].sink);
 461       ptrToDestroy->Connections[index].sink = NULL;
 462     }
 463   }
 464
 465   HeapFree(GetProcessHeap(), 0, ptrToDestroy->Connections);
 466   HeapFree(GetProcessHeap(), 0, ptrToDestroy);
 467 }
 468
 469 /************************************************************************
 470  * DataAdviseHolder_QueryInterface (IUnknown)
 471  *
 472  * See Windows documentation for more details on IUnknown methods.
 473  */
 474 static HRESULT WINAPI DataAdviseHolder_QueryInterface(
 475   IDataAdviseHolder*      iface,
 476   REFIID                  riid,
 477   void**                  ppvObject)
 478 {
 479   ICOM_THIS(DataAdviseHolder, iface);
 480   TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppvObject);
 481   /*
 482    * Perform a sanity check on the parameters.
 483    */
 484   if ( (This==0) || (ppvObject==0) )
 485     return E_INVALIDARG;
 486
 487   /*
 488    * Initialize the return parameter.
 489    */
 490   *ppvObject = 0;
 491
 492   /*
 493    * Compare the riid with the interface IDs implemented by this object.
 494    */
 495   if ( (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0) ||
 496        (memcmp(&IID_IDataAdviseHolder, riid, sizeof(IID_IDataAdviseHolder)) == 0)  )
 497   {
 498     *ppvObject = iface;
 499   }
 500
 501   /*
 502    * Check that we obtained an interface.
 503    */
 504   if ((*ppvObject)==0)
 505   {
 506     return E_NOINTERFACE;
 507   }
 508
 509   /*
 510    * Query Interface always increases the reference count by one when it is
 511    * successful.
 512    */
 513   IUnknown_AddRef((IUnknown*)*ppvObject);
 514
 515   return S_OK;
 516 }
 517
 518 /************************************************************************
 519  * DataAdviseHolder_AddRef (IUnknown)
 520  *
 521  * See Windows documentation for more details on IUnknown methods.
 522  */
 523 static ULONG WINAPI       DataAdviseHolder_AddRef(
 524   IDataAdviseHolder*      iface)
 525 {
 526   ICOM_THIS(DataAdviseHolder, iface);
 527   TRACE("(%p) (ref=%ld)\n", This, This->ref);
 528   This->ref++;
 529
 530   return This->ref;
 531 }
 532
 533 /************************************************************************
 534  * DataAdviseHolder_Release (IUnknown)
 535  *
 536  * See Windows documentation for more details on IUnknown methods.
 537  */
 538 static ULONG WINAPI DataAdviseHolder_Release(
 539   IDataAdviseHolder*      iface)
 540 {
 541   ICOM_THIS(DataAdviseHolder, iface);
 542   TRACE("(%p) (ref=%ld)\n", This, This->ref);
 543
 544   /*
 545    * Decrease the reference count on this object.
 546    */
 547   This->ref--;
 548
 549   /*
 550    * If the reference count goes down to 0, perform suicide.
 551    */
 552   if (This->ref==0)
 553   {
 554     DataAdviseHolder_Destructor(This);
 555
 556     return 0;
 557   }
 558
 559   return This->ref;
 560 }
 561
 562 /************************************************************************
 563  * DataAdviseHolder_Advise
 564  *
 565  */
 566 static HRESULT WINAPI DataAdviseHolder_Advise(
 567   IDataAdviseHolder*      iface,
 568   IDataObject*            pDataObject,
 569   FORMATETC*              pFetc,
 570   DWORD                   advf,
 571   IAdviseSink*            pAdvise,
 572   DWORD*                  pdwConnection)
 573 {
 574   DWORD index;
 575
 576   ICOM_THIS(DataAdviseHolder, iface);
 577
 578   TRACE("(%p)->(%p, %p, %08lx, %p, %p)\n", This, pDataObject, pFetc, advf,
 579         pAdvise, pdwConnection);
 580   /*
 581    * Sanity check
 582    */
 583   if (pdwConnection==NULL)
 584     return E_POINTER;
 585
 586   *pdwConnection = 0;
 587
 588   /*
 589    * Find a free spot in the array.
 590    */
 591   for (index = 0; index < This->maxCons; index++)
 592   {
 593     if (This->Connections[index].sink == NULL)
 594       break;
 595   }
 596
 597   /*
 598    * If the array is full, we need to grow it.
 599    */
 600   if (index == This->maxCons)
 601   {
 602     This->maxCons+=INITIAL_SINKS;
 603     This->Connections = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 604                                     This->Connections,
 605                                     This->maxCons*sizeof(DataAdviseConnection));
 606   }
 607   /*
 608    * Store the new sink
 609    */
 610   This->Connections[index].sink = pAdvise;
 611   memcpy(&(This->Connections[index].fmat), pFetc, sizeof(FORMATETC));
 612   This->Connections[index].advf = advf;
 613
 614   if (This->Connections[index].sink != NULL) {
 615     IAdviseSink_AddRef(This->Connections[index].sink);
 616     if(advf & ADVF_PRIMEFIRST) {
 617       DataAdviseHolder_SendOnDataChange(iface, pDataObject, 0, advf);
 618     }
 619   }
 620   /*
 621    * Return the index as the cookie.
 622    * Since 0 is not a valid cookie, we will increment by
 623    * 1 the index in the table.
 624    */
 625   *pdwConnection = index+1;
 626
 627   return S_OK;
 628 }
 629
 630 /******************************************************************************
 631  * DataAdviseHolder_Unadvise
 632  */
 633 static HRESULT WINAPI     DataAdviseHolder_Unadvise(
 634   IDataAdviseHolder*      iface,
 635   DWORD                   dwConnection)
 636 {
 637   ICOM_THIS(DataAdviseHolder, iface);
 638
 639   TRACE("(%p)->(%lu)\n", This, dwConnection);
 640
 641   /*
 642    * So we don't return 0 as a cookie, the index was
 643    * incremented by 1 in OleAdviseHolderImpl_Advise
 644    * we have to compensate.
 645    */
 646   dwConnection--;
 647
 648   /*
 649    * Check for invalid cookies.
 650    */
 651   if (dwConnection >= This->maxCons)
 652     return OLE_E_NOCONNECTION;
 653
 654   if (This->Connections[dwConnection].sink == NULL)
 655     return OLE_E_NOCONNECTION;
 656
 657   /*
 658    * Release the sink and mark the spot in the list as free.
 659    */
 660   IAdviseSink_Release(This->Connections[dwConnection].sink);
 661   memset(&(This->Connections[dwConnection]), 0, sizeof(DataAdviseConnection));
 662   return S_OK;
 663 }
 664
 665 static HRESULT WINAPI     DataAdviseHolder_EnumAdvise(
 666   IDataAdviseHolder*      iface,
 667   IEnumSTATDATA**         ppenumAdvise)
 668 {
 669   ICOM_THIS(DataAdviseHolder, iface);
 670
 671   FIXME("(%p)->(%p)\n", This, ppenumAdvise);
 672   return E_NOTIMPL;
 673 }
 674
 675 /******************************************************************************
 676  * DataAdviseHolder_SendOnDataChange
 677  */
 678 static HRESULT WINAPI     DataAdviseHolder_SendOnDataChange(
 679   IDataAdviseHolder*      iface,
 680   IDataObject*            pDataObject,
 681   DWORD                   dwReserved,
 682   DWORD                   advf)
 683 {
 684   ICOM_THIS(DataAdviseHolder, iface);
 685   DWORD index;
 686   STGMEDIUM stg;
 687   HRESULT res;
 688
 689   TRACE("(%p)->(%p,%08lx,%08lx)\n", This, pDataObject, dwReserved, advf);
 690
 691   for(index = 0; index < This->maxCons; index++) {
 692     if(This->Connections[index].sink != NULL) {
 693       if(!(This->Connections[index].advf & ADVF_NODATA)) {
 694         TRACE("Calling IDataObject_GetData\n");
 695         res = IDataObject_GetData(pDataObject,
 696                                   &(This->Connections[index].fmat),
 697                                   &stg);
 698         TRACE("returns %08lx\n", res);
 699       }
 700       TRACE("Calling IAdviseSink_OnDataChange\n");
 701       IAdviseSink_OnDataChange(This->Connections[index].sink,
 702                                      &(This->Connections[index].fmat),
 703                                      &stg);
 704       TRACE("Done IAdviseSink_OnDataChange\n");
 705       if(This->Connections[index].advf & ADVF_ONLYONCE) {
 706         TRACE("Removing connection\n");
 707         DataAdviseHolder_Unadvise(iface, index+1);
 708       }
 709     }
 710   }
 711   return S_OK;
 712 }
 713
 714 /***********************************************************************
 715  * API functions
 716  */
 717
 718 /***********************************************************************
 719  * CreateOleAdviseHolder [OLE32.59]
 720  */
 721 HRESULT WINAPI CreateOleAdviseHolder(
 722   LPOLEADVISEHOLDER *ppOAHolder)
 723 {
 724   TRACE("(%p)\n", ppOAHolder);
 725
 726   /*
 727    * Sanity check,
 728    */
 729   if (ppOAHolder==NULL)
 730     return E_POINTER;
 731
 732   *ppOAHolder = OleAdviseHolderImpl_Constructor ();
 733
 734   if (*ppOAHolder != NULL)
 735     return S_OK;
 736
 737   return E_OUTOFMEMORY;
 738 }
 739
 740 /******************************************************************************
 741  *              CreateDataAdviseHolder        [OLE32.53]
 742  */
 743 HRESULT WINAPI CreateDataAdviseHolder(
 744   LPDATAADVISEHOLDER* ppDAHolder)
 745 {
 746   TRACE("(%p)\n", ppDAHolder);
 747
 748   /*
 749    * Sanity check,
 750    */
 751   if (ppDAHolder==NULL)
 752     return E_POINTER;
 753
 754   *ppDAHolder = DataAdviseHolder_Constructor();
 755
 756   if (*ppDAHolder != NULL)
 757     return S_OK;
 758
 759   return E_OUTOFMEMORY;
 760 }
 761