compositemoniker.c File Reference

#include <assert.h>
#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "winerror.h"
#include "wine/debug.h"
#include "ole2.h"
#include "moniker.h"

Include dependency graph for compositemoniker.c:

Go to the source code of this file.

Classes
struct	CompositeMonikerImpl
struct	EnumMonikerImpl

Macros
#define	COBJMACROS
#define	BLOCK_TAB_SIZE   5 /* represent the first size table and its increment block size */

Typedefs
typedef struct CompositeMonikerImpl	CompositeMonikerImpl
typedef struct EnumMonikerImpl	EnumMonikerImpl

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
static CompositeMonikerImpl *	impl_from_IMoniker (IMoniker *iface)
static CompositeMonikerImpl *	impl_from_IROTData (IROTData *iface)
static CompositeMonikerImpl *	impl_from_IMarshal (IMarshal *iface)
static EnumMonikerImpl *	impl_from_IEnumMoniker (IEnumMoniker *iface)
static HRESULT	EnumMonikerImpl_CreateEnumMoniker (IMoniker **tabMoniker, ULONG tabSize, ULONG currentPos, BOOL leftToRight, IEnumMoniker **ppmk)
static HRESULT WINAPI	CompositeMonikerImpl_QueryInterface (IMoniker *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	CompositeMonikerImpl_AddRef (IMoniker *iface)
static void	CompositeMonikerImpl_ReleaseMonikersInTable (CompositeMonikerImpl *This)
static ULONG WINAPI	CompositeMonikerImpl_Release (IMoniker *iface)
static HRESULT WINAPI	CompositeMonikerImpl_GetClassID (IMoniker *iface, CLSID *pClassID)
static HRESULT WINAPI	CompositeMonikerImpl_IsDirty (IMoniker *iface)
static HRESULT WINAPI	CompositeMonikerImpl_Load (IMoniker *iface, IStream *pStm)
static HRESULT WINAPI	CompositeMonikerImpl_Save (IMoniker *iface, IStream *pStm, BOOL fClearDirty)
static HRESULT WINAPI	CompositeMonikerImpl_GetSizeMax (IMoniker *iface, ULARGE_INTEGER *pcbSize)
static HRESULT WINAPI	CompositeMonikerImpl_BindToObject (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, VOID **ppvResult)
static HRESULT WINAPI	CompositeMonikerImpl_BindToStorage (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, VOID **ppvResult)
static HRESULT WINAPI	CompositeMonikerImpl_Reduce (IMoniker *iface, IBindCtx *pbc, DWORD dwReduceHowFar, IMoniker **ppmkToLeft, IMoniker **ppmkReduced)
static HRESULT WINAPI	CompositeMonikerImpl_ComposeWith (IMoniker *iface, IMoniker *pmkRight, BOOL fOnlyIfNotGeneric, IMoniker **ppmkComposite)
static HRESULT WINAPI	CompositeMonikerImpl_Enum (IMoniker *iface, BOOL fForward, IEnumMoniker **ppenumMoniker)
static HRESULT WINAPI	CompositeMonikerImpl_IsEqual (IMoniker *iface, IMoniker *pmkOtherMoniker)
static HRESULT WINAPI	CompositeMonikerImpl_Hash (IMoniker *iface, DWORD *pdwHash)
static HRESULT WINAPI	CompositeMonikerImpl_IsRunning (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, IMoniker *pmkNewlyRunning)
static HRESULT WINAPI	CompositeMonikerImpl_GetTimeOfLastChange (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, FILETIME *pCompositeTime)
static HRESULT WINAPI	CompositeMonikerImpl_Inverse (IMoniker *iface, IMoniker **ppmk)
static HRESULT WINAPI	CompositeMonikerImpl_CommonPrefixWith (IMoniker *iface, IMoniker *pmkOther, IMoniker **ppmkPrefix)
static VOID	GetAfterCommonPrefix (IMoniker *pGenMk, IMoniker *commonMk, IMoniker **restMk)
static HRESULT WINAPI	CompositeMonikerImpl_RelativePathTo (IMoniker *iface, IMoniker *pmkOther, IMoniker **ppmkRelPath)
static HRESULT WINAPI	CompositeMonikerImpl_GetDisplayName (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR *ppszDisplayName)
static HRESULT WINAPI	CompositeMonikerImpl_ParseDisplayName (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR pszDisplayName, ULONG *pchEaten, IMoniker **ppmkOut)
static HRESULT WINAPI	CompositeMonikerImpl_IsSystemMoniker (IMoniker *iface, DWORD *pwdMksys)
static HRESULT WINAPI	CompositeMonikerROTDataImpl_QueryInterface (IROTData *iface, REFIID riid, VOID **ppvObject)
static ULONG WINAPI	CompositeMonikerROTDataImpl_AddRef (IROTData *iface)
static ULONG WINAPI	CompositeMonikerROTDataImpl_Release (IROTData *iface)
static HRESULT WINAPI	CompositeMonikerROTDataImpl_GetComparisonData (IROTData *iface, BYTE *pbData, ULONG cbMax, ULONG *pcbData)
static HRESULT WINAPI	CompositeMonikerMarshalImpl_QueryInterface (IMarshal *iface, REFIID riid, LPVOID *ppv)
static ULONG WINAPI	CompositeMonikerMarshalImpl_AddRef (IMarshal *iface)
static ULONG WINAPI	CompositeMonikerMarshalImpl_Release (IMarshal *iface)
static HRESULT WINAPI	CompositeMonikerMarshalImpl_GetUnmarshalClass (IMarshal *iface, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, CLSID *pCid)
static HRESULT WINAPI	CompositeMonikerMarshalImpl_GetMarshalSizeMax (IMarshal *iface, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, DWORD *pSize)
static HRESULT WINAPI	CompositeMonikerMarshalImpl_MarshalInterface (IMarshal *iface, IStream *pStm, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags)
static HRESULT WINAPI	CompositeMonikerMarshalImpl_UnmarshalInterface (IMarshal *iface, IStream *pStm, REFIID riid, void **ppv)
static HRESULT WINAPI	CompositeMonikerMarshalImpl_ReleaseMarshalData (IMarshal *iface, IStream *pStm)
static HRESULT WINAPI	CompositeMonikerMarshalImpl_DisconnectObject (IMarshal *iface, DWORD dwReserved)
static HRESULT WINAPI	EnumMonikerImpl_QueryInterface (IEnumMoniker *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	EnumMonikerImpl_AddRef (IEnumMoniker *iface)
static ULONG WINAPI	EnumMonikerImpl_Release (IEnumMoniker *iface)
static HRESULT WINAPI	EnumMonikerImpl_Next (IEnumMoniker *iface, ULONG celt, IMoniker **rgelt, ULONG *pceltFethed)
static HRESULT WINAPI	EnumMonikerImpl_Skip (IEnumMoniker *iface, ULONG celt)
static HRESULT WINAPI	EnumMonikerImpl_Reset (IEnumMoniker *iface)
static HRESULT WINAPI	EnumMonikerImpl_Clone (IEnumMoniker *iface, IEnumMoniker **ppenum)
static HRESULT	CompositeMonikerImpl_Construct (IMoniker **ppMoniker, IMoniker *pmkFirst, IMoniker *pmkRest)
HRESULT WINAPI	CreateGenericComposite (IMoniker *pmkFirst, IMoniker *pmkRest, IMoniker **ppmkComposite)
HRESULT WINAPI	MonikerCommonPrefixWith (IMoniker *pmkThis, IMoniker *pmkOther, IMoniker **ppmkCommon)
HRESULT WINAPI	CompositeMoniker_CreateInstance (IClassFactory *iface, IUnknown *pUnk, REFIID riid, void **ppv)

Variables
static const IEnumMonikerVtbl	VT_EnumMonikerImpl
static const IMonikerVtbl	VT_CompositeMonikerImpl
static const IROTDataVtbl	VT_ROTDataImpl
static const IMarshalVtbl	VT_MarshalImpl

Macro Definition Documentation

BLOCK_TAB_SIZE

#define BLOCK_TAB_SIZE   5 /* represent the first size table and its increment block size */

Definition at line 37 of file compositemoniker.c.

COBJMACROS

#define COBJMACROS

Definition at line 25 of file compositemoniker.c.

Typedef Documentation

CompositeMonikerImpl

typedef struct CompositeMonikerImpl CompositeMonikerImpl

EnumMonikerImpl

typedef struct EnumMonikerImpl EnumMonikerImpl

Function Documentation

CompositeMoniker_CreateInstance()

HRESULT WINAPI CompositeMoniker_CreateInstance	(	IClassFactory *	iface,
		IUnknown *	pUnk,
		REFIID	riid,
		void **	ppv
	)

Definition at line 1999 of file compositemoniker.c.

{
    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;
}

CompositeMonikerImpl_AddRef()

static ULONG WINAPI CompositeMonikerImpl_AddRef ( IMoniker *  iface )

static

Definition at line 124 of file compositemoniker.c.

{
    CompositeMonikerImpl *This = impl_from_IMoniker(iface);
 
    TRACE("(%p)\n",This);
 
    return InterlockedIncrement(&This->ref);
}

Referenced by CompositeMonikerMarshalImpl_AddRef().

CompositeMonikerImpl_BindToObject()

static HRESULT WINAPI CompositeMonikerImpl_BindToObject ( IMoniker *  iface, IBindCtx *  pbc, IMoniker *  pmkToLeft, REFIID  riid, VOID **  ppvResult  )

static

Definition at line 330 of file compositemoniker.c.

{
    HRESULT   res;
    IRunningObjectTable *prot;
    IMoniker *tempMk,*antiMk,*rightMostMk;
    IEnumMoniker *enumMoniker;
 
    TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(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;
}

CompositeMonikerImpl_BindToStorage()

static HRESULT WINAPI CompositeMonikerImpl_BindToStorage ( IMoniker *  iface, IBindCtx *  pbc, IMoniker *  pmkToLeft, REFIID  riid, VOID **  ppvResult  )

static

Definition at line 384 of file compositemoniker.c.

{
    HRESULT   res;
    IMoniker *tempMk,*antiMk,*rightMostMk,*leftMk;
    IEnumMoniker *enumMoniker;
 
    TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(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;
}

CompositeMonikerImpl_CommonPrefixWith()

static HRESULT WINAPI CompositeMonikerImpl_CommonPrefixWith ( IMoniker *  iface, IMoniker *  pmkOther, IMoniker **  ppmkPrefix  )

static

Definition at line 825 of file compositemoniker.c.

{
    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;
    }
}

CompositeMonikerImpl_ComposeWith()

static HRESULT WINAPI CompositeMonikerImpl_ComposeWith ( IMoniker *  iface, IMoniker *  pmkRight, BOOL  fOnlyIfNotGeneric, IMoniker **  ppmkComposite  )

static

Definition at line 504 of file compositemoniker.c.

{
    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);
}

CompositeMonikerImpl_Construct()

static HRESULT CompositeMonikerImpl_Construct ( IMoniker **  ppMoniker, IMoniker *  pmkFirst, IMoniker *  pmkRest  )

static

Definition at line 1758 of file compositemoniker.c.

{
    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;
}

Referenced by CompositeMoniker_CreateInstance(), and CreateGenericComposite().

CompositeMonikerImpl_Enum()

static HRESULT WINAPI CompositeMonikerImpl_Enum ( IMoniker *  iface, BOOL  fForward, IEnumMoniker **  ppenumMoniker  )

static

Definition at line 528 of file compositemoniker.c.

{
    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);
}

CompositeMonikerImpl_GetClassID()

static HRESULT WINAPI CompositeMonikerImpl_GetClassID ( IMoniker *  iface, CLSID *  pClassID  )

static

Definition at line 172 of file compositemoniker.c.

{
    TRACE("(%p,%p)\n",iface,pClassID);
 
    if (pClassID==NULL)
        return E_POINTER;
 
    *pClassID = CLSID_CompositeMoniker;
 
    return S_OK;
}

CompositeMonikerImpl_GetDisplayName()

static HRESULT WINAPI CompositeMonikerImpl_GetDisplayName ( IMoniker *  iface, IBindCtx *  pbc, IMoniker *  pmkToLeft, LPOLESTR *  ppszDisplayName  )

static

Definition at line 1107 of file compositemoniker.c.

{
    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;
 
        lstrcatW(*ppszDisplayName,tempStr);
 
        CoTaskMemFree(tempStr);
        IMoniker_Release(tempMk);
    }
 
    IEnumMoniker_Release(enumMoniker);
 
    return S_OK;
}

