| /*************************************************************************************** |
| * AntiMonikers implementation |
| * |
| * Copyright 1999 Noomen Hamza |
| ***************************************************************************************/ |
| |
| #include <assert.h> |
| #include "winerror.h" |
| #include "debug.h" |
| #include "heap.h" |
| #include "winuser.h" |
| #include "file.h" |
| #include "winreg.h" |
| #include "objbase.h" |
| #include "wine/obj_inplace.h" |
| |
| /* AntiMoniker data structure */ |
| typedef struct AntiMonikerImpl{ |
| |
| ICOM_VTABLE(IMoniker)* lpvtbl1; /* VTable relative to the IMoniker interface.*/ |
| |
| /* The ROT (RunningObjectTable implementation) uses the IROTData interface to test whether |
| * two monikers are equal. That's whay IROTData interface is implemented by monikers. |
| */ |
| ICOM_VTABLE(IROTData)* lpvtbl2; /* VTable relative to the IROTData interface.*/ |
| |
| ULONG ref; /* reference counter for this object */ |
| |
| } AntiMonikerImpl; |
| |
| /********************************************************************************/ |
| /* AntiMoniker prototype functions : */ |
| |
| /* IUnknown prototype functions */ |
| static HRESULT WINAPI AntiMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject); |
| static ULONG WINAPI AntiMonikerImpl_AddRef(IMoniker* iface); |
| static ULONG WINAPI AntiMonikerImpl_Release(IMoniker* iface); |
| |
| /* IPersist prototype functions */ |
| static HRESULT WINAPI AntiMonikerImpl_GetClassID(const IMoniker* iface, CLSID *pClassID); |
| |
| /* IPersistStream prototype functions */ |
| static HRESULT WINAPI AntiMonikerImpl_IsDirty(IMoniker* iface); |
| static HRESULT WINAPI AntiMonikerImpl_Load(IMoniker* iface, IStream* pStm); |
| static HRESULT WINAPI AntiMonikerImpl_Save(IMoniker* iface, IStream* pStm, BOOL fClearDirty); |
| static HRESULT WINAPI AntiMonikerImpl_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize); |
| |
| /* IMoniker prototype functions */ |
| static HRESULT WINAPI AntiMonikerImpl_BindToObject(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult); |
| static HRESULT WINAPI AntiMonikerImpl_BindToStorage(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult); |
| static HRESULT WINAPI AntiMonikerImpl_Reduce(IMoniker* iface,IBindCtx* pbc, DWORD dwReduceHowFar,IMoniker** ppmkToLeft, IMoniker** ppmkReduced); |
| static HRESULT WINAPI AntiMonikerImpl_ComposeWith(IMoniker* iface,IMoniker* pmkRight,BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite); |
| static HRESULT WINAPI AntiMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker); |
| static HRESULT WINAPI AntiMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker); |
| static HRESULT WINAPI AntiMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash); |
| static HRESULT WINAPI AntiMonikerImpl_IsRunning(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning); |
| static HRESULT WINAPI AntiMonikerImpl_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft, FILETIME* pAntiTime); |
| static HRESULT WINAPI AntiMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk); |
| static HRESULT WINAPI AntiMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther, IMoniker** ppmkPrefix); |
| static HRESULT WINAPI AntiMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath); |
| static HRESULT WINAPI AntiMonikerImpl_GetDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName); |
| static HRESULT WINAPI AntiMonikerImpl_ParseDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut); |
| static HRESULT WINAPI AntiMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys); |
| |
| /********************************************************************************/ |
| /* IROTData prototype functions */ |
| |
| /* IUnknown prototype functions */ |
| static HRESULT WINAPI AntiMonikerROTDataImpl_QueryInterface(IROTData* iface,REFIID riid,VOID** ppvObject); |
| static ULONG WINAPI AntiMonikerROTDataImpl_AddRef(IROTData* iface); |
| static ULONG WINAPI AntiMonikerROTDataImpl_Release(IROTData* iface); |
| |
| /* IROTData prototype function */ |
| static HRESULT WINAPI AntiMonikerROTDataImpl_GetComparaisonData(IROTData* iface,BYTE* pbData,ULONG cbMax,ULONG* pcbData); |
| |
| /* Local function used by AntiMoniker implementation */ |
| HRESULT WINAPI AntiMonikerImpl_Construct(AntiMonikerImpl* iface); |
| HRESULT WINAPI AntiMonikerImpl_Destroy(AntiMonikerImpl* iface); |
| |
| /********************************************************************************/ |
| /* Virtual function table for the AntiMonikerImpl class witch include Ipersist,*/ |
| /* IPersistStream and IMoniker functions. */ |
| static ICOM_VTABLE(IMoniker) VT_AntiMonikerImpl = |
| { |
| AntiMonikerImpl_QueryInterface, |
| AntiMonikerImpl_AddRef, |
| AntiMonikerImpl_Release, |
| AntiMonikerImpl_GetClassID, |
| AntiMonikerImpl_IsDirty, |
| AntiMonikerImpl_Load, |
| AntiMonikerImpl_Save, |
| AntiMonikerImpl_GetSizeMax, |
| AntiMonikerImpl_BindToObject, |
| AntiMonikerImpl_BindToStorage, |
| AntiMonikerImpl_Reduce, |
| AntiMonikerImpl_ComposeWith, |
| AntiMonikerImpl_Enum, |
| AntiMonikerImpl_IsEqual, |
| AntiMonikerImpl_Hash, |
| AntiMonikerImpl_IsRunning, |
| AntiMonikerImpl_GetTimeOfLastChange, |
| AntiMonikerImpl_Inverse, |
| AntiMonikerImpl_CommonPrefixWith, |
| AntiMonikerImpl_RelativePathTo, |
| AntiMonikerImpl_GetDisplayName, |
| AntiMonikerImpl_ParseDisplayName, |
| AntiMonikerImpl_IsSystemMoniker |
| }; |
| |
| /********************************************************************************/ |
| /* Virtual function table for the IROTData class. */ |
| static ICOM_VTABLE(IROTData) VT_ROTDataImpl = |
| { |
| AntiMonikerROTDataImpl_QueryInterface, |
| AntiMonikerROTDataImpl_AddRef, |
| AntiMonikerROTDataImpl_Release, |
| AntiMonikerROTDataImpl_GetComparaisonData |
| }; |
| |
| /******************************************************************************* |
| * AntiMoniker_QueryInterface |
| *******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject) |
| { |
| ICOM_THIS(AntiMonikerImpl,iface); |
| |
| TRACE(ole,"(%p,%p,%p)\n",This,riid,ppvObject); |
| |
| /* Perform a sanity check on the parameters.*/ |
| if ( (This==0) || (ppvObject==0) ) |
| return E_INVALIDARG; |
| |
| /* Initialize the return parameter */ |
| *ppvObject = 0; |
| |
| /* Compare the riid with the interface IDs implemented by this object.*/ |
| if (IsEqualIID(&IID_IUnknown, riid) || |
| IsEqualIID(&IID_IPersist, riid) || |
| IsEqualIID(&IID_IPersistStream, riid) || |
| IsEqualIID(&IID_IMoniker, riid) |
| ) |
| *ppvObject = iface; |
| else if (IsEqualIID(&IID_IROTData, riid)) |
| *ppvObject = (IROTData*)&(This->lpvtbl2); |
| |
| /* Check that we obtained an interface.*/ |
| if ((*ppvObject)==0) |
| return E_NOINTERFACE; |
| |
| /* Query Interface always increases the reference count by one when it is successful */ |
| AntiMonikerImpl_AddRef(iface); |
| |
| return S_OK; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_AddRef |
| ******************************************************************************/ |
| ULONG WINAPI AntiMonikerImpl_AddRef(IMoniker* iface) |
| { |
| ICOM_THIS(AntiMonikerImpl,iface); |
| |
| TRACE(ole,"(%p)\n",This); |
| |
| return ++(This->ref); |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_Release |
| ******************************************************************************/ |
| ULONG WINAPI AntiMonikerImpl_Release(IMoniker* iface) |
| { |
| ICOM_THIS(AntiMonikerImpl,iface); |
| |
| TRACE(ole,"(%p)\n",This); |
| |
| This->ref--; |
| |
| /* destroy the object if there's no more reference on it */ |
| if (This->ref==0){ |
| |
| AntiMonikerImpl_Destroy(This); |
| |
| return 0; |
| } |
| return This->ref;; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_GetClassID |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_GetClassID(const IMoniker* iface,CLSID *pClassID) |
| { |
| TRACE(ole,"(%p,%p),stub!\n",iface,pClassID); |
| |
| if (pClassID==NULL) |
| return E_POINTER; |
| |
| *pClassID = CLSID_AntiMoniker; |
| |
| return S_OK; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_IsDirty |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_IsDirty(IMoniker* iface) |
| { |
| /* Note that the OLE-provided implementations of the IPersistStream::IsDirty |
| method in the OLE-provided moniker interfaces always return S_FALSE because |
| their internal state never changes. */ |
| |
| TRACE(ole,"(%p)\n",iface); |
| |
| return S_FALSE; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_Load |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_Load(IMoniker* iface,IStream* pStm) |
| { |
| DWORD constant=1,dwbuffer; |
| HRESULT res; |
| |
| /* data read by this function is only a DWORD constant (must be 1) ! */ |
| res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),NULL); |
| |
| if (SUCCEEDED(res)&& dwbuffer!=constant) |
| return E_FAIL; |
| |
| return res; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_Save |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_Save(IMoniker* iface,IStream* pStm,BOOL fClearDirty) |
| { |
| DWORD constant=1; |
| HRESULT res; |
| |
| /* data writen by this function is only a DWORD constant seted to 1 ! */ |
| res=IStream_Write(pStm,&constant,sizeof(constant),NULL); |
| |
| return res; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_GetSizeMax |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_GetSizeMax(IMoniker* iface, |
| ULARGE_INTEGER* pcbSize)/* Pointer to size of stream needed to save object */ |
| { |
| TRACE(ole,"(%p,%p)\n",iface,pcbSize); |
| |
| if (pcbSize!=NULL) |
| return E_POINTER; |
| |
| /* for more details see AntiMonikerImpl_Save coments */ |
| |
| /* Normaly the sizemax must be the size of DWORD ! but I tested this function it ususlly return 16 bytes */ |
| /* more than the number of bytes used by AntiMoniker::Save function */ |
| pcbSize->LowPart = sizeof(DWORD)+16; |
| |
| pcbSize->HighPart=0; |
| |
| return S_OK; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_Construct (local function) |
| *******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_Construct(AntiMonikerImpl* This) |
| { |
| |
| TRACE(ole,"(%p)\n",This); |
| |
| /* Initialize the virtual fgunction table. */ |
| This->lpvtbl1 = &VT_AntiMonikerImpl; |
| This->lpvtbl2 = &VT_ROTDataImpl; |
| This->ref = 0; |
| |
| return S_OK; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_Destroy (local function) |
| *******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_Destroy(AntiMonikerImpl* This) |
| { |
| TRACE(ole,"(%p)\n",This); |
| |
| return HeapFree(GetProcessHeap(),0,This); |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_BindToObject |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_BindToObject(IMoniker* iface, |
| IBindCtx* pbc, |
| IMoniker* pmkToLeft, |
| REFIID riid, |
| VOID** ppvResult) |
| { |
| TRACE(ole,"(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult); |
| return E_NOTIMPL; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_BindToStorage |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_BindToStorage(IMoniker* iface, |
| IBindCtx* pbc, |
| IMoniker* pmkToLeft, |
| REFIID riid, |
| VOID** ppvResult) |
| { |
| TRACE(ole,"(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult); |
| return E_NOTIMPL; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_Reduce |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_Reduce(IMoniker* iface, |
| IBindCtx* pbc, |
| DWORD dwReduceHowFar, |
| IMoniker** ppmkToLeft, |
| IMoniker** ppmkReduced) |
| { |
| TRACE(ole,"(%p,%p,%ld,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced); |
| |
| if (ppmkReduced==NULL) |
| return E_POINTER; |
| |
| AntiMonikerImpl_AddRef(iface); |
| |
| *ppmkReduced=iface; |
| |
| return MK_S_REDUCED_TO_SELF; |
| } |
| /****************************************************************************** |
| * AntiMoniker_ComposeWith |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_ComposeWith(IMoniker* iface, |
| IMoniker* pmkRight, |
| BOOL fOnlyIfNotGeneric, |
| IMoniker** ppmkComposite) |
| { |
| |
| TRACE(ole,"(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite); |
| |
| if ((ppmkComposite==NULL)||(pmkRight==NULL)) |
| return E_POINTER; |
| |
| *ppmkComposite=0; |
| |
| if (fOnlyIfNotGeneric) |
| return MK_E_NEEDGENERIC; |
| else |
| return CreateGenericComposite(iface,pmkRight,ppmkComposite); |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_Enum |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker) |
| { |
| TRACE(ole,"(%p,%d,%p)\n",iface,fForward,ppenumMoniker); |
| |
| if (ppenumMoniker == NULL) |
| return E_POINTER; |
| |
| *ppenumMoniker = NULL; |
| |
| return S_OK; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_IsEqual |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker) |
| { |
| DWORD mkSys; |
| |
| TRACE(ole,"(%p,%p)\n",iface,pmkOtherMoniker); |
| |
| if (pmkOtherMoniker==NULL) |
| return S_FALSE; |
| |
| IMoniker_IsSystemMoniker(pmkOtherMoniker,&mkSys); |
| |
| if (mkSys==MKSYS_ANTIMONIKER) |
| return S_OK; |
| else |
| return S_FALSE; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_Hash |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash) |
| { |
| if (pdwHash==NULL) |
| return E_POINTER; |
| |
| *pdwHash=0; |
| |
| return S_OK; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_IsRunning |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_IsRunning(IMoniker* iface, |
| IBindCtx* pbc, |
| IMoniker* pmkToLeft, |
| IMoniker* pmkNewlyRunning) |
| { |
| IRunningObjectTable* rot; |
| HRESULT res; |
| |
| TRACE(ole,"(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning); |
| |
| if (pbc==NULL) |
| return E_INVALIDARG; |
| |
| res=IBindCtx_GetRunningObjectTable(pbc,&rot); |
| |
| if (FAILED(res)) |
| return res; |
| |
| res = IRunningObjectTable_IsRunning(rot,iface); |
| |
| IRunningObjectTable_Release(rot); |
| |
| return res; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_GetTimeOfLastChange |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_GetTimeOfLastChange(IMoniker* iface, |
| IBindCtx* pbc, |
| IMoniker* pmkToLeft, |
| FILETIME* pAntiTime) |
| { |
| TRACE(ole,"(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pAntiTime); |
| return E_NOTIMPL; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_Inverse |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk) |
| { |
| TRACE(ole,"(%p,%p)\n",iface,ppmk); |
| |
| if (ppmk==NULL) |
| return E_POINTER; |
| |
| *ppmk=0; |
| |
| return MK_E_NOINVERSE; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_CommonPrefixWith |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix) |
| { |
| DWORD mkSys; |
| |
| IMoniker_IsSystemMoniker(pmkOther,&mkSys); |
| |
| if(mkSys==MKSYS_ITEMMONIKER){ |
| |
| IMoniker_AddRef(iface); |
| |
| *ppmkPrefix=iface; |
| |
| IMoniker_AddRef(iface); |
| |
| return MK_S_US; |
| } |
| else |
| return MonikerCommonPrefixWith(iface,pmkOther,ppmkPrefix); |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_RelativePathTo |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath) |
| { |
| TRACE(ole,"(%p,%p,%p)\n",iface,pmOther,ppmkRelPath); |
| |
| if (ppmkRelPath==NULL) |
| return E_POINTER; |
| |
| IMoniker_AddRef(pmOther); |
| |
| *ppmkRelPath=pmOther; |
| |
| return MK_S_HIM; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_GetDisplayName |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_GetDisplayName(IMoniker* iface, |
| IBindCtx* pbc, |
| IMoniker* pmkToLeft, |
| LPOLESTR *ppszDisplayName) |
| { |
| WCHAR back[]={'\\','.','.',0}; |
| |
| TRACE(ole,"(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName); |
| |
| if (ppszDisplayName==NULL) |
| return E_POINTER; |
| |
| if (pmkToLeft!=NULL){ |
| FIXME(ole,"() pmkToLeft!=NULL not implemented \n"); |
| return E_NOTIMPL; |
| } |
| |
| *ppszDisplayName=CoTaskMemAlloc(sizeof(back)); |
| |
| if (*ppszDisplayName==NULL) |
| return E_OUTOFMEMORY; |
| |
| lstrcpyW(*ppszDisplayName,back); |
| |
| return S_OK; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_ParseDisplayName |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_ParseDisplayName(IMoniker* iface, |
| IBindCtx* pbc, |
| IMoniker* pmkToLeft, |
| LPOLESTR pszDisplayName, |
| ULONG* pchEaten, |
| IMoniker** ppmkOut) |
| { |
| TRACE(ole,"(%p,%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut); |
| return E_NOTIMPL; |
| } |
| |
| /****************************************************************************** |
| * AntiMoniker_IsSystemMonker |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys) |
| { |
| TRACE(ole,"(%p,%p)\n",iface,pwdMksys); |
| |
| if (!pwdMksys) |
| return E_POINTER; |
| |
| (*pwdMksys)=MKSYS_ANTIMONIKER; |
| |
| return S_OK; |
| } |
| |
| /******************************************************************************* |
| * AntiMonikerIROTData_QueryInterface |
| *******************************************************************************/ |
| HRESULT WINAPI AntiMonikerROTDataImpl_QueryInterface(IROTData *iface,REFIID riid,VOID** ppvObject) |
| { |
| |
| ICOM_THIS_From_IROTData(IMoniker, iface); |
| |
| TRACE(ole,"(%p,%p,%p)\n",iface,riid,ppvObject); |
| |
| return AntiMonikerImpl_QueryInterface(This, riid, ppvObject); |
| } |
| |
| /*********************************************************************** |
| * AntiMonikerIROTData_AddRef |
| */ |
| ULONG WINAPI AntiMonikerROTDataImpl_AddRef(IROTData *iface) |
| { |
| ICOM_THIS_From_IROTData(IMoniker, iface); |
| |
| TRACE(ole,"(%p)\n",iface); |
| |
| return AntiMonikerImpl_AddRef(This); |
| } |
| |
| /*********************************************************************** |
| * AntiMonikerIROTData_Release |
| */ |
| ULONG WINAPI AntiMonikerROTDataImpl_Release(IROTData* iface) |
| { |
| ICOM_THIS_From_IROTData(IMoniker, iface); |
| |
| TRACE(ole,"(%p)\n",iface); |
| |
| return AntiMonikerImpl_Release(This); |
| } |
| |
| /****************************************************************************** |
| * AntiMonikerIROTData_GetComparaisonData |
| ******************************************************************************/ |
| HRESULT WINAPI AntiMonikerROTDataImpl_GetComparaisonData(IROTData* iface, |
| BYTE* pbData, |
| ULONG cbMax, |
| ULONG* pcbData) |
| { |
| FIXME(ole,"(),stub!\n"); |
| return E_NOTIMPL; |
| } |
| |
| /****************************************************************************** |
| * CreateAntiMoniker [OLE.55] |
| ******************************************************************************/ |
| HRESULT WINAPI CreateAntiMoniker(LPMONIKER * ppmk) |
| { |
| AntiMonikerImpl* newAntiMoniker = 0; |
| HRESULT hr = S_OK; |
| IID riid=IID_IMoniker; |
| |
| TRACE(ole,"(%p)\n",ppmk); |
| |
| newAntiMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(AntiMonikerImpl)); |
| |
| if (newAntiMoniker == 0) |
| return STG_E_INSUFFICIENTMEMORY; |
| |
| hr = AntiMonikerImpl_Construct(newAntiMoniker); |
| |
| if (FAILED(hr)){ |
| |
| HeapFree(GetProcessHeap(),0,newAntiMoniker); |
| return hr; |
| } |
| |
| hr = AntiMonikerImpl_QueryInterface((IMoniker*)newAntiMoniker,&riid,(void**)ppmk); |
| |
| return hr; |
| } |
