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