CompositeMonikerImpl_GetSizeMax()

static HRESULT WINAPI CompositeMonikerImpl_GetSizeMax ( IMoniker *  iface, ULARGE_INTEGER *  pcbSize  )

static

Definition at line 293 of file compositemoniker.c.

{
    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;
}

CompositeMonikerImpl_GetTimeOfLastChange()

static HRESULT WINAPI CompositeMonikerImpl_GetTimeOfLastChange ( IMoniker *  iface, IBindCtx *  pbc, IMoniker *  pmkToLeft, FILETIME *  pCompositeTime  )

static

Definition at line 709 of file compositemoniker.c.

{
    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;
}

CompositeMonikerImpl_Hash()

static HRESULT WINAPI CompositeMonikerImpl_Hash ( IMoniker *  iface, DWORD *  pdwHash  )

static

Definition at line 595 of file compositemoniker.c.

{
    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;
}

CompositeMonikerImpl_Inverse()

static HRESULT WINAPI CompositeMonikerImpl_Inverse ( IMoniker *  iface, IMoniker **  ppmk  )

static

Definition at line 772 of file compositemoniker.c.

{
    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;
    }
}

Referenced by CompositeMonikerImpl_Inverse().

CompositeMonikerImpl_IsDirty()

static HRESULT WINAPI CompositeMonikerImpl_IsDirty ( IMoniker *  iface )

