4 * Copyright 1998 Eric Kohl
5 * Copyright 1999 Francis Beaudet
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.
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.
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
32 #include "wine/debug.h"
35 WINE_DEFAULT_DEBUG_CHANNEL(ole);
37 #define INITIAL_SINKS 10
39 /**************************************************************************
40 * OleAdviseHolderImpl Implementation
42 typedef struct OleAdviseHolderImpl
44 const IOleAdviseHolderVtbl *lpVtbl;
49 IAdviseSink** arrayOfSinks;
51 } OleAdviseHolderImpl;
53 static HRESULT EnumOleSTATDATA_Construct(OleAdviseHolderImpl *pOleAdviseHolder, ULONG index, IEnumSTATDATA **ppenum);
57 const IEnumSTATDATAVtbl *lpvtbl;
61 OleAdviseHolderImpl *pOleAdviseHolder;
64 static HRESULT WINAPI EnumOleSTATDATA_QueryInterface(
65 IEnumSTATDATA *iface, REFIID riid, void **ppv)
67 TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
68 if (IsEqualIID(riid, &IID_IUnknown) ||
69 IsEqualIID(riid, &IID_IEnumSTATDATA))
71 IUnknown_AddRef(iface);
78 static ULONG WINAPI EnumOleSTATDATA_AddRef(
81 EnumOleSTATDATA *This = (EnumOleSTATDATA *)iface;
83 return InterlockedIncrement(&This->ref);
86 static ULONG WINAPI EnumOleSTATDATA_Release(
89 EnumOleSTATDATA *This = (EnumOleSTATDATA *)iface;
90 LONG refs = InterlockedDecrement(&This->ref);
94 IOleAdviseHolder_Release((IOleAdviseHolder *)This->pOleAdviseHolder);
95 HeapFree(GetProcessHeap(), 0, This);
100 static HRESULT WINAPI EnumOleSTATDATA_Next(
101 IEnumSTATDATA *iface, ULONG celt, LPSTATDATA rgelt,
104 EnumOleSTATDATA *This = (EnumOleSTATDATA *)iface;
107 TRACE("(%ld, %p, %p)\n", celt, rgelt, pceltFetched);
112 for (; celt; celt--, rgelt++)
114 while ((This->index < This->pOleAdviseHolder->maxSinks) &&
115 !This->pOleAdviseHolder->arrayOfSinks[This->index])
119 if (This->index >= This->pOleAdviseHolder->maxSinks)
125 memset(&rgelt->formatetc, 0, sizeof(rgelt->formatetc));
127 rgelt->pAdvSink = This->pOleAdviseHolder->arrayOfSinks[This->index];
128 IAdviseSink_AddRef(rgelt->pAdvSink);
129 rgelt->dwConnection = This->index;
138 static HRESULT WINAPI EnumOleSTATDATA_Skip(
139 IEnumSTATDATA *iface, ULONG celt)
141 EnumOleSTATDATA *This = (EnumOleSTATDATA *)iface;
143 TRACE("(%ld)\n", celt);
147 while ((This->index < This->pOleAdviseHolder->maxSinks) &&
148 !This->pOleAdviseHolder->arrayOfSinks[This->index])
152 if (This->index >= This->pOleAdviseHolder->maxSinks)
159 static HRESULT WINAPI EnumOleSTATDATA_Reset(
160 IEnumSTATDATA *iface)
162 EnumOleSTATDATA *This = (EnumOleSTATDATA *)iface;
170 static HRESULT WINAPI EnumOleSTATDATA_Clone(
171 IEnumSTATDATA *iface,
172 IEnumSTATDATA **ppenum)
174 EnumOleSTATDATA *This = (EnumOleSTATDATA *)iface;
175 return EnumOleSTATDATA_Construct(This->pOleAdviseHolder, This->index, ppenum);
178 static const IEnumSTATDATAVtbl EnumOleSTATDATA_VTable =
180 EnumOleSTATDATA_QueryInterface,
181 EnumOleSTATDATA_AddRef,
182 EnumOleSTATDATA_Release,
183 EnumOleSTATDATA_Next,
184 EnumOleSTATDATA_Skip,
185 EnumOleSTATDATA_Reset,
186 EnumOleSTATDATA_Clone
189 static HRESULT EnumOleSTATDATA_Construct(OleAdviseHolderImpl *pOleAdviseHolder, ULONG index, IEnumSTATDATA **ppenum)
191 EnumOleSTATDATA *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
193 return E_OUTOFMEMORY;
194 This->lpvtbl = &EnumOleSTATDATA_VTable;
197 This->pOleAdviseHolder = pOleAdviseHolder;
198 IOleAdviseHolder_AddRef((IOleAdviseHolder *)pOleAdviseHolder);
199 *ppenum = (IEnumSTATDATA *)&This->lpvtbl;
203 /**************************************************************************
204 * OleAdviseHolderImpl_Destructor
206 static void OleAdviseHolderImpl_Destructor(
207 OleAdviseHolderImpl* ptrToDestroy)
210 TRACE("%p\n", ptrToDestroy);
212 for (index = 0; index < ptrToDestroy->maxSinks; index++)
214 if (ptrToDestroy->arrayOfSinks[index]!=0)
216 IAdviseSink_Release(ptrToDestroy->arrayOfSinks[index]);
217 ptrToDestroy->arrayOfSinks[index] = NULL;
221 HeapFree(GetProcessHeap(),
223 ptrToDestroy->arrayOfSinks);
226 HeapFree(GetProcessHeap(),
231 /**************************************************************************
232 * OleAdviseHolderImpl_QueryInterface
234 static HRESULT WINAPI OleAdviseHolderImpl_QueryInterface(
235 LPOLEADVISEHOLDER iface,
239 OleAdviseHolderImpl *This = (OleAdviseHolderImpl *)iface;
240 TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppvObj);
249 if (IsEqualIID(riid, &IID_IUnknown))
254 else if(IsEqualIID(riid, &IID_IOleAdviseHolder))
256 /* IOleAdviseHolder */
257 *ppvObj = (IOleAdviseHolder*) This;
261 return E_NOINTERFACE;
264 * A successful QI always increments the reference count.
266 IUnknown_AddRef((IUnknown*)*ppvObj);
271 /******************************************************************************
272 * OleAdviseHolderImpl_AddRef
274 static ULONG WINAPI OleAdviseHolderImpl_AddRef(
275 LPOLEADVISEHOLDER iface)
277 OleAdviseHolderImpl *This = (OleAdviseHolderImpl *)iface;
278 ULONG ref = InterlockedIncrement(&This->ref);
280 TRACE("(%p)->(ref=%ld)\n", This, ref - 1);
285 /******************************************************************************
286 * OleAdviseHolderImpl_Release
288 static ULONG WINAPI OleAdviseHolderImpl_Release(
289 LPOLEADVISEHOLDER iface)
291 OleAdviseHolderImpl *This = (OleAdviseHolderImpl *)iface;
293 TRACE("(%p)->(ref=%ld)\n", This, This->ref);
294 ref = InterlockedDecrement(&This->ref);
296 if (ref == 0) OleAdviseHolderImpl_Destructor(This);
301 /******************************************************************************
302 * OleAdviseHolderImpl_Advise
304 static HRESULT WINAPI OleAdviseHolderImpl_Advise(
305 LPOLEADVISEHOLDER iface,
306 IAdviseSink* pAdvise,
307 DWORD* pdwConnection)
311 OleAdviseHolderImpl *This = (OleAdviseHolderImpl *)iface;
313 TRACE("(%p)->(%p, %p)\n", This, pAdvise, pdwConnection);
318 if (pdwConnection==NULL)
324 * Find a free spot in the array.
326 for (index = 0; index < This->maxSinks; index++)
328 if (This->arrayOfSinks[index]==NULL)
333 * If the array is full, we need to grow it.
335 if (index == This->maxSinks)
339 This->maxSinks+=INITIAL_SINKS;
341 This->arrayOfSinks = HeapReAlloc(GetProcessHeap(),
344 This->maxSinks*sizeof(IAdviseSink*));
346 for (i=index;i < This->maxSinks; i++)
347 This->arrayOfSinks[i]=0;
353 This->arrayOfSinks[index] = pAdvise;
355 if (This->arrayOfSinks[index]!=NULL)
356 IAdviseSink_AddRef(This->arrayOfSinks[index]);
359 * Return the index as the cookie.
360 * Since 0 is not a valid cookie, we will increment by
361 * 1 the index in the table.
363 *pdwConnection = index+1;
368 /******************************************************************************
369 * OleAdviseHolderImpl_Unadvise
371 static HRESULT WINAPI OleAdviseHolderImpl_Unadvise(
372 LPOLEADVISEHOLDER iface,
375 OleAdviseHolderImpl *This = (OleAdviseHolderImpl *)iface;
377 TRACE("(%p)->(%lu)\n", This, dwConnection);
380 * So we don't return 0 as a cookie, the index was
381 * incremented by 1 in OleAdviseHolderImpl_Advise
382 * we have to compensate.
387 * Check for invalid cookies.
389 if (dwConnection >= This->maxSinks)
390 return OLE_E_NOCONNECTION;
392 if (This->arrayOfSinks[dwConnection] == NULL)
393 return OLE_E_NOCONNECTION;
396 * Release the sink and mark the spot in the list as free.
398 IAdviseSink_Release(This->arrayOfSinks[dwConnection]);
399 This->arrayOfSinks[dwConnection] = NULL;
404 /******************************************************************************
405 * OleAdviseHolderImpl_EnumAdvise
407 static HRESULT WINAPI
408 OleAdviseHolderImpl_EnumAdvise (LPOLEADVISEHOLDER iface, IEnumSTATDATA **ppenumAdvise)
410 OleAdviseHolderImpl *This = (OleAdviseHolderImpl *)iface;
412 TRACE("(%p)->(%p)\n", This, ppenumAdvise);
414 *ppenumAdvise = NULL;
416 return EnumOleSTATDATA_Construct(This, 0, ppenumAdvise);
419 /******************************************************************************
420 * OleAdviseHolderImpl_SendOnRename
422 static HRESULT WINAPI
423 OleAdviseHolderImpl_SendOnRename (LPOLEADVISEHOLDER iface, IMoniker *pmk)
425 IEnumSTATDATA *pEnum;
428 TRACE("(%p)->(%p)\n", iface, pmk);
430 hr = IOleAdviseHolder_EnumAdvise(iface, &pEnum);
434 while (IEnumSTATDATA_Next(pEnum, 1, &statdata, NULL) == S_OK)
436 IAdviseSink_OnRename(statdata.pAdvSink, pmk);
438 IAdviseSink_Release(statdata.pAdvSink);
440 IEnumSTATDATA_Release(pEnum);
446 /******************************************************************************
447 * OleAdviseHolderImpl_SendOnSave
449 static HRESULT WINAPI
450 OleAdviseHolderImpl_SendOnSave (LPOLEADVISEHOLDER iface)
452 IEnumSTATDATA *pEnum;
455 TRACE("(%p)->()\n", iface);
457 hr = IOleAdviseHolder_EnumAdvise(iface, &pEnum);
461 while (IEnumSTATDATA_Next(pEnum, 1, &statdata, NULL) == S_OK)
463 IAdviseSink_OnSave(statdata.pAdvSink);
465 IAdviseSink_Release(statdata.pAdvSink);
467 IEnumSTATDATA_Release(pEnum);
473 /******************************************************************************
474 * OleAdviseHolderImpl_SendOnClose
476 static HRESULT WINAPI
477 OleAdviseHolderImpl_SendOnClose (LPOLEADVISEHOLDER iface)
479 IEnumSTATDATA *pEnum;
482 TRACE("(%p)->()\n", iface);
484 hr = IOleAdviseHolder_EnumAdvise(iface, &pEnum);
488 while (IEnumSTATDATA_Next(pEnum, 1, &statdata, NULL) == S_OK)
490 IAdviseSink_OnClose(statdata.pAdvSink);
492 IAdviseSink_Release(statdata.pAdvSink);
494 IEnumSTATDATA_Release(pEnum);
500 /**************************************************************************
501 * OleAdviseHolderImpl_VTable
503 static const IOleAdviseHolderVtbl oahvt =
505 OleAdviseHolderImpl_QueryInterface,
506 OleAdviseHolderImpl_AddRef,
507 OleAdviseHolderImpl_Release,
508 OleAdviseHolderImpl_Advise,
509 OleAdviseHolderImpl_Unadvise,
510 OleAdviseHolderImpl_EnumAdvise,
511 OleAdviseHolderImpl_SendOnRename,
512 OleAdviseHolderImpl_SendOnSave,
513 OleAdviseHolderImpl_SendOnClose
516 /**************************************************************************
517 * OleAdviseHolderImpl_Constructor
520 static LPOLEADVISEHOLDER OleAdviseHolderImpl_Constructor(void)
522 OleAdviseHolderImpl* lpoah;
525 lpoah = HeapAlloc(GetProcessHeap(), 0, sizeof(OleAdviseHolderImpl));
527 lpoah->lpVtbl = &oahvt;
529 lpoah->maxSinks = INITIAL_SINKS;
530 lpoah->arrayOfSinks = HeapAlloc(GetProcessHeap(),
532 lpoah->maxSinks * sizeof(IAdviseSink*));
534 for (index = 0; index < lpoah->maxSinks; index++)
535 lpoah->arrayOfSinks[index]=0;
537 TRACE("returning %p\n", lpoah);
538 return (LPOLEADVISEHOLDER)lpoah;
541 /**************************************************************************
542 * DataAdviseHolder Implementation
544 typedef struct DataAdviseConnection {
548 DWORD remote_connection;
549 } DataAdviseConnection;
551 typedef struct DataAdviseHolder
553 const IDataAdviseHolderVtbl *lpVtbl;
557 DataAdviseConnection* Connections;
558 IDataObject* delegate;
561 /* this connection has also has been advised to the delegate data object */
562 #define WINE_ADVF_REMOTE 0x80000000
564 /******************************************************************************
565 * DataAdviseHolder_Destructor
567 static void DataAdviseHolder_Destructor(DataAdviseHolder* ptrToDestroy)
570 TRACE("%p\n", ptrToDestroy);
572 for (index = 0; index < ptrToDestroy->maxCons; index++)
574 if (ptrToDestroy->Connections[index].sink != NULL)
576 if (ptrToDestroy->delegate &&
577 (ptrToDestroy->Connections[index].advf & WINE_ADVF_REMOTE))
578 IDataObject_DUnadvise(ptrToDestroy->delegate,
579 ptrToDestroy->Connections[index].remote_connection);
581 IAdviseSink_Release(ptrToDestroy->Connections[index].sink);
582 ptrToDestroy->Connections[index].sink = NULL;
586 HeapFree(GetProcessHeap(), 0, ptrToDestroy->Connections);
587 HeapFree(GetProcessHeap(), 0, ptrToDestroy);
590 /************************************************************************
591 * DataAdviseHolder_QueryInterface (IUnknown)
593 * See Windows documentation for more details on IUnknown methods.
595 static HRESULT WINAPI DataAdviseHolder_QueryInterface(
596 IDataAdviseHolder* iface,
600 DataAdviseHolder *This = (DataAdviseHolder *)iface;
601 TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppvObject);
603 * Perform a sanity check on the parameters.
605 if ( (This==0) || (ppvObject==0) )
609 * Initialize the return parameter.
614 * Compare the riid with the interface IDs implemented by this object.
616 if ( (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0) ||
617 (memcmp(&IID_IDataAdviseHolder, riid, sizeof(IID_IDataAdviseHolder)) == 0) )
623 * Check that we obtained an interface.
627 return E_NOINTERFACE;
631 * Query Interface always increases the reference count by one when it is
634 IUnknown_AddRef((IUnknown*)*ppvObject);
639 /************************************************************************
640 * DataAdviseHolder_AddRef (IUnknown)
642 * See Windows documentation for more details on IUnknown methods.
644 static ULONG WINAPI DataAdviseHolder_AddRef(
645 IDataAdviseHolder* iface)
647 DataAdviseHolder *This = (DataAdviseHolder *)iface;
648 TRACE("(%p) (ref=%ld)\n", This, This->ref);
649 return InterlockedIncrement(&This->ref);
652 /************************************************************************
653 * DataAdviseHolder_Release (IUnknown)
655 * See Windows documentation for more details on IUnknown methods.
657 static ULONG WINAPI DataAdviseHolder_Release(
658 IDataAdviseHolder* iface)
660 DataAdviseHolder *This = (DataAdviseHolder *)iface;
662 TRACE("(%p) (ref=%ld)\n", This, This->ref);
665 * Decrease the reference count on this object.
667 ref = InterlockedDecrement(&This->ref);
670 * If the reference count goes down to 0, perform suicide.
672 if (ref==0) DataAdviseHolder_Destructor(This);
677 /************************************************************************
678 * DataAdviseHolder_Advise
681 static HRESULT WINAPI DataAdviseHolder_Advise(
682 IDataAdviseHolder* iface,
683 IDataObject* pDataObject,
686 IAdviseSink* pAdvise,
687 DWORD* pdwConnection)
691 DataAdviseHolder *This = (DataAdviseHolder *)iface;
693 TRACE("(%p)->(%p, %p, %08lx, %p, %p)\n", This, pDataObject, pFetc, advf,
694 pAdvise, pdwConnection);
698 if (pdwConnection==NULL)
704 * Find a free spot in the array.
706 for (index = 0; index < This->maxCons; index++)
708 if (This->Connections[index].sink == NULL)
713 * If the array is full, we need to grow it.
715 if (index == This->maxCons)
717 This->maxCons+=INITIAL_SINKS;
718 This->Connections = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
720 This->maxCons*sizeof(DataAdviseConnection));
725 This->Connections[index].sink = pAdvise;
726 memcpy(&(This->Connections[index].fmat), pFetc, sizeof(FORMATETC));
727 This->Connections[index].advf = advf & ~WINE_ADVF_REMOTE;
729 if (This->Connections[index].sink != NULL) {
730 IAdviseSink_AddRef(This->Connections[index].sink);
731 if(advf & ADVF_PRIMEFIRST) {
732 IDataAdviseHolder_SendOnDataChange(iface, pDataObject, 0, advf);
735 /* if we are already connected advise the remote object */
740 hr = IDataObject_DAdvise(This->delegate, &This->Connections[index].fmat,
741 This->Connections[index].advf,
742 This->Connections[index].sink,
743 &This->Connections[index].remote_connection);
746 IDataAdviseHolder_Unadvise(iface, index + 1);
749 This->Connections[index].advf |= WINE_ADVF_REMOTE;
753 * Return the index as the cookie.
754 * Since 0 is not a valid cookie, we will increment by
755 * 1 the index in the table.
757 *pdwConnection = index+1;
762 /******************************************************************************
763 * DataAdviseHolder_Unadvise
765 static HRESULT WINAPI DataAdviseHolder_Unadvise(
766 IDataAdviseHolder* iface,
769 DataAdviseHolder *This = (DataAdviseHolder *)iface;
771 TRACE("(%p)->(%lu)\n", This, dwConnection);
774 * So we don't return 0 as a cookie, the index was
775 * incremented by 1 in OleAdviseHolderImpl_Advise
776 * we have to compensate.
781 * Check for invalid cookies.
783 if (dwConnection >= This->maxCons)
784 return OLE_E_NOCONNECTION;
786 if (This->Connections[dwConnection].sink == NULL)
787 return OLE_E_NOCONNECTION;
789 if (This->delegate && This->Connections[dwConnection].advf & WINE_ADVF_REMOTE)
790 IDataObject_DUnadvise(This->delegate,
791 This->Connections[dwConnection].remote_connection);
794 * Release the sink and mark the spot in the list as free.
796 IAdviseSink_Release(This->Connections[dwConnection].sink);
797 memset(&(This->Connections[dwConnection]), 0, sizeof(DataAdviseConnection));
802 static HRESULT WINAPI DataAdviseHolder_EnumAdvise(
803 IDataAdviseHolder* iface,
804 IEnumSTATDATA** ppenumAdvise)
806 DataAdviseHolder *This = (DataAdviseHolder *)iface;
808 FIXME("(%p)->(%p)\n", This, ppenumAdvise);
812 /******************************************************************************
813 * DataAdviseHolder_SendOnDataChange
815 static HRESULT WINAPI DataAdviseHolder_SendOnDataChange(
816 IDataAdviseHolder* iface,
817 IDataObject* pDataObject,
821 DataAdviseHolder *This = (DataAdviseHolder *)iface;
826 TRACE("(%p)->(%p,%08lx,%08lx)\n", This, pDataObject, dwReserved, advf);
828 for(index = 0; index < This->maxCons; index++) {
829 if(This->Connections[index].sink != NULL) {
830 memset(&stg, 0, sizeof(stg));
831 if(!(This->Connections[index].advf & ADVF_NODATA)) {
832 TRACE("Calling IDataObject_GetData\n");
833 res = IDataObject_GetData(pDataObject,
834 &(This->Connections[index].fmat),
836 TRACE("returns %08lx\n", res);
838 TRACE("Calling IAdviseSink_OnDataChange\n");
839 IAdviseSink_OnDataChange(This->Connections[index].sink,
840 &(This->Connections[index].fmat),
842 TRACE("Done IAdviseSink_OnDataChange\n");
843 if(This->Connections[index].advf & ADVF_ONLYONCE) {
844 TRACE("Removing connection\n");
845 DataAdviseHolder_Unadvise(iface, index+1);
852 /**************************************************************************
853 * DataAdviseHolderImpl_VTable
855 static const IDataAdviseHolderVtbl DataAdviseHolderImpl_VTable =
857 DataAdviseHolder_QueryInterface,
858 DataAdviseHolder_AddRef,
859 DataAdviseHolder_Release,
860 DataAdviseHolder_Advise,
861 DataAdviseHolder_Unadvise,
862 DataAdviseHolder_EnumAdvise,
863 DataAdviseHolder_SendOnDataChange
866 HRESULT DataAdviseHolder_OnConnect(IDataAdviseHolder *iface, IDataObject *pDelegate)
868 DataAdviseHolder *This = (DataAdviseHolder *)iface;
872 for(index = 0; index < This->maxCons; index++)
874 if(This->Connections[index].sink != NULL)
876 hr = IDataObject_DAdvise(pDelegate, &This->Connections[index].fmat,
877 This->Connections[index].advf,
878 This->Connections[index].sink,
879 &This->Connections[index].remote_connection);
880 if (FAILED(hr)) break;
881 This->Connections[index].advf |= WINE_ADVF_REMOTE;
884 This->delegate = pDelegate;
888 void DataAdviseHolder_OnDisconnect(IDataAdviseHolder *iface)
890 DataAdviseHolder *This = (DataAdviseHolder *)iface;
893 for(index = 0; index < This->maxCons; index++)
895 if((This->Connections[index].sink != NULL) &&
896 (This->Connections[index].advf & WINE_ADVF_REMOTE))
898 IDataObject_DUnadvise(This->delegate,
899 This->Connections[index].remote_connection);
900 This->Connections[index].advf &= ~WINE_ADVF_REMOTE;
903 This->delegate = NULL;
906 /******************************************************************************
907 * DataAdviseHolder_Constructor
909 static IDataAdviseHolder* DataAdviseHolder_Constructor(void)
911 DataAdviseHolder* newHolder;
913 newHolder = HeapAlloc(GetProcessHeap(), 0, sizeof(DataAdviseHolder));
915 newHolder->lpVtbl = &DataAdviseHolderImpl_VTable;
917 newHolder->maxCons = INITIAL_SINKS;
918 newHolder->Connections = HeapAlloc(GetProcessHeap(),
921 sizeof(DataAdviseConnection));
922 newHolder->delegate = NULL;
924 TRACE("returning %p\n", newHolder);
925 return (IDataAdviseHolder*)newHolder;
928 /***********************************************************************
932 /***********************************************************************
933 * CreateOleAdviseHolder [OLE32.@]
935 HRESULT WINAPI CreateOleAdviseHolder(
936 LPOLEADVISEHOLDER *ppOAHolder)
938 TRACE("(%p)\n", ppOAHolder);
943 if (ppOAHolder==NULL)
946 *ppOAHolder = OleAdviseHolderImpl_Constructor ();
948 if (*ppOAHolder != NULL)
951 return E_OUTOFMEMORY;
954 /******************************************************************************
955 * CreateDataAdviseHolder [OLE32.@]
957 HRESULT WINAPI CreateDataAdviseHolder(
958 LPDATAADVISEHOLDER* ppDAHolder)
960 TRACE("(%p)\n", ppDAHolder);
965 if (ppDAHolder==NULL)
968 *ppDAHolder = DataAdviseHolder_Constructor();
970 if (*ppDAHolder != NULL)
973 return E_OUTOFMEMORY;