/* * CompositeMonikers implementation * * Copyright 1999 Noomen Hamza * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include <assert.h> #include <stdarg.h> #include <string.h> #define COBJMACROS #include "windef.h" #include "winbase.h" #include "winuser.h" #include "winerror.h" #include "wine/debug.h" #include "wine/unicode.h" #include "ole2.h" #include "moniker.h" WINE_DEFAULT_DEBUG_CHANNEL(ole); #define BLOCK_TAB_SIZE 5 /* represent the first size table and its increment block size */ /* CompositeMoniker data structure */ typedef struct CompositeMonikerImpl{ IMoniker IMoniker_iface; IROTData IROTData_iface; IMarshal IMarshal_iface; LONG ref; IMoniker** tabMoniker; /* dynamic table containing all components (monikers) of this composite moniker */ ULONG tabSize; /* size of tabMoniker */ ULONG tabLastIndex; /* first free index in tabMoniker */ } CompositeMonikerImpl; static inline CompositeMonikerImpl *impl_from_IMoniker(IMoniker *iface) { return CONTAINING_RECORD(iface, CompositeMonikerImpl, IMoniker_iface); } static inline CompositeMonikerImpl *impl_from_IROTData(IROTData *iface) { return CONTAINING_RECORD(iface, CompositeMonikerImpl, IROTData_iface); } static inline CompositeMonikerImpl *impl_from_IMarshal(IMarshal *iface) { return CONTAINING_RECORD(iface, CompositeMonikerImpl, IMarshal_iface); } /* EnumMoniker data structure */ typedef struct EnumMonikerImpl{ IEnumMoniker IEnumMoniker_iface; LONG ref; IMoniker** tabMoniker; /* dynamic table containing the enumerated monikers */ ULONG tabSize; /* size of tabMoniker */ ULONG currentPos; /* index pointer on the current moniker */ } EnumMonikerImpl; static inline EnumMonikerImpl *impl_from_IEnumMoniker(IEnumMoniker *iface) { return CONTAINING_RECORD(iface, EnumMonikerImpl, IEnumMoniker_iface); } static HRESULT EnumMonikerImpl_CreateEnumMoniker(IMoniker** tabMoniker,ULONG tabSize,ULONG currentPos,BOOL leftToRight,IEnumMoniker ** ppmk); /******************************************************************************* * CompositeMoniker_QueryInterface *******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject) { CompositeMonikerImpl *This = impl_from_IMoniker(iface); TRACE("(%p,%p,%p)\n",This,riid,ppvObject); /* Perform a sanity check on the parameters.*/ if ( 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 = &This->IROTData_iface; else if (IsEqualIID(&IID_IMarshal, riid)) *ppvObject = &This->IMarshal_iface; /* 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 */ IMoniker_AddRef(iface); return S_OK; } /****************************************************************************** * CompositeMoniker_AddRef ******************************************************************************/ static ULONG WINAPI CompositeMonikerImpl_AddRef(IMoniker* iface) { CompositeMonikerImpl *This = impl_from_IMoniker(iface); TRACE("(%p)\n",This); return InterlockedIncrement(&This->ref); } static void CompositeMonikerImpl_ReleaseMonikersInTable(CompositeMonikerImpl *This) { ULONG i; for (i = 0; i < This->tabLastIndex; i++) IMoniker_Release(This->tabMoniker[i]); This->tabLastIndex = 0; } /****************************************************************************** * CompositeMoniker_Release ******************************************************************************/ static ULONG WINAPI CompositeMonikerImpl_Release(IMoniker* iface) { CompositeMonikerImpl *This = impl_from_IMoniker(iface); ULONG ref; TRACE("(%p)\n",This); ref = InterlockedDecrement(&This->ref); /* destroy the object if there are no more references to it */ if (ref == 0){ /* release all the components before destroying this object */ CompositeMonikerImpl_ReleaseMonikersInTable(This); HeapFree(GetProcessHeap(),0,This->tabMoniker); HeapFree(GetProcessHeap(),0,This); } return ref; } /****************************************************************************** * CompositeMoniker_GetClassID ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_GetClassID(IMoniker* iface,CLSID *pClassID) { TRACE("(%p,%p)\n",iface,pClassID); if (pClassID==NULL) return E_POINTER; *pClassID = CLSID_CompositeMoniker; return S_OK; } /****************************************************************************** * CompositeMoniker_IsDirty ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_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("(%p)\n",iface); return S_FALSE; } /****************************************************************************** * CompositeMoniker_Load ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_Load(IMoniker* iface,IStream* pStm) { CompositeMonikerImpl *This = impl_from_IMoniker(iface); HRESULT res; DWORD moniker_count; DWORD i; TRACE("(%p,%p)\n",iface,pStm); /* this function call OleLoadFromStream function for each moniker within this object */ res=IStream_Read(pStm,&moniker_count,sizeof(DWORD),NULL); if (res != S_OK) { ERR("couldn't reading moniker count from stream\n"); return E_FAIL; } CompositeMonikerImpl_ReleaseMonikersInTable(This); for (i = 0; i < moniker_count; i++) { res=OleLoadFromStream(pStm,&IID_IMoniker,(void**)&This->tabMoniker[This->tabLastIndex]); if (FAILED(res)) { ERR("couldn't load moniker from stream, res = 0x%08x\n", res); break; } /* resize the table if needed */ if (++This->tabLastIndex==This->tabSize){ This->tabSize+=BLOCK_TAB_SIZE; This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(This->tabMoniker[0])); if (This->tabMoniker==NULL) return E_OUTOFMEMORY; } } return res; } /****************************************************************************** * CompositeMoniker_Save ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_Save(IMoniker* iface,IStream* pStm,BOOL fClearDirty) { CompositeMonikerImpl *This = impl_from_IMoniker(iface); HRESULT res; IEnumMoniker *enumMk; IMoniker *pmk; DWORD moniker_count = This->tabLastIndex; TRACE("(%p,%p,%d)\n",iface,pStm,fClearDirty); /* This function calls OleSaveToStream function for each moniker within * this object. * When I tested this function in windows, I usually found this constant * at the beginning of the stream. I don't known why (there's no * indication in the specification) ! */ res=IStream_Write(pStm,&moniker_count,sizeof(moniker_count),NULL); if (FAILED(res)) return res; IMoniker_Enum(iface,TRUE,&enumMk); while(IEnumMoniker_Next(enumMk,1,&pmk,NULL)==S_OK){ res=OleSaveToStream((IPersistStream*)pmk,pStm); IMoniker_Release(pmk); if (FAILED(res)){ IEnumMoniker_Release(enumMk); return res; } } IEnumMoniker_Release(enumMk); return S_OK; } /****************************************************************************** * CompositeMoniker_GetSizeMax ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_GetSizeMax(IMoniker* iface,ULARGE_INTEGER* pcbSize) { IEnumMoniker *enumMk; IMoniker *pmk; ULARGE_INTEGER ptmpSize; /* The sizeMax of this object is calculated by calling GetSizeMax on * each moniker within this object then summing all returned values */ TRACE("(%p,%p)\n",iface,pcbSize); if (!pcbSize) return E_POINTER; pcbSize->QuadPart = sizeof(DWORD); IMoniker_Enum(iface,TRUE,&enumMk); while(IEnumMoniker_Next(enumMk,1,&pmk,NULL)==S_OK){ IMoniker_GetSizeMax(pmk,&ptmpSize); IMoniker_Release(pmk); pcbSize->QuadPart = ptmpSize.QuadPart + sizeof(CLSID); } IEnumMoniker_Release(enumMk); return S_OK; } /****************************************************************************** * CompositeMoniker_BindToObject ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_BindToObject(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult) { HRESULT res; IRunningObjectTable *prot; IMoniker *tempMk,*antiMk,*rightMostMk; IEnumMoniker *enumMoniker; TRACE("(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult); if (ppvResult==NULL) return E_POINTER; *ppvResult=0; /* If pmkToLeft is NULL, this method looks for the moniker in the ROT, and if found, queries the retrieved */ /* object for the requested interface pointer. */ if(pmkToLeft==NULL){ res=IBindCtx_GetRunningObjectTable(pbc,&prot); if (SUCCEEDED(res)){ /* if the requested class was loaded before ! we don't need to reload it */ res = IRunningObjectTable_GetObject(prot,iface,(IUnknown**)ppvResult); if (res==S_OK) return res; } } else{ /* If pmkToLeft is not NULL, the method recursively calls IMoniker::BindToObject on the rightmost */ /* component of the composite, passing the rest of the composite as the pmkToLeft parameter for that call */ IMoniker_Enum(iface,FALSE,&enumMoniker); IEnumMoniker_Next(enumMoniker,1,&rightMostMk,NULL); IEnumMoniker_Release(enumMoniker); res=CreateAntiMoniker(&antiMk); res=IMoniker_ComposeWith(iface,antiMk,0,&tempMk); IMoniker_Release(antiMk); res=IMoniker_BindToObject(rightMostMk,pbc,tempMk,riid,ppvResult); IMoniker_Release(tempMk); IMoniker_Release(rightMostMk); } return res; } /****************************************************************************** * CompositeMoniker_BindToStorage ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_BindToStorage(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult) { HRESULT res; IMoniker *tempMk,*antiMk,*rightMostMk,*leftMk; IEnumMoniker *enumMoniker; TRACE("(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult); *ppvResult=0; /* This method recursively calls BindToStorage on the rightmost component of the composite, */ /* passing the rest of the composite as the pmkToLeft parameter for that call. */ if (pmkToLeft) { res = IMoniker_ComposeWith(pmkToLeft, iface, FALSE, &leftMk); if (FAILED(res)) return res; } else leftMk = iface; IMoniker_Enum(iface, FALSE, &enumMoniker); IEnumMoniker_Next(enumMoniker, 1, &rightMostMk, NULL); IEnumMoniker_Release(enumMoniker); res = CreateAntiMoniker(&antiMk); if (FAILED(res)) return res; res = IMoniker_ComposeWith(leftMk, antiMk, 0, &tempMk); if (FAILED(res)) return res; IMoniker_Release(antiMk); res = IMoniker_BindToStorage(rightMostMk, pbc, tempMk, riid, ppvResult); IMoniker_Release(tempMk); IMoniker_Release(rightMostMk); if (pmkToLeft) IMoniker_Release(leftMk); return res; } /****************************************************************************** * CompositeMoniker_Reduce ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_Reduce(IMoniker* iface, IBindCtx* pbc, DWORD dwReduceHowFar, IMoniker** ppmkToLeft, IMoniker** ppmkReduced) { IMoniker *tempMk,*antiMk,*rightMostMk,*leftReducedComposedMk,*rightMostReducedMk; IEnumMoniker *enumMoniker; TRACE("(%p,%p,%d,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced); if (ppmkReduced==NULL) return E_POINTER; /* This method recursively calls Reduce for each of its component monikers. */ if (ppmkToLeft==NULL){ IMoniker_Enum(iface,FALSE,&enumMoniker); IEnumMoniker_Next(enumMoniker,1,&rightMostMk,NULL); IEnumMoniker_Release(enumMoniker); CreateAntiMoniker(&antiMk); IMoniker_ComposeWith(iface,antiMk,0,&tempMk); IMoniker_Release(antiMk); return IMoniker_Reduce(rightMostMk,pbc,dwReduceHowFar,&tempMk, ppmkReduced); } else if (*ppmkToLeft==NULL) return IMoniker_Reduce(iface,pbc,dwReduceHowFar,NULL,ppmkReduced); else{ /* separate the composite moniker in to left and right moniker */ IMoniker_Enum(iface,FALSE,&enumMoniker); IEnumMoniker_Next(enumMoniker,1,&rightMostMk,NULL); IEnumMoniker_Release(enumMoniker); CreateAntiMoniker(&antiMk); IMoniker_ComposeWith(iface,antiMk,0,&tempMk); IMoniker_Release(antiMk); /* If any of the components reduces itself, the method returns S_OK and passes back a composite */ /* of the reduced components */ if (IMoniker_Reduce(rightMostMk,pbc,dwReduceHowFar,NULL,&rightMostReducedMk) && IMoniker_Reduce(rightMostMk,pbc,dwReduceHowFar,&tempMk,&leftReducedComposedMk) ) return CreateGenericComposite(leftReducedComposedMk,rightMostReducedMk,ppmkReduced); else{ /* If no reduction occurred, the method passes back the same moniker and returns MK_S_REDUCED_TO_SELF.*/ IMoniker_AddRef(iface); *ppmkReduced=iface; return MK_S_REDUCED_TO_SELF; } } } /****************************************************************************** * CompositeMoniker_ComposeWith ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_ComposeWith(IMoniker* iface, IMoniker* pmkRight, BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite) { TRACE("(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite); if ((ppmkComposite==NULL)||(pmkRight==NULL)) return E_POINTER; *ppmkComposite=0; /* If fOnlyIfNotGeneric is TRUE, this method sets *pmkComposite to NULL and returns MK_E_NEEDGENERIC; */ /* otherwise, the method returns the result of combining the two monikers by calling the */ /* CreateGenericComposite function */ if (fOnlyIfNotGeneric) return MK_E_NEEDGENERIC; return CreateGenericComposite(iface,pmkRight,ppmkComposite); } /****************************************************************************** * CompositeMoniker_Enum ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker) { CompositeMonikerImpl *This = impl_from_IMoniker(iface); TRACE("(%p,%d,%p)\n",iface,fForward,ppenumMoniker); if (ppenumMoniker == NULL) return E_POINTER; return EnumMonikerImpl_CreateEnumMoniker(This->tabMoniker,This->tabLastIndex,0,fForward,ppenumMoniker); } /****************************************************************************** * CompositeMoniker_IsEqual ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker) { IEnumMoniker *enumMoniker1,*enumMoniker2; IMoniker *tempMk1,*tempMk2; HRESULT res1,res2,res; BOOL done; TRACE("(%p,%p)\n",iface,pmkOtherMoniker); if (pmkOtherMoniker==NULL) return S_FALSE; /* This method returns S_OK if the components of both monikers are equal when compared in the */ /* left-to-right order.*/ IMoniker_Enum(pmkOtherMoniker,TRUE,&enumMoniker1); if (enumMoniker1==NULL) return S_FALSE; IMoniker_Enum(iface,TRUE,&enumMoniker2); do { res1=IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL); res2=IEnumMoniker_Next(enumMoniker2,1,&tempMk2,NULL); if((res1==S_OK)&&(res2==S_OK)){ done = (res = IMoniker_IsEqual(tempMk1,tempMk2)) == S_FALSE; } else { res = (res1==S_FALSE) && (res2==S_FALSE); done = TRUE; } if (res1==S_OK) IMoniker_Release(tempMk1); if (res2==S_OK) IMoniker_Release(tempMk2); } while (!done); IEnumMoniker_Release(enumMoniker1); IEnumMoniker_Release(enumMoniker2); return res; } /****************************************************************************** * CompositeMoniker_Hash ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash) { IEnumMoniker *enumMoniker; IMoniker *tempMk; HRESULT res; DWORD tempHash; TRACE("(%p,%p)\n",iface,pdwHash); if (pdwHash==NULL) return E_POINTER; res = IMoniker_Enum(iface,TRUE,&enumMoniker); if(FAILED(res)) return res; *pdwHash = 0; while(IEnumMoniker_Next(enumMoniker,1,&tempMk,NULL)==S_OK){ res = IMoniker_Hash(tempMk, &tempHash); if(FAILED(res)) break; *pdwHash = *pdwHash ^ tempHash; IMoniker_Release(tempMk); } IEnumMoniker_Release(enumMoniker); return res; } /****************************************************************************** * CompositeMoniker_IsRunning ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_IsRunning(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning) { IRunningObjectTable* rot; HRESULT res; IMoniker *tempMk,*antiMk,*rightMostMk; IEnumMoniker *enumMoniker; TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning); /* If pmkToLeft is non-NULL, this method composes pmkToLeft with this moniker and calls IsRunning on the result.*/ if (pmkToLeft!=NULL){ CreateGenericComposite(pmkToLeft,iface,&tempMk); res = IMoniker_IsRunning(tempMk,pbc,NULL,pmkNewlyRunning); IMoniker_Release(tempMk); return res; } else /* If pmkToLeft is NULL, this method returns S_OK if pmkNewlyRunning is non-NULL and is equal */ /* to this moniker */ if (pmkNewlyRunning!=NULL) if (IMoniker_IsEqual(iface,pmkNewlyRunning)==S_OK) return S_OK; else return S_FALSE; else{ if (pbc==NULL) return E_INVALIDARG; /* If pmkToLeft and pmkNewlyRunning are both NULL, this method checks the ROT to see whether */ /* the moniker is running. If so, the method returns S_OK; otherwise, it recursively calls */ /* IMoniker::IsRunning on the rightmost component of the composite, passing the remainder of */ /* the composite as the pmkToLeft parameter for that call. */ res=IBindCtx_GetRunningObjectTable(pbc,&rot); if (FAILED(res)) return res; res = IRunningObjectTable_IsRunning(rot,iface); IRunningObjectTable_Release(rot); if(res==S_OK) return S_OK; else{ IMoniker_Enum(iface,FALSE,&enumMoniker); IEnumMoniker_Next(enumMoniker,1,&rightMostMk,NULL); IEnumMoniker_Release(enumMoniker); res=CreateAntiMoniker(&antiMk); res=IMoniker_ComposeWith(iface,antiMk,0,&tempMk); IMoniker_Release(antiMk); res=IMoniker_IsRunning(rightMostMk,pbc,tempMk,pmkNewlyRunning); IMoniker_Release(tempMk); IMoniker_Release(rightMostMk); return res; } } } /****************************************************************************** * CompositeMoniker_GetTimeOfLastChange ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft, FILETIME* pCompositeTime) { HRESULT res; IMoniker *tempMk,*antiMk,*rightMostMk,*leftMk; IEnumMoniker *enumMoniker; TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pCompositeTime); if (pCompositeTime==NULL) return E_INVALIDARG; /* This method creates a composite of pmkToLeft (if non-NULL) and this moniker and uses the ROT to */ /* retrieve the time of last change. If the object is not in the ROT, the method recursively calls */ /* IMoniker::GetTimeOfLastChange on the rightmost component of the composite, passing the remainder */ /* of the composite as the pmkToLeft parameter for that call. */ if (pmkToLeft) { IRunningObjectTable* rot; res = IMoniker_ComposeWith(pmkToLeft, iface, FALSE, &leftMk); if (FAILED(res)) return res; res = IBindCtx_GetRunningObjectTable(pbc,&rot); if (FAILED(res)) { IMoniker_Release(leftMk); return res; } if (IRunningObjectTable_GetTimeOfLastChange(rot,leftMk,pCompositeTime)==S_OK) { IMoniker_Release(leftMk); return res; } } else leftMk = iface; IMoniker_Enum(iface, FALSE, &enumMoniker); IEnumMoniker_Next(enumMoniker, 1, &rightMostMk, NULL); IEnumMoniker_Release(enumMoniker); res = CreateAntiMoniker(&antiMk); res = IMoniker_ComposeWith(leftMk, antiMk, 0, &tempMk); IMoniker_Release(antiMk); res = IMoniker_GetTimeOfLastChange(rightMostMk, pbc, tempMk, pCompositeTime); IMoniker_Release(tempMk); IMoniker_Release(rightMostMk); if (pmkToLeft) IMoniker_Release(leftMk); return res; } /****************************************************************************** * CompositeMoniker_Inverse ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk) { HRESULT res; IMoniker *tempMk,*antiMk,*rightMostMk,*tempInvMk,*rightMostInvMk; IEnumMoniker *enumMoniker; TRACE("(%p,%p)\n",iface,ppmk); if (ppmk==NULL) return E_POINTER; /* This method returns a composite moniker that consists of the inverses of each of the components */ /* of the original composite, stored in reverse order */ *ppmk = NULL; res=CreateAntiMoniker(&antiMk); if (FAILED(res)) return res; res=IMoniker_ComposeWith(iface,antiMk,FALSE,&tempMk); IMoniker_Release(antiMk); if (FAILED(res)) return res; if (tempMk==NULL) return IMoniker_Inverse(iface,ppmk); else{ IMoniker_Enum(iface,FALSE,&enumMoniker); IEnumMoniker_Next(enumMoniker,1,&rightMostMk,NULL); IEnumMoniker_Release(enumMoniker); IMoniker_Inverse(rightMostMk,&rightMostInvMk); CompositeMonikerImpl_Inverse(tempMk,&tempInvMk); res=CreateGenericComposite(rightMostInvMk,tempInvMk,ppmk); IMoniker_Release(tempMk); IMoniker_Release(rightMostMk); IMoniker_Release(tempInvMk); IMoniker_Release(rightMostInvMk); return res; } } /****************************************************************************** * CompositeMoniker_CommonPrefixWith ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_CommonPrefixWith(IMoniker* iface, IMoniker* pmkOther, IMoniker** ppmkPrefix) { DWORD mkSys; HRESULT res1,res2; IMoniker *tempMk1,*tempMk2,*mostLeftMk1,*mostLeftMk2; IEnumMoniker *enumMoniker1,*enumMoniker2; ULONG i,nbCommonMk=0; /* If the other moniker is a composite, this method compares the components of each composite from left */ /* to right. The returned common prefix moniker might also be a composite moniker, depending on how many */ /* of the leftmost components were common to both monikers. */ if (ppmkPrefix==NULL) return E_POINTER; *ppmkPrefix=0; if (pmkOther==NULL) return MK_E_NOPREFIX; IMoniker_IsSystemMoniker(pmkOther,&mkSys); if(mkSys==MKSYS_GENERICCOMPOSITE){ IMoniker_Enum(iface,TRUE,&enumMoniker1); IMoniker_Enum(pmkOther,TRUE,&enumMoniker2); while(1){ res1=IEnumMoniker_Next(enumMoniker1,1,&mostLeftMk1,NULL); res2=IEnumMoniker_Next(enumMoniker2,1,&mostLeftMk2,NULL); if ((res1==S_FALSE) && (res2==S_FALSE)){ /* If the monikers are equal, the method returns MK_S_US and sets ppmkPrefix to this moniker.*/ *ppmkPrefix=iface; IMoniker_AddRef(iface); return MK_S_US; } else if ((res1==S_OK) && (res2==S_OK)){ if (IMoniker_IsEqual(mostLeftMk1,mostLeftMk2)==S_OK) nbCommonMk++; else break; } else if (res1==S_OK){ /* If the other moniker is a prefix of this moniker, the method returns MK_S_HIM and sets */ /* ppmkPrefix to the other moniker. */ *ppmkPrefix=pmkOther; return MK_S_HIM; } else{ /* If this moniker is a prefix of the other, this method returns MK_S_ME and sets ppmkPrefix */ /* to this moniker. */ *ppmkPrefix=iface; return MK_S_ME; } } IEnumMoniker_Release(enumMoniker1); IEnumMoniker_Release(enumMoniker2); /* If there is no common prefix, this method returns MK_E_NOPREFIX and sets ppmkPrefix to NULL. */ if (nbCommonMk==0) return MK_E_NOPREFIX; IEnumMoniker_Reset(enumMoniker1); IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL); /* if we have more than one common moniker the result will be a composite moniker */ if (nbCommonMk>1){ /* initialize the common prefix moniker with the composite of two first moniker (from the left)*/ IEnumMoniker_Next(enumMoniker1,1,&tempMk2,NULL); CreateGenericComposite(tempMk1,tempMk2,ppmkPrefix); IMoniker_Release(tempMk1); IMoniker_Release(tempMk2); /* compose all common monikers in a composite moniker */ for(i=0;i<nbCommonMk;i++){ IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL); CreateGenericComposite(*ppmkPrefix,tempMk1,&tempMk2); IMoniker_Release(*ppmkPrefix); IMoniker_Release(tempMk1); *ppmkPrefix=tempMk2; } return S_OK; } else{ /* if we have only one common moniker the result will be a simple moniker which is the most-left one*/ *ppmkPrefix=tempMk1; return S_OK; } } else{ /* If the other moniker is not a composite, the method simply compares it to the leftmost component of this moniker.*/ IMoniker_Enum(iface,TRUE,&enumMoniker1); IEnumMoniker_Next(enumMoniker1,1,&mostLeftMk1,NULL); if (IMoniker_IsEqual(pmkOther,mostLeftMk1)==S_OK){ *ppmkPrefix=pmkOther; return MK_S_HIM; } else return MK_E_NOPREFIX; } } /*************************************************************************************************** * GetAfterCommonPrefix (local function) * This function returns a moniker that consist of the remainder when the common prefix is removed ***************************************************************************************************/ static VOID GetAfterCommonPrefix(IMoniker* pGenMk,IMoniker* commonMk,IMoniker** restMk) { IMoniker *tempMk,*tempMk1,*tempMk2; IEnumMoniker *enumMoniker1,*enumMoniker2,*enumMoniker3; ULONG nbRestMk=0; DWORD mkSys; HRESULT res1,res2; *restMk=0; /* to create an enumerator for pGenMk with current position pointed on the first element after common */ /* prefix: enum the two monikers (left-right) then compare these enumerations (left-right) and stop */ /* on the first difference. */ IMoniker_Enum(pGenMk,TRUE,&enumMoniker1); IMoniker_IsSystemMoniker(commonMk,&mkSys); if (mkSys==MKSYS_GENERICCOMPOSITE){ IMoniker_Enum(commonMk,TRUE,&enumMoniker2); while(1){ res1=IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL); res2=IEnumMoniker_Next(enumMoniker2,1,&tempMk2,NULL); if ((res1==S_FALSE)||(res2==S_FALSE)){ if (res1==S_OK) nbRestMk++; IMoniker_Release(tempMk1); IMoniker_Release(tempMk2); break; } IMoniker_Release(tempMk1); IMoniker_Release(tempMk2); } } else{ IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL); IMoniker_Release(tempMk1); } /* count the number of elements in the enumerator after the common prefix */ IEnumMoniker_Clone(enumMoniker1,&enumMoniker3); for(;IEnumMoniker_Next(enumMoniker3,1,&tempMk,NULL)==S_OK;nbRestMk++) IMoniker_Release(tempMk); if (nbRestMk==0) return; /* create a generic composite moniker with monikers located after the common prefix */ IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL); if (nbRestMk==1){ *restMk= tempMk1; return; } else { IEnumMoniker_Next(enumMoniker1,1,&tempMk2,NULL); CreateGenericComposite(tempMk1,tempMk2,restMk); IMoniker_Release(tempMk1); IMoniker_Release(tempMk2); while(IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL)==S_OK){ CreateGenericComposite(*restMk,tempMk1,&tempMk2); IMoniker_Release(tempMk1); IMoniker_Release(*restMk); *restMk=tempMk2; } } } /****************************************************************************** * CompositeMoniker_RelativePathTo ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmkOther, IMoniker** ppmkRelPath) { HRESULT res; IMoniker *restOtherMk=0,*restThisMk=0,*invRestThisMk=0,*commonMk=0; TRACE("(%p,%p,%p)\n",iface,pmkOther,ppmkRelPath); if (ppmkRelPath==NULL) return E_POINTER; *ppmkRelPath=0; /* This method finds the common prefix of the two monikers and creates two monikers that consist */ /* of the remainder when the common prefix is removed. Then it creates the inverse for the remainder */ /* of this moniker and composes the remainder of the other moniker on the right of it. */ /* finds the common prefix of the two monikers */ res=IMoniker_CommonPrefixWith(iface,pmkOther,&commonMk); /* if there's no common prefix or the two moniker are equal the relative is the other moniker */ if ((res== MK_E_NOPREFIX)||(res==MK_S_US)){ *ppmkRelPath=pmkOther; IMoniker_AddRef(pmkOther); return MK_S_HIM; } GetAfterCommonPrefix(iface,commonMk,&restThisMk); GetAfterCommonPrefix(pmkOther,commonMk,&restOtherMk); /* if other is a prefix of this moniker the relative path is the inverse of the remainder path of this */ /* moniker when the common prefix is removed */ if (res==MK_S_HIM){ IMoniker_Inverse(restThisMk,ppmkRelPath); IMoniker_Release(restThisMk); } /* if this moniker is a prefix of other moniker the relative path is the remainder path of other moniker */ /* when the common prefix is removed */ else if (res==MK_S_ME){ *ppmkRelPath=restOtherMk; IMoniker_AddRef(restOtherMk); } /* the relative path is the inverse for the remainder of this moniker and the remainder of the other */ /* moniker on the right of it. */ else if (res==S_OK){ IMoniker_Inverse(restThisMk,&invRestThisMk); IMoniker_Release(restThisMk); CreateGenericComposite(invRestThisMk,restOtherMk,ppmkRelPath); IMoniker_Release(invRestThisMk); IMoniker_Release(restOtherMk); } return S_OK; } /****************************************************************************** * CompositeMoniker_GetDisplayName ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_GetDisplayName(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName) { ULONG lengthStr=1; IEnumMoniker *enumMoniker; IMoniker* tempMk; LPOLESTR tempStr; TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName); if (ppszDisplayName==NULL) return E_POINTER; *ppszDisplayName=CoTaskMemAlloc(sizeof(WCHAR)); if (*ppszDisplayName==NULL) return E_OUTOFMEMORY; /* This method returns the concatenation of the display names returned by each component moniker of */ /* the composite */ **ppszDisplayName=0; IMoniker_Enum(iface,TRUE,&enumMoniker); while(IEnumMoniker_Next(enumMoniker,1,&tempMk,NULL)==S_OK){ IMoniker_GetDisplayName(tempMk,pbc,NULL,&tempStr); lengthStr+=lstrlenW(tempStr); *ppszDisplayName=CoTaskMemRealloc(*ppszDisplayName,lengthStr * sizeof(WCHAR)); if (*ppszDisplayName==NULL) return E_OUTOFMEMORY; strcatW(*ppszDisplayName,tempStr); CoTaskMemFree(tempStr); IMoniker_Release(tempMk); } IEnumMoniker_Release(enumMoniker); return S_OK; } /****************************************************************************** * CompositeMoniker_ParseDisplayName ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_ParseDisplayName(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut) { IEnumMoniker *enumMoniker; IMoniker *tempMk,*rightMostMk,*antiMk; /* This method recursively calls IMoniker::ParseDisplayName on the rightmost component of the composite,*/ /* passing everything else as the pmkToLeft parameter for that call. */ /* get the most right moniker */ IMoniker_Enum(iface,FALSE,&enumMoniker); IEnumMoniker_Next(enumMoniker,1,&rightMostMk,NULL); IEnumMoniker_Release(enumMoniker); /* get the left moniker */ CreateAntiMoniker(&antiMk); IMoniker_ComposeWith(iface,antiMk,0,&tempMk); IMoniker_Release(antiMk); return IMoniker_ParseDisplayName(rightMostMk,pbc,tempMk,pszDisplayName,pchEaten,ppmkOut); } /****************************************************************************** * CompositeMoniker_IsSystemMoniker ******************************************************************************/ static HRESULT WINAPI CompositeMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys) { TRACE("(%p,%p)\n",iface,pwdMksys); if (!pwdMksys) return E_POINTER; (*pwdMksys)=MKSYS_GENERICCOMPOSITE; return S_OK; } /******************************************************************************* * CompositeMonikerIROTData_QueryInterface *******************************************************************************/ static HRESULT WINAPI CompositeMonikerROTDataImpl_QueryInterface(IROTData *iface,REFIID riid, VOID** ppvObject) { CompositeMonikerImpl *This = impl_from_IROTData(iface); TRACE("(%p,%p,%p)\n",iface,riid,ppvObject); return CompositeMonikerImpl_QueryInterface(&This->IMoniker_iface, riid, ppvObject); } /*********************************************************************** * CompositeMonikerIROTData_AddRef */ static ULONG WINAPI CompositeMonikerROTDataImpl_AddRef(IROTData *iface) { CompositeMonikerImpl *This = impl_from_IROTData(iface); TRACE("(%p)\n",iface); return IMoniker_AddRef(&This->IMoniker_iface); } /*********************************************************************** * CompositeMonikerIROTData_Release */ static ULONG WINAPI CompositeMonikerROTDataImpl_Release(IROTData* iface) { CompositeMonikerImpl *This = impl_from_IROTData(iface); TRACE("(%p)\n",iface); return IMoniker_Release(&This->IMoniker_iface); } /****************************************************************************** * CompositeMonikerIROTData_GetComparisonData ******************************************************************************/ static HRESULT WINAPI CompositeMonikerROTDataImpl_GetComparisonData(IROTData* iface, BYTE* pbData, ULONG cbMax, ULONG* pcbData) { CompositeMonikerImpl *This = impl_from_IROTData(iface); IEnumMoniker *pEnumMk; IMoniker *pmk; HRESULT hr; TRACE("(%p, %u, %p)\n", pbData, cbMax, pcbData); *pcbData = sizeof(CLSID); hr = IMoniker_Enum(&This->IMoniker_iface, TRUE, &pEnumMk); if (FAILED(hr)) return hr; while(IEnumMoniker_Next(pEnumMk, 1, &pmk, NULL) == S_OK) { IROTData *pROTData; hr = IMoniker_QueryInterface(pmk, &IID_IROTData, (void **)&pROTData); if (FAILED(hr)) ERR("moniker doesn't support IROTData interface\n"); if (SUCCEEDED(hr)) { ULONG cbData; hr = IROTData_GetComparisonData(pROTData, NULL, 0, &cbData); IROTData_Release(pROTData); if (SUCCEEDED(hr) || (hr == E_OUTOFMEMORY)) { *pcbData += cbData; hr = S_OK; } else ERR("IROTData_GetComparisonData failed with error 0x%08x\n", hr); } IMoniker_Release(pmk); if (FAILED(hr)) { IEnumMoniker_Release(pEnumMk); return hr; } } if (cbMax < *pcbData) return E_OUTOFMEMORY; IEnumMoniker_Reset(pEnumMk); memcpy(pbData, &CLSID_CompositeMoniker, sizeof(CLSID)); pbData += sizeof(CLSID); cbMax -= sizeof(CLSID); while (IEnumMoniker_Next(pEnumMk, 1, &pmk, NULL) == S_OK) { IROTData *pROTData; hr = IMoniker_QueryInterface(pmk, &IID_IROTData, (void **)&pROTData); if (FAILED(hr)) ERR("moniker doesn't support IROTData interface\n"); if (SUCCEEDED(hr)) { ULONG cbData; hr = IROTData_GetComparisonData(pROTData, pbData, cbMax, &cbData); IROTData_Release(pROTData); if (SUCCEEDED(hr)) { pbData += cbData; cbMax -= cbData; } else ERR("IROTData_GetComparisonData failed with error 0x%08x\n", hr); } IMoniker_Release(pmk); if (FAILED(hr)) { IEnumMoniker_Release(pEnumMk); return hr; } } IEnumMoniker_Release(pEnumMk); return S_OK; } static HRESULT WINAPI CompositeMonikerMarshalImpl_QueryInterface(IMarshal *iface, REFIID riid, LPVOID *ppv) { CompositeMonikerImpl *This = impl_from_IMarshal(iface); TRACE("(%p,%s,%p)\n",iface,debugstr_guid(riid),ppv); return CompositeMonikerImpl_QueryInterface(&This->IMoniker_iface, riid, ppv); } static ULONG WINAPI CompositeMonikerMarshalImpl_AddRef(IMarshal *iface) { CompositeMonikerImpl *This = impl_from_IMarshal(iface); TRACE("(%p)\n",iface); return CompositeMonikerImpl_AddRef(&This->IMoniker_iface); } static ULONG WINAPI CompositeMonikerMarshalImpl_Release(IMarshal *iface) { CompositeMonikerImpl *This = impl_from_IMarshal(iface); TRACE("(%p)\n",iface); return CompositeMonikerImpl_Release(&This->IMoniker_iface); } static HRESULT WINAPI CompositeMonikerMarshalImpl_GetUnmarshalClass( IMarshal *iface, REFIID riid, void *pv, DWORD dwDestContext, void* pvDestContext, DWORD mshlflags, CLSID* pCid) { CompositeMonikerImpl *This = impl_from_IMarshal(iface); TRACE("(%s, %p, %x, %p, %x, %p)\n", debugstr_guid(riid), pv, dwDestContext, pvDestContext, mshlflags, pCid); return IMoniker_GetClassID(&This->IMoniker_iface, pCid); } static HRESULT WINAPI CompositeMonikerMarshalImpl_GetMarshalSizeMax( IMarshal *iface, REFIID riid, void *pv, DWORD dwDestContext, void* pvDestContext, DWORD mshlflags, DWORD* pSize) { CompositeMonikerImpl *This = impl_from_IMarshal(iface); IEnumMoniker *pEnumMk; IMoniker *pmk; HRESULT hr; ULARGE_INTEGER size; TRACE("(%s, %p, %x, %p, %x, %p)\n", debugstr_guid(riid), pv, dwDestContext, pvDestContext, mshlflags, pSize); *pSize = 0x10; /* to match native */ hr = IMoniker_Enum(&This->IMoniker_iface, TRUE, &pEnumMk); if (FAILED(hr)) return hr; hr = IMoniker_GetSizeMax(&This->IMoniker_iface, &size); while (IEnumMoniker_Next(pEnumMk, 1, &pmk, NULL) == S_OK) { ULONG size; hr = CoGetMarshalSizeMax(&size, &IID_IMoniker, (IUnknown *)pmk, dwDestContext, pvDestContext, mshlflags); if (SUCCEEDED(hr)) *pSize += size; IMoniker_Release(pmk); if (FAILED(hr)) { IEnumMoniker_Release(pEnumMk); return hr; } } IEnumMoniker_Release(pEnumMk); return S_OK; } static HRESULT WINAPI CompositeMonikerMarshalImpl_MarshalInterface(IMarshal *iface, IStream *pStm, REFIID riid, void* pv, DWORD dwDestContext, void* pvDestContext, DWORD mshlflags) { CompositeMonikerImpl *This = impl_from_IMarshal(iface); IEnumMoniker *pEnumMk; IMoniker *pmk; HRESULT hr; ULONG i = 0; TRACE("(%p, %s, %p, %x, %p, %x)\n", pStm, debugstr_guid(riid), pv, dwDestContext, pvDestContext, mshlflags); hr = IMoniker_Enum(&This->IMoniker_iface, TRUE, &pEnumMk); if (FAILED(hr)) return hr; while (IEnumMoniker_Next(pEnumMk, 1, &pmk, NULL) == S_OK) { hr = CoMarshalInterface(pStm, &IID_IMoniker, (IUnknown *)pmk, dwDestContext, pvDestContext, mshlflags); IMoniker_Release(pmk); if (FAILED(hr)) { IEnumMoniker_Release(pEnumMk); return hr; } i++; } if (i != 2) FIXME("moniker count of %d not supported\n", i); IEnumMoniker_Release(pEnumMk); return S_OK; } static HRESULT WINAPI CompositeMonikerMarshalImpl_UnmarshalInterface(IMarshal *iface, IStream *pStm, REFIID riid, void **ppv) { CompositeMonikerImpl *This = impl_from_IMarshal(iface); HRESULT hr; TRACE("(%p, %s, %p)\n", pStm, debugstr_guid(riid), ppv); CompositeMonikerImpl_ReleaseMonikersInTable(This); /* resize the table if needed */ if (This->tabLastIndex + 2 > This->tabSize) { This->tabSize += max(BLOCK_TAB_SIZE, 2); This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(This->tabMoniker[0])); if (This->tabMoniker==NULL) return E_OUTOFMEMORY; } hr = CoUnmarshalInterface(pStm, &IID_IMoniker, (void**)&This->tabMoniker[This->tabLastIndex]); if (FAILED(hr)) { ERR("couldn't unmarshal moniker, hr = 0x%08x\n", hr); return hr; } This->tabLastIndex++; hr = CoUnmarshalInterface(pStm, &IID_IMoniker, (void**)&This->tabMoniker[This->tabLastIndex]); if (FAILED(hr)) { ERR("couldn't unmarshal moniker, hr = 0x%08x\n", hr); return hr; } This->tabLastIndex++; return IMoniker_QueryInterface(&This->IMoniker_iface, riid, ppv); } static HRESULT WINAPI CompositeMonikerMarshalImpl_ReleaseMarshalData(IMarshal *iface, IStream *pStm) { TRACE("(%p)\n", pStm); /* can't release a state-based marshal as nothing on server side to * release */ return S_OK; } static HRESULT WINAPI CompositeMonikerMarshalImpl_DisconnectObject(IMarshal *iface, DWORD dwReserved) { TRACE("(0x%x)\n", dwReserved); /* can't disconnect a state-based marshal as nothing on server side to * disconnect from */ return S_OK; } /****************************************************************************** * EnumMonikerImpl_QueryInterface ******************************************************************************/ static HRESULT WINAPI EnumMonikerImpl_QueryInterface(IEnumMoniker* iface,REFIID riid,void** ppvObject) { EnumMonikerImpl *This = impl_from_IEnumMoniker(iface); TRACE("(%p,%p,%p)\n",This,riid,ppvObject); /* Perform a sanity check on the parameters.*/ if ( 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_IEnumMoniker, riid)) *ppvObject = iface; /* 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 */ IEnumMoniker_AddRef(iface); return S_OK; } /****************************************************************************** * EnumMonikerImpl_AddRef ******************************************************************************/ static ULONG WINAPI EnumMonikerImpl_AddRef(IEnumMoniker* iface) { EnumMonikerImpl *This = impl_from_IEnumMoniker(iface); TRACE("(%p)\n",This); return InterlockedIncrement(&This->ref); } /****************************************************************************** * EnumMonikerImpl_Release ******************************************************************************/ static ULONG WINAPI EnumMonikerImpl_Release(IEnumMoniker* iface) { EnumMonikerImpl *This = impl_from_IEnumMoniker(iface); ULONG i; ULONG ref; TRACE("(%p)\n",This); ref = InterlockedDecrement(&This->ref); /* destroy the object if there are no more references to it */ if (ref == 0) { for(i=0;i<This->tabSize;i++) IMoniker_Release(This->tabMoniker[i]); HeapFree(GetProcessHeap(),0,This->tabMoniker); HeapFree(GetProcessHeap(),0,This); } return ref; } /****************************************************************************** * EnumMonikerImpl_Next ******************************************************************************/ static HRESULT WINAPI EnumMonikerImpl_Next(IEnumMoniker* iface,ULONG celt, IMoniker** rgelt, ULONG* pceltFethed) { EnumMonikerImpl *This = impl_from_IEnumMoniker(iface); ULONG i; /* retrieve the requested number of moniker from the current position */ for(i=0;((This->currentPos < This->tabSize) && (i < celt));i++) { rgelt[i]=This->tabMoniker[This->currentPos++]; IMoniker_AddRef(rgelt[i]); } if (pceltFethed!=NULL) *pceltFethed= i; if (i==celt) return S_OK; else return S_FALSE; } /****************************************************************************** * EnumMonikerImpl_Skip ******************************************************************************/ static HRESULT WINAPI EnumMonikerImpl_Skip(IEnumMoniker* iface,ULONG celt) { EnumMonikerImpl *This = impl_from_IEnumMoniker(iface); if ((This->currentPos+celt) >= This->tabSize) return S_FALSE; This->currentPos+=celt; return S_OK; } /****************************************************************************** * EnumMonikerImpl_Reset ******************************************************************************/ static HRESULT WINAPI EnumMonikerImpl_Reset(IEnumMoniker* iface) { EnumMonikerImpl *This = impl_from_IEnumMoniker(iface); This->currentPos=0; return S_OK; } /****************************************************************************** * EnumMonikerImpl_Clone ******************************************************************************/ static HRESULT WINAPI EnumMonikerImpl_Clone(IEnumMoniker* iface,IEnumMoniker** ppenum) { EnumMonikerImpl *This = impl_from_IEnumMoniker(iface); return EnumMonikerImpl_CreateEnumMoniker(This->tabMoniker,This->tabSize,This->currentPos,TRUE,ppenum); } /********************************************************************************/ /* Virtual function table for the IROTData class */ static const IEnumMonikerVtbl VT_EnumMonikerImpl = { EnumMonikerImpl_QueryInterface, EnumMonikerImpl_AddRef, EnumMonikerImpl_Release, EnumMonikerImpl_Next, EnumMonikerImpl_Skip, EnumMonikerImpl_Reset, EnumMonikerImpl_Clone }; /****************************************************************************** * EnumMonikerImpl_CreateEnumMoniker ******************************************************************************/ static HRESULT EnumMonikerImpl_CreateEnumMoniker(IMoniker** tabMoniker, ULONG tabSize, ULONG currentPos, BOOL leftToRight, IEnumMoniker ** ppmk) { EnumMonikerImpl* newEnumMoniker; ULONG i; if (currentPos > tabSize) return E_INVALIDARG; newEnumMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(EnumMonikerImpl)); if (newEnumMoniker == 0) return STG_E_INSUFFICIENTMEMORY; /* Initialize the virtual function table. */ newEnumMoniker->IEnumMoniker_iface.lpVtbl = &VT_EnumMonikerImpl; newEnumMoniker->ref = 1; newEnumMoniker->tabSize=tabSize; newEnumMoniker->currentPos=currentPos; newEnumMoniker->tabMoniker=HeapAlloc(GetProcessHeap(),0,tabSize*sizeof(newEnumMoniker->tabMoniker[0])); if (newEnumMoniker->tabMoniker==NULL) { HeapFree(GetProcessHeap(), 0, newEnumMoniker); return E_OUTOFMEMORY; } if (leftToRight) for (i=0;i<tabSize;i++){ newEnumMoniker->tabMoniker[i]=tabMoniker[i]; IMoniker_AddRef(tabMoniker[i]); } else for (i = tabSize; i > 0; i--){ newEnumMoniker->tabMoniker[tabSize-i]=tabMoniker[i - 1]; IMoniker_AddRef(tabMoniker[i - 1]); } *ppmk=&newEnumMoniker->IEnumMoniker_iface; return S_OK; } /********************************************************************************/ /* Virtual function table for the CompositeMonikerImpl class which includes */ /* IPersist, IPersistStream and IMoniker functions. */ static const IMonikerVtbl VT_CompositeMonikerImpl = { CompositeMonikerImpl_QueryInterface, CompositeMonikerImpl_AddRef, CompositeMonikerImpl_Release, CompositeMonikerImpl_GetClassID, CompositeMonikerImpl_IsDirty, CompositeMonikerImpl_Load, CompositeMonikerImpl_Save, CompositeMonikerImpl_GetSizeMax, CompositeMonikerImpl_BindToObject, CompositeMonikerImpl_BindToStorage, CompositeMonikerImpl_Reduce, CompositeMonikerImpl_ComposeWith, CompositeMonikerImpl_Enum, CompositeMonikerImpl_IsEqual, CompositeMonikerImpl_Hash, CompositeMonikerImpl_IsRunning, CompositeMonikerImpl_GetTimeOfLastChange, CompositeMonikerImpl_Inverse, CompositeMonikerImpl_CommonPrefixWith, CompositeMonikerImpl_RelativePathTo, CompositeMonikerImpl_GetDisplayName, CompositeMonikerImpl_ParseDisplayName, CompositeMonikerImpl_IsSystemMoniker }; /********************************************************************************/ /* Virtual function table for the IROTData class. */ static const IROTDataVtbl VT_ROTDataImpl = { CompositeMonikerROTDataImpl_QueryInterface, CompositeMonikerROTDataImpl_AddRef, CompositeMonikerROTDataImpl_Release, CompositeMonikerROTDataImpl_GetComparisonData }; static const IMarshalVtbl VT_MarshalImpl = { CompositeMonikerMarshalImpl_QueryInterface, CompositeMonikerMarshalImpl_AddRef, CompositeMonikerMarshalImpl_Release, CompositeMonikerMarshalImpl_GetUnmarshalClass, CompositeMonikerMarshalImpl_GetMarshalSizeMax, CompositeMonikerMarshalImpl_MarshalInterface, CompositeMonikerMarshalImpl_UnmarshalInterface, CompositeMonikerMarshalImpl_ReleaseMarshalData, CompositeMonikerMarshalImpl_DisconnectObject }; /****************************************************************************** * Composite-Moniker_Construct (local function) *******************************************************************************/ static HRESULT CompositeMonikerImpl_Construct(IMoniker **ppMoniker, IMoniker *pmkFirst, IMoniker *pmkRest) { DWORD mkSys; IEnumMoniker *enumMoniker; IMoniker *tempMk; HRESULT res; CompositeMonikerImpl *This; int i; This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This)); if (!This) return E_OUTOFMEMORY; TRACE("(%p,%p,%p)\n",This,pmkFirst,pmkRest); /* Initialize the virtual function table. */ This->IMoniker_iface.lpVtbl = &VT_CompositeMonikerImpl; This->IROTData_iface.lpVtbl = &VT_ROTDataImpl; This->IMarshal_iface.lpVtbl = &VT_MarshalImpl; This->ref = 1; This->tabSize=BLOCK_TAB_SIZE; This->tabLastIndex=0; This->tabMoniker=HeapAlloc(GetProcessHeap(),0,This->tabSize*sizeof(This->tabMoniker[0])); if (This->tabMoniker==NULL) { HeapFree(GetProcessHeap(), 0, This); return E_OUTOFMEMORY; } if (!pmkFirst && !pmkRest) { *ppMoniker = &This->IMoniker_iface; return S_OK; } IMoniker_IsSystemMoniker(pmkFirst,&mkSys); /* put the first moniker contents in the beginning of the table */ if (mkSys!=MKSYS_GENERICCOMPOSITE){ This->tabMoniker[(This->tabLastIndex)++]=pmkFirst; IMoniker_AddRef(pmkFirst); } else{ IMoniker_Enum(pmkFirst,TRUE,&enumMoniker); while(IEnumMoniker_Next(enumMoniker,1,&This->tabMoniker[This->tabLastIndex],NULL)==S_OK){ if (++This->tabLastIndex==This->tabSize){ IMoniker **tab_moniker = This->tabMoniker; This->tabSize+=BLOCK_TAB_SIZE; This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(This->tabMoniker[0])); if (This->tabMoniker==NULL){ for (i = 0; i < This->tabLastIndex; i++) IMoniker_Release(tab_moniker[i]); HeapFree(GetProcessHeap(), 0, tab_moniker); HeapFree(GetProcessHeap(), 0, This); return E_OUTOFMEMORY; } } } IEnumMoniker_Release(enumMoniker); } /* put the rest moniker contents after the first one and make simplification if needed */ IMoniker_IsSystemMoniker(pmkRest,&mkSys); if (mkSys!=MKSYS_GENERICCOMPOSITE){ /* add a simple moniker to the moniker table */ res=IMoniker_ComposeWith(This->tabMoniker[This->tabLastIndex-1],pmkRest,TRUE,&tempMk); if (res==MK_E_NEEDGENERIC){ /* there's no simplification in this case */ This->tabMoniker[This->tabLastIndex]=pmkRest; This->tabLastIndex++; IMoniker_AddRef(pmkRest); } else if (tempMk==NULL){ /* we have an antimoniker after a simple moniker so we can make a simplification in this case */ IMoniker_Release(This->tabMoniker[This->tabLastIndex-1]); This->tabLastIndex--; } else if (SUCCEEDED(res)){ /* the non-generic composition was successful so we can make a simplification in this case */ IMoniker_Release(This->tabMoniker[This->tabLastIndex-1]); This->tabMoniker[This->tabLastIndex-1]=tempMk; } else{ for (i = 0; i < This->tabLastIndex; i++) IMoniker_Release(This->tabMoniker[i]); HeapFree(GetProcessHeap(), 0, This->tabMoniker); HeapFree(GetProcessHeap(), 0, This); return res; } /* resize tabMoniker if needed */ if (This->tabLastIndex==This->tabSize){ IMoniker **tab_moniker = This->tabMoniker; This->tabSize+=BLOCK_TAB_SIZE; This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(IMoniker)); if (This->tabMoniker==NULL){ for (i = 0; i < This->tabLastIndex; i++) IMoniker_Release(tab_moniker[i]); HeapFree(GetProcessHeap(), 0, tab_moniker); HeapFree(GetProcessHeap(), 0, This); return E_OUTOFMEMORY; } } } else{ /* add a composite moniker to the moniker table (do the same thing * for each moniker within the composite moniker as a simple moniker * (see above for how to add a simple moniker case) ) */ IMoniker_Enum(pmkRest,TRUE,&enumMoniker); while(IEnumMoniker_Next(enumMoniker,1,&This->tabMoniker[This->tabLastIndex],NULL)==S_OK){ res=IMoniker_ComposeWith(This->tabMoniker[This->tabLastIndex-1],This->tabMoniker[This->tabLastIndex],TRUE,&tempMk); if (res==MK_E_NEEDGENERIC){ This->tabLastIndex++; } else if (tempMk==NULL){ IMoniker_Release(This->tabMoniker[This->tabLastIndex-1]); IMoniker_Release(This->tabMoniker[This->tabLastIndex]); This->tabLastIndex--; } else{ IMoniker_Release(This->tabMoniker[This->tabLastIndex-1]); This->tabMoniker[This->tabLastIndex-1]=tempMk; } if (This->tabLastIndex==This->tabSize){ IMoniker **tab_moniker = This->tabMoniker; This->tabSize+=BLOCK_TAB_SIZE; This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(This->tabMoniker[0])); if (This->tabMoniker==NULL){ for (i = 0; i < This->tabLastIndex; i++) IMoniker_Release(tab_moniker[i]); HeapFree(GetProcessHeap(), 0, tab_moniker); HeapFree(GetProcessHeap(), 0, This); return E_OUTOFMEMORY; } } } IEnumMoniker_Release(enumMoniker); } /* only one moniker, then just return it */ if (This->tabLastIndex == 1) { *ppMoniker = This->tabMoniker[0]; IMoniker_AddRef(*ppMoniker); IMoniker_Release(&This->IMoniker_iface); } else *ppMoniker = &This->IMoniker_iface; return S_OK; } /****************************************************************************** * CreateGenericComposite [OLE32.@] ******************************************************************************/ HRESULT WINAPI CreateGenericComposite(IMoniker *pmkFirst, IMoniker *pmkRest, IMoniker **ppmkComposite) { IMoniker* moniker = 0; HRESULT hr = S_OK; TRACE("(%p,%p,%p)\n",pmkFirst,pmkRest,ppmkComposite); if (ppmkComposite==NULL) return E_POINTER; *ppmkComposite=0; if (pmkFirst==NULL && pmkRest!=NULL){ *ppmkComposite=pmkRest; IMoniker_AddRef(pmkRest); return S_OK; } else if (pmkFirst!=NULL && pmkRest==NULL){ *ppmkComposite=pmkFirst; IMoniker_AddRef(pmkFirst); return S_OK; } else if (pmkFirst==NULL && pmkRest==NULL) return S_OK; hr = CompositeMonikerImpl_Construct(&moniker,pmkFirst,pmkRest); if (FAILED(hr)) return hr; hr = IMoniker_QueryInterface(moniker,&IID_IMoniker,(void**)ppmkComposite); IMoniker_Release(moniker); return hr; } /****************************************************************************** * MonikerCommonPrefixWith [OLE32.@] ******************************************************************************/ HRESULT WINAPI MonikerCommonPrefixWith(IMoniker* pmkThis,IMoniker* pmkOther,IMoniker** ppmkCommon) { FIXME("(),stub!\n"); return E_NOTIMPL; } static HRESULT WINAPI CompositeMonikerCF_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv) { *ppv = NULL; if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory)) { *ppv = iface; IClassFactory_AddRef(iface); return S_OK; } return E_NOINTERFACE; } static ULONG WINAPI CompositeMonikerCF_AddRef(LPCLASSFACTORY iface) { return 2; /* non-heap based object */ } static ULONG WINAPI CompositeMonikerCF_Release(LPCLASSFACTORY iface) { return 1; /* non-heap based object */ } static HRESULT WINAPI CompositeMonikerCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv) { IMoniker* pMoniker; HRESULT hr; TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv); *ppv = NULL; if (pUnk) return CLASS_E_NOAGGREGATION; hr = CompositeMonikerImpl_Construct(&pMoniker, NULL, NULL); if (SUCCEEDED(hr)) { hr = IMoniker_QueryInterface(pMoniker, riid, ppv); IMoniker_Release(pMoniker); } return hr; } static HRESULT WINAPI CompositeMonikerCF_LockServer(LPCLASSFACTORY iface, BOOL fLock) { FIXME("(%d), stub!\n",fLock); return S_OK; } static const IClassFactoryVtbl CompositeMonikerCFVtbl = { CompositeMonikerCF_QueryInterface, CompositeMonikerCF_AddRef, CompositeMonikerCF_Release, CompositeMonikerCF_CreateInstance, CompositeMonikerCF_LockServer }; static const IClassFactoryVtbl *CompositeMonikerCF = &CompositeMonikerCFVtbl; HRESULT CompositeMonikerCF_Create(REFIID riid, LPVOID *ppv) { return IClassFactory_QueryInterface((IClassFactory *)&CompositeMonikerCF, riid, ppv); }