static

Definition at line 188 of file compositemoniker.c.

{
    /* 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;
}

CompositeMonikerImpl_IsEqual()

static HRESULT WINAPI CompositeMonikerImpl_IsEqual ( IMoniker *  iface, IMoniker *  pmkOtherMoniker  )

static

Definition at line 544 of file compositemoniker.c.

{
    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;
}

CompositeMonikerImpl_IsRunning()

static HRESULT WINAPI CompositeMonikerImpl_IsRunning ( IMoniker *  iface, IBindCtx *  pbc, IMoniker *  pmkToLeft, IMoniker *  pmkNewlyRunning  )

static

Definition at line 631 of file compositemoniker.c.

{
    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;
            }
        }
}

CompositeMonikerImpl_IsSystemMoniker()

static HRESULT WINAPI CompositeMonikerImpl_IsSystemMoniker ( IMoniker *  iface, DWORD *  pwdMksys  )

static

Definition at line 1184 of file compositemoniker.c.

{
    TRACE("(%p,%p)\n",iface,pwdMksys);
 
    if (!pwdMksys)
        return E_POINTER;
 
    (*pwdMksys)=MKSYS_GENERICCOMPOSITE;
 
    return S_OK;
}

CompositeMonikerImpl_Load()

static HRESULT WINAPI CompositeMonikerImpl_Load ( IMoniker *  iface, IStream *  pStm  )

static

Definition at line 203 of file compositemoniker.c.

{
    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;
}

CompositeMonikerImpl_ParseDisplayName()

static HRESULT WINAPI CompositeMonikerImpl_ParseDisplayName ( IMoniker *  iface, IBindCtx *  pbc, IMoniker *  pmkToLeft, LPOLESTR  pszDisplayName, ULONG *  pchEaten, IMoniker **  ppmkOut  )

static

Definition at line 1158 of file compositemoniker.c.

{
    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);
}

CompositeMonikerImpl_QueryInterface()

static HRESULT WINAPI CompositeMonikerImpl_QueryInterface ( IMoniker *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 85 of file compositemoniker.c.

{
    CompositeMonikerImpl *This = impl_from_IMoniker(iface);
 
    TRACE("(%p,%s,%p)\n",This,debugstr_guid(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;
}

Referenced by CompositeMonikerMarshalImpl_QueryInterface(), and CompositeMonikerROTDataImpl_QueryInterface().

CompositeMonikerImpl_Reduce()

static HRESULT WINAPI CompositeMonikerImpl_Reduce ( IMoniker *  iface, IBindCtx *  pbc, DWORD  dwReduceHowFar, IMoniker **  ppmkToLeft, IMoniker **  ppmkReduced  )

static

Definition at line 432 of file compositemoniker.c.

{
    HRESULT   res;
    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);
 
        res = IMoniker_Reduce(rightMostMk,pbc,dwReduceHowFar,&tempMk, ppmkReduced);
        IMoniker_Release(tempMk);
        IMoniker_Release(rightMostMk);
 
        return res;
    }
    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) ){
            IMoniker_Release(tempMk);
            IMoniker_Release(rightMostMk);
 
            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_Release(tempMk);
            IMoniker_Release(rightMostMk);
 
            IMoniker_AddRef(iface);
 
            *ppmkReduced=iface;
 
            return MK_S_REDUCED_TO_SELF;
        }
    }
}

CompositeMonikerImpl_RelativePathTo()

static HRESULT WINAPI CompositeMonikerImpl_RelativePathTo ( IMoniker *  iface, IMoniker *  pmkOther, IMoniker **  ppmkRelPath  )

static

Definition at line 1045 of file compositemoniker.c.

{
    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;
}

CompositeMonikerImpl_Release()

static ULONG WINAPI CompositeMonikerImpl_Release ( IMoniker *  iface )

static

Definition at line 147 of file compositemoniker.c.

{
    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;
}

Referenced by CompositeMonikerMarshalImpl_Release().

CompositeMonikerImpl_ReleaseMonikersInTable()

static void CompositeMonikerImpl_ReleaseMonikersInTable ( CompositeMonikerImpl *  This )

static

Definition at line 133 of file compositemoniker.c.

{
    ULONG i;
 
    for (i = 0; i < This->tabLastIndex; i++)
        IMoniker_Release(This->tabMoniker[i]);
 
    This->tabLastIndex = 0;
}

Referenced by CompositeMonikerImpl_Load(), CompositeMonikerImpl_Release(), and CompositeMonikerMarshalImpl_UnmarshalInterface().

CompositeMonikerImpl_Save()

static HRESULT WINAPI CompositeMonikerImpl_Save ( IMoniker *  iface, IStream *  pStm, BOOL  fClearDirty  )

static

Definition at line 250 of file compositemoniker.c.

{
    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;
}

CompositeMonikerMarshalImpl_AddRef()

static ULONG WINAPI CompositeMonikerMarshalImpl_AddRef ( IMarshal *  iface )

static

Definition at line 1336 of file compositemoniker.c.

{
    CompositeMonikerImpl *This = impl_from_IMarshal(iface);
 
    TRACE("(%p)\n",iface);
 
    return CompositeMonikerImpl_AddRef(&This->IMoniker_iface);
}

CompositeMonikerMarshalImpl_DisconnectObject()

static HRESULT WINAPI CompositeMonikerMarshalImpl_DisconnectObject ( IMarshal *  iface, DWORD  dwReserved  )

static

Definition at line 1492 of file compositemoniker.c.

{
    TRACE("(0x%x)\n", dwReserved);
    /* can't disconnect a state-based marshal as nothing on server side to
     * disconnect from */
    return S_OK;
}

