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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22
  23 #include <stdarg.h>
  24 #include <string.h>
  25
  26 #define COBJMACROS
  27 #define NONAMELESSUNION
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winuser.h"
  32 #include "winerror.h"
  33 #include "wine/debug.h"
  34 #include "ole2.h"
  35
  36 #include "compobj_private.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  39
  40 #define INITIAL_SINKS 10
  41
  42 static void release_statdata(STATDATA *data)
  43 {
  44     if(data->formatetc.ptd)
  45     {
  46         CoTaskMemFree(data->formatetc.ptd);
  47         data->formatetc.ptd = NULL;
  48     }
  49
  50     if(data->pAdvSink)
  51     {
  52         IAdviseSink_Release(data->pAdvSink);
  53         data->pAdvSink = NULL;
  54     }
  55 }
  56
  57 static HRESULT copy_statdata(STATDATA *dst, const STATDATA *src)
  58 {
  59     *dst = *src;
  60     if(src->formatetc.ptd)
  61     {
  62         dst->formatetc.ptd = CoTaskMemAlloc(src->formatetc.ptd->tdSize);
  63         if(!dst->formatetc.ptd) return E_OUTOFMEMORY;
  64         memcpy(dst->formatetc.ptd, src->formatetc.ptd, src->formatetc.ptd->tdSize);
  65     }
  66     if(dst->pAdvSink) IAdviseSink_AddRef(dst->pAdvSink);
  67     return S_OK;
  68 }
  69
  70 /**************************************************************************
  71  *  EnumSTATDATA Implementation
  72  */
  73
  74 static HRESULT EnumSTATDATA_Construct(IUnknown *holder, ULONG index, DWORD array_len, STATDATA *data, IEnumSTATDATA **ppenum);
  75
  76 typedef struct
  77 {
  78     IEnumSTATDATA IEnumSTATDATA_iface;
  79     LONG ref;
  80
  81     ULONG index;
  82     DWORD num_of_elems;
  83     STATDATA *statdata;
  84     IUnknown *holder;
  85 } EnumSTATDATA;
  86
  87 static inline EnumSTATDATA *impl_from_IEnumSTATDATA(IEnumSTATDATA *iface)
  88 {
  89     return CONTAINING_RECORD(iface, EnumSTATDATA, IEnumSTATDATA_iface);
  90 }
  91
  92 static HRESULT WINAPI EnumSTATDATA_QueryInterface(IEnumSTATDATA *iface, REFIID riid, void **ppv)
  93 {
  94     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
  95     if (IsEqualIID(riid, &IID_IUnknown) ||
  96         IsEqualIID(riid, &IID_IEnumSTATDATA))
  97     {
  98         IEnumSTATDATA_AddRef(iface);
  99         *ppv = iface;
 100         return S_OK;
 101     }
 102     return E_NOINTERFACE;
 103 }
 104
 105 static ULONG WINAPI EnumSTATDATA_AddRef(IEnumSTATDATA *iface)
 106 {
 107     EnumSTATDATA *This = impl_from_IEnumSTATDATA(iface);
 108     TRACE("()\n");
 109     return InterlockedIncrement(&This->ref);
 110 }
 111
 112 static ULONG WINAPI EnumSTATDATA_Release(IEnumSTATDATA *iface)
 113 {
 114     EnumSTATDATA *This = impl_from_IEnumSTATDATA(iface);
 115     LONG refs = InterlockedDecrement(&This->ref);
 116     TRACE("()\n");
 117     if (!refs)
 118     {
 119         DWORD i;
 120         for(i = 0; i < This->num_of_elems; i++)
 121             release_statdata(This->statdata + i);
 122         HeapFree(GetProcessHeap(), 0, This->statdata);
 123         IUnknown_Release(This->holder);
 124         HeapFree(GetProcessHeap(), 0, This);
 125     }
 126     return refs;
 127 }
 128
 129 static HRESULT WINAPI EnumSTATDATA_Next(IEnumSTATDATA *iface, ULONG num, LPSTATDATA data,
 130                                         ULONG *fetched)
 131 {
 132     EnumSTATDATA *This = impl_from_IEnumSTATDATA(iface);
 133     DWORD count = 0;
 134     HRESULT hr = S_OK;
 135
 136     TRACE("(%d, %p, %p)\n", num, data, fetched);
 137
 138     while(num--)
 139     {
 140         if (This->index >= This->num_of_elems)
 141         {
 142             hr = S_FALSE;
 143             break;
 144         }
 145
 146         copy_statdata(data + count, This->statdata + This->index);
 147
 148         count++;
 149         This->index++;
 150     }
 151
 152     if (fetched) *fetched = count;
 153
 154     return hr;
 155 }
 156
 157 static HRESULT WINAPI EnumSTATDATA_Skip(IEnumSTATDATA *iface, ULONG num)
 158 {
 159     EnumSTATDATA *This = impl_from_IEnumSTATDATA(iface);
 160
 161     TRACE("(%d)\n", num);
 162
 163     if(This->index + num >= This->num_of_elems)
 164     {
 165         This->index = This->num_of_elems;
 166         return S_FALSE;
 167     }
 168
 169     This->index += num;
 170     return S_OK;
 171 }
 172
 173 static HRESULT WINAPI EnumSTATDATA_Reset(IEnumSTATDATA *iface)
 174 {
 175     EnumSTATDATA *This = impl_from_IEnumSTATDATA(iface);
 176
 177     TRACE("()\n");
 178
 179     This->index = 0;
 180     return S_OK;
 181 }
 182
 183 static HRESULT WINAPI EnumSTATDATA_Clone(IEnumSTATDATA *iface, IEnumSTATDATA **ppenum)
 184 {
 185     EnumSTATDATA *This = impl_from_IEnumSTATDATA(iface);
 186
 187     return EnumSTATDATA_Construct(This->holder, This->index, This->num_of_elems, This->statdata, ppenum);
 188 }
 189
 190 static const IEnumSTATDATAVtbl EnumSTATDATA_VTable =
 191 {
 192     EnumSTATDATA_QueryInterface,
 193     EnumSTATDATA_AddRef,
 194     EnumSTATDATA_Release,
 195     EnumSTATDATA_Next,
 196     EnumSTATDATA_Skip,
 197     EnumSTATDATA_Reset,
 198     EnumSTATDATA_Clone
 199 };
 200
 201 static HRESULT EnumSTATDATA_Construct(IUnknown *holder, ULONG index, DWORD array_len, STATDATA *data,
 202                                       IEnumSTATDATA **ppenum)
 203 {
 204     EnumSTATDATA *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 205     DWORD i, count;
 206
 207     if (!This) return E_OUTOFMEMORY;
 208
 209     This->IEnumSTATDATA_iface.lpVtbl = &EnumSTATDATA_VTable;
 210     This->ref = 1;
 211     This->index = index;
 212
 213     This->statdata = HeapAlloc(GetProcessHeap(), 0, array_len * sizeof(*This->statdata));
 214     if(!This->statdata)
 215     {
 216         HeapFree(GetProcessHeap(), 0, This);
 217         return E_OUTOFMEMORY;
 218     }
 219
 220     for(i = 0, count = 0; i < array_len; i++)
 221     {
 222         if(data[i].pAdvSink)
 223         {
 224             copy_statdata(This->statdata + count, data + i);
 225             count++;
 226         }
 227     }
 228
 229     This->num_of_elems = count;
 230     This->holder = holder;
 231     IUnknown_AddRef(holder);
 232     *ppenum = &This->IEnumSTATDATA_iface;
 233     return S_OK;
 234 }
 235
 236 /**************************************************************************
 237  *  OleAdviseHolder Implementation
 238  */
 239 typedef struct
 240 {
 241     IOleAdviseHolder IOleAdviseHolder_iface;
 242
 243     LONG ref;
 244
 245     DWORD max_cons;
 246     STATDATA *connections;
 247 } OleAdviseHolderImpl;
 248
 249 static inline OleAdviseHolderImpl *impl_from_IOleAdviseHolder(IOleAdviseHolder *iface)
 250 {
 251     return CONTAINING_RECORD(iface, OleAdviseHolderImpl, IOleAdviseHolder_iface);
 252 }
 253
 254 /**************************************************************************
 255  *  OleAdviseHolderImpl_Destructor
 256  */
 257 static void OleAdviseHolderImpl_Destructor(OleAdviseHolderImpl *This)
 258 {
 259     DWORD index;
 260     TRACE("%p\n", This);
 261
 262     for (index = 0; index < This->max_cons; index++)
 263     {
 264         if (This->connections[index].pAdvSink != NULL)
 265             release_statdata(This->connections + index);
 266     }
 267
 268     HeapFree(GetProcessHeap(), 0, This->connections);
 269     HeapFree(GetProcessHeap(), 0, This);
 270 }
 271
 272 /**************************************************************************
 273  *  OleAdviseHolderImpl_QueryInterface
 274  */
 275 static HRESULT WINAPI OleAdviseHolderImpl_QueryInterface(IOleAdviseHolder *iface,
 276                                                          REFIID iid, void **obj)
 277 {
 278   OleAdviseHolderImpl *This = impl_from_IOleAdviseHolder(iface);
 279   TRACE("(%p)->(%s,%p)\n",This, debugstr_guid(iid), obj);
 280
 281   if (obj == NULL)
 282     return E_POINTER;
 283
 284   *obj = NULL;
 285
 286   if (IsEqualIID(iid, &IID_IUnknown) ||
 287       IsEqualIID(iid, &IID_IOleAdviseHolder))
 288   {
 289     *obj = &This->IOleAdviseHolder_iface;
 290   }
 291
 292   if(*obj == NULL)
 293     return E_NOINTERFACE;
 294
 295   IUnknown_AddRef((IUnknown*)*obj);
 296
 297   return S_OK;
 298 }
 299
 300 /******************************************************************************
 301  * OleAdviseHolderImpl_AddRef
 302  */
 303 static ULONG WINAPI OleAdviseHolderImpl_AddRef(IOleAdviseHolder *iface)
 304 {
 305   OleAdviseHolderImpl *This = impl_from_IOleAdviseHolder(iface);
 306   ULONG ref = InterlockedIncrement(&This->ref);
 307
 308   TRACE("(%p)->(ref=%d)\n", This, ref - 1);
 309
 310   return ref;
 311 }
 312
 313 /******************************************************************************
 314  * OleAdviseHolderImpl_Release
 315  */
 316 static ULONG WINAPI OleAdviseHolderImpl_Release(IOleAdviseHolder *iface)
 317 {
 318   OleAdviseHolderImpl *This = impl_from_IOleAdviseHolder(iface);
 319   ULONG ref;
 320   TRACE("(%p)->(ref=%d)\n", This, This->ref);
 321   ref = InterlockedDecrement(&This->ref);
 322
 323   if (ref == 0) OleAdviseHolderImpl_Destructor(This);
 324
 325   return ref;
 326 }
 327
 328 /******************************************************************************
 329  * OleAdviseHolderImpl_Advise
 330  */
 331 static HRESULT WINAPI OleAdviseHolderImpl_Advise(IOleAdviseHolder *iface,
 332                                                  IAdviseSink *pAdvise,
 333                                                  DWORD *pdwConnection)
 334 {
 335   DWORD index;
 336   OleAdviseHolderImpl *This = impl_from_IOleAdviseHolder(iface);
 337   STATDATA new_conn;
 338   static const FORMATETC empty_fmtetc = {0, NULL, 0, -1, 0};
 339
 340   TRACE("(%p)->(%p, %p)\n", This, pAdvise, pdwConnection);
 341
 342   if (pdwConnection==NULL)
 343     return E_POINTER;
 344
 345   *pdwConnection = 0;
 346
 347   for (index = 0; index < This->max_cons; index++)
 348   {
 349     if (This->connections[index].pAdvSink == NULL)
 350       break;
 351   }
 352
 353   if (index == This->max_cons)
 354   {
 355     This->max_cons += INITIAL_SINKS;
 356     This->connections = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->connections,
 357                                     This->max_cons * sizeof(*This->connections));
 358   }
 359
 360   new_conn.pAdvSink = pAdvise;
 361   new_conn.advf = 0;
 362   new_conn.formatetc = empty_fmtetc;
 363   new_conn.dwConnection = index + 1; /* 0 is not a valid cookie, so increment the index */
 364
 365   copy_statdata(This->connections + index, &new_conn);
 366
 367   *pdwConnection = new_conn.dwConnection;
 368
 369   return S_OK;
 370 }
 371
 372 /******************************************************************************
 373  * OleAdviseHolderImpl_Unadvise
 374  */
 375 static HRESULT WINAPI OleAdviseHolderImpl_Unadvise(IOleAdviseHolder *iface,
 376                                                    DWORD dwConnection)
 377 {
 378   OleAdviseHolderImpl *This = impl_from_IOleAdviseHolder(iface);
 379   DWORD index;
 380
 381   TRACE("(%p)->(%u)\n", This, dwConnection);
 382
 383   /* The connection number is 1 more than the index, see OleAdviseHolder_Advise */
 384   index = dwConnection - 1;
 385
 386   if (index >= This->max_cons || This->connections[index].pAdvSink == NULL)
 387      return OLE_E_NOCONNECTION;
 388
 389   release_statdata(This->connections + index);
 390
 391   return S_OK;
 392 }
 393
 394 /******************************************************************************
 395  * OleAdviseHolderImpl_EnumAdvise
 396  */
 397 static HRESULT WINAPI OleAdviseHolderImpl_EnumAdvise(IOleAdviseHolder *iface, IEnumSTATDATA **enum_advise)
 398 {
 399     OleAdviseHolderImpl *This = impl_from_IOleAdviseHolder(iface);
 400     IUnknown *unk;
 401     HRESULT hr;
 402
 403     TRACE("(%p)->(%p)\n", This, enum_advise);
 404
 405     IOleAdviseHolder_QueryInterface(iface, &IID_IUnknown, (void**)&unk);
 406     hr = EnumSTATDATA_Construct(unk, 0, This->max_cons, This->connections, enum_advise);
 407     IUnknown_Release(unk);
 408     return hr;
 409 }
 410
 411 /******************************************************************************
 412  * OleAdviseHolderImpl_SendOnRename
 413  */
 414 static HRESULT WINAPI OleAdviseHolderImpl_SendOnRename(IOleAdviseHolder *iface, IMoniker *pmk)
 415 {
 416     IEnumSTATDATA *pEnum;
 417     HRESULT hr;
 418
 419     TRACE("(%p)->(%p)\n", iface, pmk);
 420
 421     hr = IOleAdviseHolder_EnumAdvise(iface, &pEnum);
 422     if (SUCCEEDED(hr))
 423     {
 424         STATDATA statdata;
 425         while (IEnumSTATDATA_Next(pEnum, 1, &statdata, NULL) == S_OK)
 426         {
 427             IAdviseSink_OnRename(statdata.pAdvSink, pmk);
 428
 429             IAdviseSink_Release(statdata.pAdvSink);
 430         }
 431         IEnumSTATDATA_Release(pEnum);
 432     }
 433
 434     return hr;
 435 }
 436
 437 /******************************************************************************
 438  * OleAdviseHolderImpl_SendOnSave
 439  */
 440 static HRESULT WINAPI OleAdviseHolderImpl_SendOnSave(IOleAdviseHolder *iface)
 441 {
 442     IEnumSTATDATA *pEnum;
 443     HRESULT hr;
 444
 445     TRACE("(%p)->()\n", iface);
 446
 447     hr = IOleAdviseHolder_EnumAdvise(iface, &pEnum);
 448     if (SUCCEEDED(hr))
 449     {
 450         STATDATA statdata;
 451         while (IEnumSTATDATA_Next(pEnum, 1, &statdata, NULL) == S_OK)
 452         {
 453             IAdviseSink_OnSave(statdata.pAdvSink);
 454
 455             IAdviseSink_Release(statdata.pAdvSink);
 456         }
 457         IEnumSTATDATA_Release(pEnum);
 458     }
 459
 460     return hr;
 461 }
 462
 463 /******************************************************************************
 464  * OleAdviseHolderImpl_SendOnClose
 465  */
 466 static HRESULT WINAPI OleAdviseHolderImpl_SendOnClose(IOleAdviseHolder *iface)
 467 {
 468     IEnumSTATDATA *pEnum;
 469     HRESULT hr;
 470
 471     TRACE("(%p)->()\n", iface);
 472
 473     hr = IOleAdviseHolder_EnumAdvise(iface, &pEnum);
 474     if (SUCCEEDED(hr))
 475     {
 476         STATDATA statdata;
 477         while (IEnumSTATDATA_Next(pEnum, 1, &statdata, NULL) == S_OK)
 478         {
 479             IAdviseSink_OnClose(statdata.pAdvSink);
 480
 481             IAdviseSink_Release(statdata.pAdvSink);
 482         }
 483         IEnumSTATDATA_Release(pEnum);
 484     }
 485
 486     return hr;
 487 }
 488
 489 /**************************************************************************
 490  *  OleAdviseHolderImpl_VTable
 491  */
 492 static const IOleAdviseHolderVtbl oahvt =
 493 {
 494     OleAdviseHolderImpl_QueryInterface,
 495     OleAdviseHolderImpl_AddRef,
 496     OleAdviseHolderImpl_Release,
 497     OleAdviseHolderImpl_Advise,
 498     OleAdviseHolderImpl_Unadvise,
 499     OleAdviseHolderImpl_EnumAdvise,
 500     OleAdviseHolderImpl_SendOnRename,
 501     OleAdviseHolderImpl_SendOnSave,
 502     OleAdviseHolderImpl_SendOnClose
 503 };
 504
 505 /**************************************************************************
 506  *  OleAdviseHolderImpl_Constructor
 507  */
 508
 509 static IOleAdviseHolder *OleAdviseHolderImpl_Constructor(void)
 510 {
 511   OleAdviseHolderImpl* lpoah;
 512
 513   lpoah = HeapAlloc(GetProcessHeap(), 0, sizeof(OleAdviseHolderImpl));
 514
 515   lpoah->IOleAdviseHolder_iface.lpVtbl = &oahvt;
 516   lpoah->ref = 1;
 517   lpoah->max_cons = INITIAL_SINKS;
 518   lpoah->connections = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 519                                  lpoah->max_cons * sizeof(*lpoah->connections));
 520
 521   TRACE("returning %p\n",  &lpoah->IOleAdviseHolder_iface);
 522   return &lpoah->IOleAdviseHolder_iface;
 523 }
 524
 525 /**************************************************************************
 526  *  DataAdviseHolder Implementation
 527  */
 528 typedef struct
 529 {
 530   IDataAdviseHolder     IDataAdviseHolder_iface;
 531
 532   LONG                  ref;
 533   DWORD                 maxCons;
 534   STATDATA*             connections;
 535   DWORD*                remote_connections;
 536   IDataObject*          delegate;
 537 } DataAdviseHolder;
 538
 539 /* this connection has also has been advised to the delegate data object */
 540 #define WINE_ADVF_REMOTE 0x80000000
 541
 542 static inline DataAdviseHolder *impl_from_IDataAdviseHolder(IDataAdviseHolder *iface)
 543 {
 544     return CONTAINING_RECORD(iface, DataAdviseHolder, IDataAdviseHolder_iface);
 545 }
 546
 547 /******************************************************************************
 548  * DataAdviseHolder_Destructor
 549  */
 550 static void DataAdviseHolder_Destructor(DataAdviseHolder* ptrToDestroy)
 551 {
 552   DWORD index;
 553   TRACE("%p\n", ptrToDestroy);
 554
 555   for (index = 0; index < ptrToDestroy->maxCons; index++)
 556   {
 557     if (ptrToDestroy->connections[index].pAdvSink != NULL)
 558     {
 559       if (ptrToDestroy->delegate &&
 560           (ptrToDestroy->connections[index].advf & WINE_ADVF_REMOTE))
 561         IDataObject_DUnadvise(ptrToDestroy->delegate,
 562           ptrToDestroy->remote_connections[index]);
 563
 564       release_statdata(ptrToDestroy->connections + index);
 565     }
 566   }
 567
 568   HeapFree(GetProcessHeap(), 0, ptrToDestroy->remote_connections);
 569   HeapFree(GetProcessHeap(), 0, ptrToDestroy->connections);
 570   HeapFree(GetProcessHeap(), 0, ptrToDestroy);
 571 }
 572
 573 /************************************************************************
 574  * DataAdviseHolder_QueryInterface (IUnknown)
 575  */
 576 static HRESULT WINAPI DataAdviseHolder_QueryInterface(IDataAdviseHolder *iface,
 577                                                       REFIID riid, void **ppvObject)
 578 {
 579   DataAdviseHolder *This = impl_from_IDataAdviseHolder(iface);
 580   TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppvObject);
 581
 582   if ( (This==0) || (ppvObject==0) )
 583     return E_INVALIDARG;
 584
 585   *ppvObject = 0;
 586
 587   if ( IsEqualIID(&IID_IUnknown, riid) ||
 588        IsEqualIID(&IID_IDataAdviseHolder, riid)  )
 589   {
 590     *ppvObject = iface;
 591   }
 592
 593   if ((*ppvObject)==0)
 594   {
 595     return E_NOINTERFACE;
 596   }
 597
 598   IUnknown_AddRef((IUnknown*)*ppvObject);
 599   return S_OK;
 600 }
 601
 602 /************************************************************************
 603  * DataAdviseHolder_AddRef (IUnknown)
 604  */
 605 static ULONG WINAPI DataAdviseHolder_AddRef(IDataAdviseHolder *iface)
 606 {
 607   DataAdviseHolder *This = impl_from_IDataAdviseHolder(iface);
 608   TRACE("(%p) (ref=%d)\n", This, This->ref);
 609   return InterlockedIncrement(&This->ref);
 610 }
 611
 612 /************************************************************************
 613  * DataAdviseHolder_Release (IUnknown)
 614  */
 615 static ULONG WINAPI DataAdviseHolder_Release(IDataAdviseHolder *iface)
 616 {
 617   DataAdviseHolder *This = impl_from_IDataAdviseHolder(iface);
 618   ULONG ref;
 619   TRACE("(%p) (ref=%d)\n", This, This->ref);
 620
 621   ref = InterlockedDecrement(&This->ref);
 622   if (ref==0) DataAdviseHolder_Destructor(This);
 623
 624   return ref;
 625 }
 626
 627 /************************************************************************
 628  * DataAdviseHolder_Advise
 629  *
 630  */
 631 static HRESULT WINAPI DataAdviseHolder_Advise(IDataAdviseHolder *iface,
 632                                               IDataObject *pDataObject, FORMATETC *pFetc,
 633                                               DWORD advf, IAdviseSink *pAdvise,
 634                                               DWORD *pdwConnection)
 635 {
 636   DWORD index;
 637   STATDATA new_conn;
 638   DataAdviseHolder *This = impl_from_IDataAdviseHolder(iface);
 639
 640   TRACE("(%p)->(%p, %p, %08x, %p, %p)\n", This, pDataObject, pFetc, advf,
 641         pAdvise, pdwConnection);
 642
 643   if (pdwConnection==NULL)
 644     return E_POINTER;
 645
 646   *pdwConnection = 0;
 647
 648   for (index = 0; index < This->maxCons; index++)
 649   {
 650     if (This->connections[index].pAdvSink == NULL)
 651       break;
 652   }
 653
 654   if (index == This->maxCons)
 655   {
 656     This->maxCons+=INITIAL_SINKS;
 657     This->connections = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 658                                     This->connections,
 659                                     This->maxCons * sizeof(*This->connections));
 660     This->remote_connections = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 661                                            This->remote_connections,
 662                                            This->maxCons * sizeof(*This->remote_connections));
 663   }
 664
 665   new_conn.pAdvSink = pAdvise;
 666   new_conn.advf = advf & ~WINE_ADVF_REMOTE;
 667   new_conn.formatetc = *pFetc;
 668   new_conn.dwConnection = index + 1; /* 0 is not a valid cookie, so increment the index */
 669
 670   copy_statdata(This->connections + index, &new_conn);
 671
 672   if (This->connections[index].pAdvSink != NULL)
 673   {
 674     /* if we are already connected advise the remote object */
 675     if (This->delegate)
 676     {
 677         HRESULT hr;
 678
 679         hr = IDataObject_DAdvise(This->delegate, &new_conn.formatetc,
 680                                  new_conn.advf, new_conn.pAdvSink,
 681                                  &This->remote_connections[index]);
 682         if (FAILED(hr))
 683         {
 684             IDataAdviseHolder_Unadvise(iface, new_conn.dwConnection);
 685             return hr;
 686         }
 687         This->connections[index].advf |= WINE_ADVF_REMOTE;
 688     }
 689     else if(advf & ADVF_PRIMEFIRST)
 690       /* only do this if we have no delegate, since in the above case the
 691        * delegate will do the priming for us */
 692       IDataAdviseHolder_SendOnDataChange(iface, pDataObject, 0, advf);
 693   }
 694
 695   *pdwConnection = new_conn.dwConnection;
 696
 697   return S_OK;
 698 }
 699
 700 /******************************************************************************
 701  * DataAdviseHolder_Unadvise
 702  */
 703 static HRESULT WINAPI DataAdviseHolder_Unadvise(IDataAdviseHolder *iface,
 704                                                 DWORD dwConnection)
 705 {
 706   DataAdviseHolder *This = impl_from_IDataAdviseHolder(iface);
 707   DWORD index;
 708   TRACE("(%p)->(%u)\n", This, dwConnection);
 709
 710   /* The connection number is 1 more than the index, see DataAdviseHolder_Advise */
 711   index = dwConnection - 1;
 712
 713   if (index >= This->maxCons || This->connections[index].pAdvSink == NULL)
 714      return OLE_E_NOCONNECTION;
 715
 716   if (This->delegate && This->connections[index].advf & WINE_ADVF_REMOTE)
 717   {
 718     IDataObject_DUnadvise(This->delegate, This->remote_connections[index]);
 719     This->remote_connections[index] = 0;
 720   }
 721
 722   release_statdata(This->connections + index);
 723
 724   return S_OK;
 725 }
 726
 727 /******************************************************************************
 728  * DataAdviseHolder_EnumAdvise
 729  */
 730 static HRESULT WINAPI DataAdviseHolder_EnumAdvise(IDataAdviseHolder *iface,
 731                                                   IEnumSTATDATA **enum_advise)
 732 {
 733     DataAdviseHolder *This = impl_from_IDataAdviseHolder(iface);
 734     IUnknown *unk;
 735     HRESULT hr;
 736
 737     TRACE("(%p)->(%p)\n", This, enum_advise);
 738
 739     IDataAdviseHolder_QueryInterface(iface, &IID_IUnknown, (void**)&unk);
 740     hr = EnumSTATDATA_Construct(unk, 0, This->maxCons, This->connections, enum_advise);
 741     IUnknown_Release(unk);
 742     return hr;
 743 }
 744
 745 /******************************************************************************
 746  * DataAdviseHolder_SendOnDataChange
 747  */
 748 static HRESULT WINAPI DataAdviseHolder_SendOnDataChange(IDataAdviseHolder *iface,
 749                                                         IDataObject *data_obj,
 750                                                         DWORD dwReserved, DWORD advf)
 751 {
 752     IEnumSTATDATA *pEnum;
 753     HRESULT hr;
 754
 755     TRACE("(%p)->(%p, %08x, %08x)\n", iface, data_obj, dwReserved, advf);
 756
 757     hr = IDataAdviseHolder_EnumAdvise(iface, &pEnum);
 758     if (SUCCEEDED(hr))
 759     {
 760         STATDATA statdata;
 761         while (IEnumSTATDATA_Next(pEnum, 1, &statdata, NULL) == S_OK)
 762         {
 763             STGMEDIUM stg;
 764             stg.tymed = TYMED_NULL;
 765             stg.u.pstg = NULL;
 766             stg.pUnkForRelease = NULL;
 767
 768             if(!(statdata.advf & ADVF_NODATA))
 769             {
 770                 hr = IDataObject_GetData(data_obj, &statdata.formatetc, &stg);
 771             }
 772
 773             IAdviseSink_OnDataChange(statdata.pAdvSink, &statdata.formatetc, &stg);
 774
 775             if(statdata.advf & ADVF_ONLYONCE)
 776             {
 777                 IDataAdviseHolder_Unadvise(iface, statdata.dwConnection);
 778             }
 779
 780             release_statdata(&statdata);
 781         }
 782         IEnumSTATDATA_Release(pEnum);
 783     }
 784
 785     return S_OK;
 786 }
 787
 788 /**************************************************************************
 789  *  DataAdviseHolderImpl_VTable
 790  */
 791 static const IDataAdviseHolderVtbl DataAdviseHolderImpl_VTable =
 792 {
 793   DataAdviseHolder_QueryInterface,
 794   DataAdviseHolder_AddRef,
 795   DataAdviseHolder_Release,
 796   DataAdviseHolder_Advise,
 797   DataAdviseHolder_Unadvise,
 798   DataAdviseHolder_EnumAdvise,
 799   DataAdviseHolder_SendOnDataChange
 800 };
 801
 802 HRESULT DataAdviseHolder_OnConnect(IDataAdviseHolder *iface, IDataObject *pDelegate)
 803 {
 804   DataAdviseHolder *This = impl_from_IDataAdviseHolder(iface);
 805   DWORD index;
 806   HRESULT hr = S_OK;
 807
 808   for(index = 0; index < This->maxCons; index++)
 809   {
 810     if(This->connections[index].pAdvSink != NULL)
 811     {
 812       hr = IDataObject_DAdvise(pDelegate, &This->connections[index].formatetc,
 813                                This->connections[index].advf,
 814                                This->connections[index].pAdvSink,
 815                                &This->remote_connections[index]);
 816       if (FAILED(hr)) break;
 817       This->connections[index].advf |= WINE_ADVF_REMOTE;
 818     }
 819   }
 820   This->delegate = pDelegate;
 821   return hr;
 822 }
 823
 824 void DataAdviseHolder_OnDisconnect(IDataAdviseHolder *iface)
 825 {
 826   DataAdviseHolder *This = impl_from_IDataAdviseHolder(iface);
 827   DWORD index;
 828
 829   for(index = 0; index < This->maxCons; index++)
 830   {
 831     if((This->connections[index].pAdvSink != NULL) &&
 832        (This->connections[index].advf & WINE_ADVF_REMOTE))
 833     {
 834       IDataObject_DUnadvise(This->delegate, This->remote_connections[index]);
 835       This->remote_connections[index] = 0;
 836       This->connections[index].advf &= ~WINE_ADVF_REMOTE;
 837     }
 838   }
 839   This->delegate = NULL;
 840 }
 841
 842 /******************************************************************************
 843  * DataAdviseHolder_Constructor
 844  */
 845 static IDataAdviseHolder *DataAdviseHolder_Constructor(void)
 846 {
 847   DataAdviseHolder* newHolder;
 848
 849   newHolder = HeapAlloc(GetProcessHeap(), 0, sizeof(DataAdviseHolder));
 850
 851   newHolder->IDataAdviseHolder_iface.lpVtbl = &DataAdviseHolderImpl_VTable;
 852   newHolder->ref = 1;
 853   newHolder->maxCons = INITIAL_SINKS;
 854   newHolder->connections = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 855                                      newHolder->maxCons * sizeof(*newHolder->connections));
 856   newHolder->remote_connections = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 857                                             newHolder->maxCons * sizeof(*newHolder->remote_connections));
 858   newHolder->delegate = NULL;
 859
 860   TRACE("returning %p\n", &newHolder->IDataAdviseHolder_iface);
 861   return &newHolder->IDataAdviseHolder_iface;
 862 }
 863
 864 /***********************************************************************
 865  * API functions
 866  */
 867
 868 /***********************************************************************
 869  * CreateOleAdviseHolder [OLE32.@]
 870  */
 871 HRESULT WINAPI CreateOleAdviseHolder(IOleAdviseHolder **ppOAHolder)
 872 {
 873   TRACE("(%p)\n", ppOAHolder);
 874
 875   if (ppOAHolder==NULL)
 876     return E_POINTER;
 877
 878   *ppOAHolder = OleAdviseHolderImpl_Constructor ();
 879
 880   if (*ppOAHolder != NULL)
 881     return S_OK;
 882
 883   return E_OUTOFMEMORY;
 884 }
 885
 886 /******************************************************************************
 887  *              CreateDataAdviseHolder        [OLE32.@]
 888  */
 889 HRESULT WINAPI CreateDataAdviseHolder(IDataAdviseHolder **ppDAHolder)
 890 {
 891   TRACE("(%p)\n", ppDAHolder);
 892
 893   if (ppDAHolder==NULL)
 894     return E_POINTER;
 895
 896   *ppDAHolder = DataAdviseHolder_Constructor();
 897
 898   if (*ppDAHolder != NULL)
 899     return S_OK;
 900
 901   return E_OUTOFMEMORY;
 902 }