ReactOS  0.4.15-dev-1018-g0695ecb
oleobj.c
Go to the documentation of this file.
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 
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 {
75 
78  STATDATA *statdata;
80 } EnumSTATDATA;
81 
83 {
84  return CONTAINING_RECORD(iface, EnumSTATDATA, IEnumSTATDATA_iface);
85 }
86 
88 {
89  TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
90  if (IsEqualIID(riid, &IID_IUnknown) ||
92  {
93  IEnumSTATDATA_AddRef(iface);
94  *ppv = iface;
95  return S_OK;
96  }
97  return E_NOINTERFACE;
98 }
99 
101 {
103  TRACE("()\n");
104  return InterlockedIncrement(&This->ref);
105 }
106 
108 {
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);
120  }
121  return refs;
122 }
123 
125  ULONG *fetched)
126 {
128  DWORD count = 0;
129  HRESULT hr = S_OK;
130 
131  TRACE("(%d, %p, %p)\n", 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 
153 {
155 
156  TRACE("(%d)\n", 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 
169 {
171 
172  TRACE("()\n");
173 
174  This->index = 0;
175  return S_OK;
176 }
177 
179 {
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 {
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  {
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 {
246 
248 
250  STATDATA *connections;
252 
254 {
255  return CONTAINING_RECORD(iface, OleAdviseHolderImpl, IOleAdviseHolder_iface);
256 }
257 
258 /**************************************************************************
259  * OleAdviseHolderImpl_Destructor
260  */
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);
274 }
275 
276 /**************************************************************************
277  * OleAdviseHolderImpl_QueryInterface
278  */
280  REFIID iid, void **obj)
281 {
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) ||
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  */
308 {
311 
312  TRACE("(%p)->(ref=%d)\n", This, ref - 1);
313 
314  return ref;
315 }
316 
317 /******************************************************************************
318  * OleAdviseHolderImpl_Release
319  */
321 {
323  ULONG ref;
324  TRACE("(%p)->(ref=%d)\n", This, This->ref);
325  ref = InterlockedDecrement(&This->ref);
326 
328 
329  return ref;
330 }
331 
332 /******************************************************************************
333  * OleAdviseHolderImpl_Advise
334  */
336  IAdviseSink *pAdvise,
337  DWORD *pdwConnection)
338 {
339  DWORD index;
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  */
380  DWORD dwConnection)
381 {
383  DWORD index;
384 
385  TRACE("(%p)->(%u)\n", This, 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  */
402 {
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  */
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  */
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  */
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 {
507 };
508 
509 /**************************************************************************
510  * OleAdviseHolderImpl_Constructor
511  */
512 
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;
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 {
535 
538  STATDATA* connections;
542 
543 /* this connection has also has been advised to the delegate data object */
544 #define WINE_ADVF_REMOTE 0x80000000
545 
547 {
548  return CONTAINING_RECORD(iface, DataAdviseHolder, IDataAdviseHolder_iface);
549 }
550 
551 /******************************************************************************
552  * DataAdviseHolder_Destructor
553  */
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  */
581  REFIID riid, void **ppvObject)
582 {
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) ||
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  */
610 {
612  TRACE("(%p) (ref=%d)\n", This, This->ref);
613  return InterlockedIncrement(&This->ref);
614 }
615 
616 /************************************************************************
617  * DataAdviseHolder_Release (IUnknown)
618  */
620 {
622  ULONG ref;
623  TRACE("(%p) (ref=%d)\n", This, This->ref);
624 
625  ref = InterlockedDecrement(&This->ref);
627 
628  return ref;
629 }
630 
631 /************************************************************************
632  * DataAdviseHolder_Advise
633  *
634  */
636  IDataObject *pDataObject, FORMATETC *pFetc,
637  DWORD advf, IAdviseSink *pAdvise,
638  DWORD *pdwConnection)
639 {
640  DWORD index;
641  STATDATA new_conn;
643 
644  TRACE("(%p)->(%p, %p, %08x, %p, %p)\n", This, pDataObject, pFetc, advf,
645  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;
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  */
708  DWORD dwConnection)
709 {
711  DWORD index;
712  TRACE("(%p)->(%u)\n", This, dwConnection);
713 
714  /* The connection number is 1 more than the index, see DataAdviseHolder_Advise */
715  index = dwConnection - 1;
716 
717  if (index >= This->maxCons || This->connections[index].pAdvSink == NULL)
718  return OLE_E_NOCONNECTION;
719 
720  if (This->delegate && This->connections[index].advf & WINE_ADVF_REMOTE)
721  {
722  IDataObject_DUnadvise(This->delegate, This->remote_connections[index]);
723  This->remote_connections[index] = 0;
724  }
725 
726  release_statdata(This->connections + index);
727 
728  return S_OK;
729 }
730 
731 /******************************************************************************
732  * DataAdviseHolder_EnumAdvise
733  */
735  IEnumSTATDATA **enum_advise)
736 {
738  IUnknown *unk;
739  HRESULT hr;
740 
741  TRACE("(%p)->(%p)\n", This, enum_advise);
742 
743  IDataAdviseHolder_QueryInterface(iface, &IID_IUnknown, (void**)&unk);
744  hr = EnumSTATDATA_Construct(unk, 0, This->maxCons, This->connections, TRUE, enum_advise);
745  IUnknown_Release(unk);
746  return hr;
747 }
748 
749 /******************************************************************************
750  * DataAdviseHolder_SendOnDataChange
751  */
753  IDataObject *data_obj,
754  DWORD dwReserved, DWORD advf)
755 {
756  IEnumSTATDATA *pEnum;
757  HRESULT hr;
758 
759  TRACE("(%p)->(%p, %08x, %08x)\n", iface, data_obj, dwReserved, advf);
760 
761  hr = IDataAdviseHolder_EnumAdvise(iface, &pEnum);
762  if (SUCCEEDED(hr))
763  {
764  STATDATA statdata;
765  while (IEnumSTATDATA_Next(pEnum, 1, &statdata, NULL) == S_OK)
766  {
767  STGMEDIUM stg;
768  stg.tymed = TYMED_NULL;
769  stg.u.pstg = NULL;
770  stg.pUnkForRelease = NULL;
771 
772  if(!(statdata.advf & ADVF_NODATA))
773  {
774  hr = IDataObject_GetData(data_obj, &statdata.formatetc, &stg);
775  }
776 
777  IAdviseSink_OnDataChange(statdata.pAdvSink, &statdata.formatetc, &stg);
778 
779  if(statdata.advf & ADVF_ONLYONCE)
780  {
781  IDataAdviseHolder_Unadvise(iface, statdata.dwConnection);
782  }
783 
784  release_statdata(&statdata);
785  }
786  IEnumSTATDATA_Release(pEnum);
787  }
788 
789  return S_OK;
790 }
791 
792 /**************************************************************************
793  * DataAdviseHolderImpl_VTable
794  */
795 static const IDataAdviseHolderVtbl DataAdviseHolderImpl_VTable =
796 {
804 };
805 
807 {
809  DWORD index;
810  HRESULT hr = S_OK;
811 
812  for(index = 0; index < This->maxCons; index++)
813  {
814  if(This->connections[index].pAdvSink != NULL)
815  {
816  hr = IDataObject_DAdvise(pDelegate, &This->connections[index].formatetc,
817  This->connections[index].advf,
818  This->connections[index].pAdvSink,
819  &This->remote_connections[index]);
820  if (FAILED(hr)) break;
821  This->connections[index].advf |= WINE_ADVF_REMOTE;
822  }
823  }
824  This->delegate = pDelegate;
825  return hr;
826 }
827 
829 {
831  DWORD index;
832 
833  for(index = 0; index < This->maxCons; index++)
834  {
835  if((This->connections[index].pAdvSink != NULL) &&
836  (This->connections[index].advf & WINE_ADVF_REMOTE))
837  {
838  IDataObject_DUnadvise(This->delegate, This->remote_connections[index]);
839  This->remote_connections[index] = 0;
840  This->connections[index].advf &= ~WINE_ADVF_REMOTE;
841  }
842  }
843  This->delegate = NULL;
844 }
845 
846 /******************************************************************************
847  * DataAdviseHolder_Constructor
848  */
850 {
851  DataAdviseHolder* newHolder;
852 
853  newHolder = HeapAlloc(GetProcessHeap(), 0, sizeof(DataAdviseHolder));
854 
856  newHolder->ref = 1;
857  newHolder->maxCons = INITIAL_SINKS;
859  newHolder->maxCons * sizeof(*newHolder->connections));
861  newHolder->maxCons * sizeof(*newHolder->remote_connections));
862  newHolder->delegate = NULL;
863 
864  TRACE("returning %p\n", &newHolder->IDataAdviseHolder_iface);
865  return &newHolder->IDataAdviseHolder_iface;
866 }
867 
868 /***********************************************************************
869  * API functions
870  */
871 
872 /***********************************************************************
873  * CreateOleAdviseHolder [OLE32.@]
874  */
876 {
877  TRACE("(%p)\n", ppOAHolder);
878 
879  if (ppOAHolder==NULL)
880  return E_POINTER;
881 
882  *ppOAHolder = OleAdviseHolderImpl_Constructor ();
883 
884  if (*ppOAHolder != NULL)
885  return S_OK;
886 
887  return E_OUTOFMEMORY;
888 }
889 
890 /******************************************************************************
891  * CreateDataAdviseHolder [OLE32.@]
892  */
894 {
895  TRACE("(%p)\n", ppDAHolder);
896 
897  if (ppDAHolder==NULL)
898  return E_POINTER;
899 
900  *ppDAHolder = DataAdviseHolder_Constructor();
901 
902  if (*ppDAHolder != NULL)
903  return S_OK;
904 
905  return E_OUTOFMEMORY;
906 }
static HRESULT WINAPI EnumSTATDATA_Clone(IEnumSTATDATA *iface, IEnumSTATDATA **ppenum)
Definition: oleobj.c:178
HRESULT WINAPI CreateOleAdviseHolder(IOleAdviseHolder **ppOAHolder)
Definition: oleobj.c:875
static HRESULT WINAPI DataAdviseHolder_Unadvise(IDataAdviseHolder *iface, DWORD dwConnection)
Definition: oleobj.c:707
#define REFIID
Definition: guiddef.h:118
#define E_NOINTERFACE
Definition: winerror.h:2364
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
HRESULT hr
Definition: shlfolder.c:183
static void OleAdviseHolderImpl_Destructor(OleAdviseHolderImpl *This)
Definition: oleobj.c:261
static HRESULT WINAPI OleAdviseHolderImpl_QueryInterface(IOleAdviseHolder *iface, REFIID iid, void **obj)
Definition: oleobj.c:279
static ULONG WINAPI OleAdviseHolderImpl_Release(IOleAdviseHolder *iface)
Definition: oleobj.c:320
static HRESULT WINAPI OleAdviseHolderImpl_EnumAdvise(IOleAdviseHolder *iface, IEnumSTATDATA **enum_advise)
Definition: oleobj.c:401
IDataAdviseHolder IDataAdviseHolder_iface
Definition: oleobj.c:534
#define TRUE
Definition: types.h:120
DWORD * remote_connections
Definition: oleobj.c:539
REFIID riid
Definition: precomp.h:44
HRESULT DataAdviseHolder_OnConnect(IDataAdviseHolder *iface, IDataObject *pDelegate)
Definition: oleobj.c:806
static void DataAdviseHolder_Destructor(DataAdviseHolder *ptrToDestroy)
Definition: oleobj.c:554
static void release_statdata(STATDATA *data)
Definition: oleobj.c:42
static const IDataAdviseHolderVtbl DataAdviseHolderImpl_VTable
Definition: oleobj.c:795
GLuint GLuint GLsizei count
Definition: gl.h:1545
const GUID IID_IDataAdviseHolder
static const IOleAdviseHolderVtbl oahvt
Definition: oleobj.c:496
static ULONG WINAPI DataAdviseHolder_AddRef(IDataAdviseHolder *iface)
Definition: oleobj.c:609
REFIID LPVOID * ppv
Definition: atlbase.h:39
static ULONG WINAPI EnumSTATDATA_Release(IEnumSTATDATA *iface)
Definition: oleobj.c:107
static HRESULT WINAPI EnumSTATDATA_QueryInterface(IEnumSTATDATA *iface, REFIID riid, void **ppv)
Definition: oleobj.c:87
static ULONG WINAPI DataAdviseHolder_Release(IDataAdviseHolder *iface)
Definition: oleobj.c:619
IEnumSTATDATA IEnumSTATDATA_iface
Definition: oleobj.c:73
STATDATA * connections
Definition: oleobj.c:538
static HRESULT copy_statdata(STATDATA *dst, const STATDATA *src)
Definition: oleobj.c:54
static ULONG WINAPI EnumSTATDATA_AddRef(IEnumSTATDATA *iface)
Definition: oleobj.c:100
Definition: send.c:48
static HRESULT WINAPI OleAdviseHolderImpl_SendOnSave(IOleAdviseHolder *iface)
Definition: oleobj.c:444
void DataAdviseHolder_OnDisconnect(IDataAdviseHolder *iface)
Definition: oleobj.c:828
#define OLE_E_NOCONNECTION
Definition: winerror.h:2618
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED _In_opt_ LPTRANSMIT_FILE_BUFFERS _In_ DWORD dwReserved
Definition: mswsock.h:90
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
GLenum GLint ref
Definition: glext.h:6028
HRESULT WINAPI CreateDataAdviseHolder(IDataAdviseHolder **ppDAHolder)
Definition: oleobj.c:893
#define S_FALSE
Definition: winerror.h:2357
#define E_INVALIDARG
Definition: ddrawi.h:101
static HRESULT copy_formatetc(FORMATETC *dst, const FORMATETC *src)
smooth NULL
Definition: ftsmooth.c:416
const GUID IID_IEnumSTATDATA
GLuint index
Definition: glext.h:6031
ULONG index
Definition: oleobj.c:76
static HRESULT WINAPI OleAdviseHolderImpl_Advise(IOleAdviseHolder *iface, IAdviseSink *pAdvise, DWORD *pdwConnection)
Definition: oleobj.c:335
#define debugstr_guid
Definition: kernel32.h:35
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
static const IEnumSTATDATAVtbl EnumSTATDATA_VTable
Definition: oleobj.c:186
#define TRACE(s)
Definition: solgame.cpp:4
static ULONG WINAPI OleAdviseHolderImpl_AddRef(IOleAdviseHolder *iface)
Definition: oleobj.c:307
#define WINE_ADVF_REMOTE
Definition: oleobj.c:544
#define GetProcessHeap()
Definition: compat.h:484
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
LONG HRESULT
Definition: typedefs.h:79
const GUID IID_IUnknown
static HRESULT WINAPI DataAdviseHolder_EnumAdvise(IDataAdviseHolder *iface, IEnumSTATDATA **enum_advise)
Definition: oleobj.c:734
STATDATA * statdata
Definition: oleobj.c:78
#define WINAPI
Definition: msvc.h:6
IOleAdviseHolder IOleAdviseHolder_iface
Definition: oleobj.c:245
unsigned long DWORD
Definition: ntddk_ex.h:95
GLuint GLuint num
Definition: glext.h:9618
LONG ref
Definition: oleobj.c:74
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
DWORD maxCons
Definition: oleobj.c:537
#define index(s, c)
Definition: various.h:29
#define InterlockedDecrement
Definition: armddk.h:52
WINE_DEFAULT_DEBUG_CHANNEL(ole)
REFIID LPVOID * ppvObject
Definition: precomp.h:44
GLenum src
Definition: glext.h:6340
IUnknown * holder
Definition: oleobj.c:79
IDataObject * delegate
Definition: oleobj.c:540
STATDATA * connections
Definition: oleobj.c:250
static IOleAdviseHolder * OleAdviseHolderImpl_Constructor(void)
Definition: oleobj.c:513
static IDataAdviseHolder * DataAdviseHolder_Constructor(void)
Definition: oleobj.c:849
static OleAdviseHolderImpl * impl_from_IOleAdviseHolder(IOleAdviseHolder *iface)
Definition: oleobj.c:253
#define S_OK
Definition: intsafe.h:59
#define InterlockedIncrement
Definition: armddk.h:53
static HRESULT WINAPI EnumSTATDATA_Reset(IEnumSTATDATA *iface)
Definition: oleobj.c:168
DWORD num_of_elems
Definition: oleobj.c:77
#define INITIAL_SINKS
Definition: oleobj.c:40
#define HeapReAlloc
Definition: compat.h:482
GLenum GLenum dst
Definition: glext.h:6340
INT copy(TCHAR source[MAX_PATH], TCHAR dest[MAX_PATH], INT append, DWORD lpdwFlags, BOOL bTouch)
Definition: copy.c:51
HRESULT EnumSTATDATA_Construct(IUnknown *holder, ULONG index, DWORD array_len, STATDATA *data, BOOL copy, IEnumSTATDATA **ppenum)
Definition: oleobj.c:197
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
const GUID IID_IOleAdviseHolder
static HRESULT WINAPI OleAdviseHolderImpl_Unadvise(IOleAdviseHolder *iface, DWORD dwConnection)
Definition: oleobj.c:379
static HRESULT WINAPI EnumSTATDATA_Next(IEnumSTATDATA *iface, ULONG num, LPSTATDATA data, ULONG *fetched)
Definition: oleobj.c:124
static HRESULT WINAPI OleAdviseHolderImpl_SendOnClose(IOleAdviseHolder *iface)
Definition: oleobj.c:470
static HRESULT WINAPI DataAdviseHolder_Advise(IDataAdviseHolder *iface, IDataObject *pDataObject, FORMATETC *pFetc, DWORD advf, IAdviseSink *pAdvise, DWORD *pdwConnection)
Definition: oleobj.c:635
unsigned int ULONG
Definition: retypes.h:1
static HRESULT WINAPI EnumSTATDATA_Skip(IEnumSTATDATA *iface, ULONG num)
Definition: oleobj.c:152
static HRESULT WINAPI DataAdviseHolder_SendOnDataChange(IDataAdviseHolder *iface, IDataObject *data_obj, DWORD dwReserved, DWORD advf)
Definition: oleobj.c:752
#define E_POINTER
Definition: winerror.h:2365
static HRESULT WINAPI OleAdviseHolderImpl_SendOnRename(IOleAdviseHolder *iface, IMoniker *pmk)
Definition: oleobj.c:418
static EnumSTATDATA * impl_from_IEnumSTATDATA(IEnumSTATDATA *iface)
Definition: oleobj.c:82
static HRESULT WINAPI DataAdviseHolder_QueryInterface(IDataAdviseHolder *iface, REFIID riid, void **ppvObject)
Definition: oleobj.c:580
#define HeapFree(x, y, z)
Definition: compat.h:483
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
#define SUCCEEDED(hr)
Definition: intsafe.h:57
static DataAdviseHolder * impl_from_IDataAdviseHolder(IDataAdviseHolder *iface)
Definition: oleobj.c:546