CompositeMonikerMarshalImpl_GetMarshalSizeMax()

static HRESULT WINAPI CompositeMonikerMarshalImpl_GetMarshalSizeMax ( IMarshal *  iface, REFIID  riid, void *  pv, DWORD  dwDestContext, void *  pvDestContext, DWORD  mshlflags, DWORD *  pSize  )

static

Definition at line 1366 of file compositemoniker.c.

{
    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;
}

CompositeMonikerMarshalImpl_GetUnmarshalClass()

static HRESULT WINAPI CompositeMonikerMarshalImpl_GetUnmarshalClass ( IMarshal *  iface, REFIID  riid, void *  pv, DWORD  dwDestContext, void *  pvDestContext, DWORD  mshlflags, CLSID *  pCid  )

static

Definition at line 1354 of file compositemoniker.c.

{
    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);
}

CompositeMonikerMarshalImpl_MarshalInterface()

static HRESULT WINAPI CompositeMonikerMarshalImpl_MarshalInterface ( IMarshal *  iface, IStream *  pStm, REFIID  riid, void *  pv, DWORD  dwDestContext, void *  pvDestContext, DWORD  mshlflags  )

static

Definition at line 1408 of file compositemoniker.c.

{
    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;
}

CompositeMonikerMarshalImpl_QueryInterface()

