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