static HRESULT WINAPI CompositeMonikerMarshalImpl_QueryInterface ( IMarshal *  iface, REFIID  riid, LPVOID *  ppv  )

static

Definition at line 1327 of file compositemoniker.c.

{
    CompositeMonikerImpl *This = impl_from_IMarshal(iface);
 
    TRACE("(%p,%s,%p)\n",iface,debugstr_guid(riid),ppv);
 
    return CompositeMonikerImpl_QueryInterface(&This->IMoniker_iface, riid, ppv);
}

CompositeMonikerMarshalImpl_Release()

static ULONG WINAPI CompositeMonikerMarshalImpl_Release ( IMarshal *  iface )

static

Definition at line 1345 of file compositemoniker.c.

{
    CompositeMonikerImpl *This = impl_from_IMarshal(iface);
 
    TRACE("(%p)\n",iface);
 
    return CompositeMonikerImpl_Release(&This->IMoniker_iface);
}

CompositeMonikerMarshalImpl_ReleaseMarshalData()

static HRESULT WINAPI CompositeMonikerMarshalImpl_ReleaseMarshalData ( IMarshal *  iface, IStream *  pStm  )

static

Definition at line 1484 of file compositemoniker.c.

{
    TRACE("(%p)\n", pStm);
    /* can't release a state-based marshal as nothing on server side to
     * release */
    return S_OK;
}

CompositeMonikerMarshalImpl_UnmarshalInterface()

static HRESULT WINAPI CompositeMonikerMarshalImpl_UnmarshalInterface ( IMarshal *  iface, IStream *  pStm, REFIID  riid, void **  ppv  )

static

Definition at line 1446 of file compositemoniker.c.

{
    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);
}

CompositeMonikerROTDataImpl_AddRef()

static ULONG WINAPI CompositeMonikerROTDataImpl_AddRef ( IROTData *  iface )

static

Definition at line 1214 of file compositemoniker.c.

{
    CompositeMonikerImpl *This = impl_from_IROTData(iface);
 
    TRACE("(%p)\n",iface);
 
    return IMoniker_AddRef(&This->IMoniker_iface);
}

CompositeMonikerROTDataImpl_GetComparisonData()

static HRESULT WINAPI CompositeMonikerROTDataImpl_GetComparisonData ( IROTData *  iface, BYTE *  pbData, ULONG  cbMax, ULONG *  pcbData  )

static

Definition at line 1239 of file compositemoniker.c.

{
    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;
}

CompositeMonikerROTDataImpl_QueryInterface()

static HRESULT WINAPI CompositeMonikerROTDataImpl_QueryInterface ( IROTData *  iface, REFIID  riid, VOID **  ppvObject  )

static

Definition at line 1200 of file compositemoniker.c.

{
    CompositeMonikerImpl *This = impl_from_IROTData(iface);
 
    TRACE("(%p,%s,%p)\n",iface,debugstr_guid(riid),ppvObject);
 
    return CompositeMonikerImpl_QueryInterface(&This->IMoniker_iface, riid, ppvObject);
}

CompositeMonikerROTDataImpl_Release()

static ULONG WINAPI CompositeMonikerROTDataImpl_Release ( IROTData *  iface )

static

Definition at line 1226 of file compositemoniker.c.

{
    CompositeMonikerImpl *This = impl_from_IROTData(iface);
 
    TRACE("(%p)\n",iface);
 
    return IMoniker_Release(&This->IMoniker_iface);
}

CreateGenericComposite()

HRESULT WINAPI CreateGenericComposite	(	IMoniker *	pmkFirst,
		IMoniker *	pmkRest,
		IMoniker **	ppmkComposite
	)

Definition at line 1952 of file compositemoniker.c.

{
    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;
}

Referenced by AntiMonikerImpl_ComposeWith(), ClassMoniker_ComposeWith(), CompositeMonikerImpl_CommonPrefixWith(), CompositeMonikerImpl_ComposeWith(), CompositeMonikerImpl_Inverse(), CompositeMonikerImpl_IsRunning(), CompositeMonikerImpl_Reduce(), CompositeMonikerImpl_RelativePathTo(), FileMonikerImpl_ComposeWith(), GetAfterCommonPrefix(), IHlinkBC_GetObject(), IHlinkBC_Register(), ItemMonikerImpl_ComposeWith(), ItemMonikerImpl_GetTimeOfLastChange(), PointerMonikerImpl_ComposeWith(), and test_generic_composite_moniker().

EnumMonikerImpl_AddRef()

static ULONG WINAPI EnumMonikerImpl_AddRef ( IEnumMoniker *  iface )

static

Definition at line 1536 of file compositemoniker.c.

{
    EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
 
    TRACE("(%p)\n",This);
 
    return InterlockedIncrement(&This->ref);
 
}

EnumMonikerImpl_Clone()

static HRESULT WINAPI EnumMonikerImpl_Clone ( IEnumMoniker *  iface, IEnumMoniker **  ppenum  )

static

Definition at line 1630 of file compositemoniker.c.

{
    EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
 
    return EnumMonikerImpl_CreateEnumMoniker(This->tabMoniker,This->tabSize,This->currentPos,TRUE,ppenum);
}

EnumMonikerImpl_CreateEnumMoniker()

static HRESULT EnumMonikerImpl_CreateEnumMoniker ( IMoniker **  tabMoniker, ULONG  tabSize, ULONG  currentPos, BOOL  leftToRight, IEnumMoniker **  ppmk  )

static

Definition at line 1654 of file compositemoniker.c.

{
    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;
}

Referenced by CompositeMonikerImpl_Enum(), and EnumMonikerImpl_Clone().

EnumMonikerImpl_Next()

static HRESULT WINAPI EnumMonikerImpl_Next ( IEnumMoniker *  iface, ULONG  celt, IMoniker **  rgelt, ULONG *  pceltFethed  )

static

Definition at line 1575 of file compositemoniker.c.

{
    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_QueryInterface()

static HRESULT WINAPI EnumMonikerImpl_QueryInterface ( IEnumMoniker *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 1505 of file compositemoniker.c.

{
    EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
 
    TRACE("(%p,%s,%p)\n",This,debugstr_guid(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_Release()

static ULONG WINAPI EnumMonikerImpl_Release ( IEnumMoniker *  iface )

static

Definition at line 1550 of file compositemoniker.c.

{
    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_Reset()

static HRESULT WINAPI EnumMonikerImpl_Reset ( IEnumMoniker *  iface )

static

Definition at line 1617 of file compositemoniker.c.

{
    EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
 
    This->currentPos=0;
 
    return S_OK;
}

EnumMonikerImpl_Skip()

static HRESULT WINAPI EnumMonikerImpl_Skip ( IEnumMoniker *  iface, ULONG  celt  )

static

Definition at line 1601 of file compositemoniker.c.

{
    EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
 
    if ((This->currentPos+celt) >= This->tabSize)
        return S_FALSE;
 
    This->currentPos+=celt;
 
    return S_OK;
}

GetAfterCommonPrefix()

static VOID GetAfterCommonPrefix ( IMoniker *  pGenMk, IMoniker *  commonMk, IMoniker **  restMk  )

static

Definition at line 955 of file compositemoniker.c.

{
    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;
        }
    }
}

Referenced by CompositeMonikerImpl_RelativePathTo().

impl_from_IEnumMoniker()

static EnumMonikerImpl * impl_from_IEnumMoniker ( IEnumMoniker *  iface )

inlinestatic

Definition at line 74 of file compositemoniker.c.

{
    return CONTAINING_RECORD(iface, EnumMonikerImpl, IEnumMoniker_iface);
}

Referenced by EnumMonikerImpl_AddRef(), EnumMonikerImpl_Clone(), EnumMonikerImpl_Next(), EnumMonikerImpl_QueryInterface(), EnumMonikerImpl_Release(), EnumMonikerImpl_Reset(), and EnumMonikerImpl_Skip().

impl_from_IMarshal()

static CompositeMonikerImpl * impl_from_IMarshal ( IMarshal *  iface )

inlinestatic

Definition at line 60 of file compositemoniker.c.

{
    return CONTAINING_RECORD(iface, CompositeMonikerImpl, IMarshal_iface);
}

Referenced by CompositeMonikerMarshalImpl_AddRef(), CompositeMonikerMarshalImpl_GetMarshalSizeMax(), CompositeMonikerMarshalImpl_GetUnmarshalClass(), CompositeMonikerMarshalImpl_MarshalInterface(), CompositeMonikerMarshalImpl_QueryInterface(), CompositeMonikerMarshalImpl_Release(), and CompositeMonikerMarshalImpl_UnmarshalInterface().

impl_from_IMoniker()

static CompositeMonikerImpl * impl_from_IMoniker ( IMoniker *  iface )

inlinestatic

Definition at line 50 of file compositemoniker.c.

{
    return CONTAINING_RECORD(iface, CompositeMonikerImpl, IMoniker_iface);
}

Referenced by CompositeMonikerImpl_AddRef(), CompositeMonikerImpl_Enum(), CompositeMonikerImpl_Load(), CompositeMonikerImpl_QueryInterface(), CompositeMonikerImpl_Release(), and CompositeMonikerImpl_Save().

impl_from_IROTData()

static CompositeMonikerImpl * impl_from_IROTData ( IROTData *  iface )

inlinestatic

Definition at line 55 of file compositemoniker.c.

{
    return CONTAINING_RECORD(iface, CompositeMonikerImpl, IROTData_iface);
}

Referenced by CompositeMonikerROTDataImpl_AddRef(), CompositeMonikerROTDataImpl_GetComparisonData(), CompositeMonikerROTDataImpl_QueryInterface(), and CompositeMonikerROTDataImpl_Release().

MonikerCommonPrefixWith()

HRESULT WINAPI MonikerCommonPrefixWith	(	IMoniker *	pmkThis,
		IMoniker *	pmkOther,
		IMoniker **	ppmkCommon
	)

Definition at line 1993 of file compositemoniker.c.

{
    FIXME("(),stub!\n");
    return E_NOTIMPL;
}

Referenced by AntiMonikerImpl_CommonPrefixWith(), ClassMoniker_CommonPrefixWith(), FileMonikerImpl_CommonPrefixWith(), and ItemMonikerImpl_CommonPrefixWith().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ole

)

Variable Documentation

VT_CompositeMonikerImpl

const IMonikerVtbl VT_CompositeMonikerImpl

static

Initial value:

=
{
    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
}

Definition at line 1704 of file compositemoniker.c.

Referenced by CompositeMonikerImpl_Construct().

VT_EnumMonikerImpl

const IEnumMonikerVtbl VT_EnumMonikerImpl

static

Initial value:

=
{
    EnumMonikerImpl_QueryInterface,
    EnumMonikerImpl_AddRef,
    EnumMonikerImpl_Release,
    EnumMonikerImpl_Next,
    EnumMonikerImpl_Skip,
    EnumMonikerImpl_Reset,
    EnumMonikerImpl_Clone
}

Definition at line 1639 of file compositemoniker.c.

Referenced by EnumMonikerImpl_CreateEnumMoniker().

VT_MarshalImpl

const IMarshalVtbl VT_MarshalImpl

static

Initial value:

=
{
    CompositeMonikerMarshalImpl_QueryInterface,
    CompositeMonikerMarshalImpl_AddRef,
    CompositeMonikerMarshalImpl_Release,
    CompositeMonikerMarshalImpl_GetUnmarshalClass,
    CompositeMonikerMarshalImpl_GetMarshalSizeMax,
    CompositeMonikerMarshalImpl_MarshalInterface,
    CompositeMonikerMarshalImpl_UnmarshalInterface,
    CompositeMonikerMarshalImpl_ReleaseMarshalData,
    CompositeMonikerMarshalImpl_DisconnectObject
}

Definition at line 1741 of file compositemoniker.c.

Referenced by CompositeMonikerImpl_Construct().

VT_ROTDataImpl

const IROTDataVtbl VT_ROTDataImpl

static

Initial value:

=
{
    CompositeMonikerROTDataImpl_QueryInterface,
    CompositeMonikerROTDataImpl_AddRef,
    CompositeMonikerROTDataImpl_Release,
    CompositeMonikerROTDataImpl_GetComparisonData
}

Definition at line 1733 of file compositemoniker.c.

Referenced by CompositeMonikerImpl_Construct().