filemoniker.c File Reference

#include <assert.h>
#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "winnls.h"
#include "wine/debug.h"
#include "objbase.h"
#include "moniker.h"
#include "compobj_private.h"

Include dependency graph for filemoniker.c:

Go to the source code of this file.

Classes
struct	FileMonikerImpl

Macros
#define	COBJMACROS

Typedefs
typedef struct FileMonikerImpl	FileMonikerImpl

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
static FileMonikerImpl *	impl_from_IMoniker (IMoniker *iface)
static FileMonikerImpl *	impl_from_IROTData (IROTData *iface)
static FileMonikerImpl *	unsafe_impl_from_IMoniker (IMoniker *iface)
static HRESULT	FileMonikerImpl_Construct (FileMonikerImpl *iface, LPCOLESTR lpszPathName)
static HRESULT WINAPI	FileMonikerImpl_QueryInterface (IMoniker *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	FileMonikerImpl_AddRef (IMoniker *iface)
static ULONG WINAPI	FileMonikerImpl_Release (IMoniker *iface)
static HRESULT WINAPI	FileMonikerImpl_GetClassID (IMoniker *iface, CLSID *pClassID)
static HRESULT WINAPI	FileMonikerImpl_IsDirty (IMoniker *iface)
static HRESULT WINAPI	FileMonikerImpl_Load (IMoniker *iface, IStream *pStm)
static HRESULT WINAPI	FileMonikerImpl_Save (IMoniker *iface, IStream *pStm, BOOL fClearDirty)
static HRESULT WINAPI	FileMonikerImpl_GetSizeMax (IMoniker *iface, ULARGE_INTEGER *pcbSize)
static HRESULT WINAPI	FileMonikerImpl_BindToObject (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, VOID **ppvResult)
static HRESULT WINAPI	FileMonikerImpl_BindToStorage (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, void **object)
static HRESULT WINAPI	FileMonikerImpl_Reduce (IMoniker *iface, IBindCtx *pbc, DWORD howfar, IMoniker **toleft, IMoniker **reduced)
static void	free_stringtable (LPOLESTR *stringTable)
static int	FileMonikerImpl_DecomposePath (LPCOLESTR str, LPOLESTR **stringTable)
static HRESULT WINAPI	FileMonikerImpl_ComposeWith (IMoniker *iface, IMoniker *pmkRight, BOOL fOnlyIfNotGeneric, IMoniker **ppmkComposite)
static HRESULT WINAPI	FileMonikerImpl_Enum (IMoniker *iface, BOOL fForward, IEnumMoniker **ppenumMoniker)
static HRESULT WINAPI	FileMonikerImpl_IsEqual (IMoniker *iface, IMoniker *other)
static HRESULT WINAPI	FileMonikerImpl_Hash (IMoniker *iface, DWORD *pdwHash)
static HRESULT WINAPI	FileMonikerImpl_IsRunning (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, IMoniker *pmkNewlyRunning)
static HRESULT WINAPI	FileMonikerImpl_GetTimeOfLastChange (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, FILETIME *pFileTime)
static HRESULT WINAPI	FileMonikerImpl_Inverse (IMoniker *iface, IMoniker **ppmk)
static HRESULT WINAPI	FileMonikerImpl_CommonPrefixWith (IMoniker *iface, IMoniker *pmkOther, IMoniker **ppmkPrefix)
static HRESULT WINAPI	FileMonikerImpl_RelativePathTo (IMoniker *iface, IMoniker *pmOther, IMoniker **ppmkRelPath)
static HRESULT WINAPI	FileMonikerImpl_GetDisplayName (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR *ppszDisplayName)
static HRESULT WINAPI	FileMonikerImpl_ParseDisplayName (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR pszDisplayName, ULONG *pchEaten, IMoniker **ppmkOut)
static HRESULT WINAPI	FileMonikerImpl_IsSystemMoniker (IMoniker *iface, DWORD *pwdMksys)
static HRESULT WINAPI	FileMonikerROTDataImpl_QueryInterface (IROTData *iface, REFIID riid, VOID **ppvObject)
static ULONG WINAPI	FileMonikerROTDataImpl_AddRef (IROTData *iface)
static ULONG WINAPI	FileMonikerROTDataImpl_Release (IROTData *iface)
static HRESULT WINAPI	FileMonikerROTDataImpl_GetComparisonData (IROTData *iface, BYTE *pbData, ULONG cbMax, ULONG *pcbData)
HRESULT WINAPI	CreateFileMoniker (LPCOLESTR lpszPathName, IMoniker **ppmk)
static WCHAR *	memrpbrkW (const WCHAR *ptr, size_t n, const WCHAR *accept)
HRESULT	FileMoniker_CreateFromDisplayName (LPBC pbc, LPCOLESTR szDisplayName, LPDWORD pchEaten, IMoniker **ppmk)
HRESULT WINAPI	FileMoniker_CreateInstance (IClassFactory *iface, IUnknown *pUnk, REFIID riid, void **ppv)

Variables
static const IMonikerVtbl	VT_FileMonikerImpl
static const IROTDataVtbl	VT_ROTDataImpl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 26 of file filemoniker.c.

Typedef Documentation

FileMonikerImpl

typedef struct FileMonikerImpl FileMonikerImpl

Function Documentation

CreateFileMoniker()

HRESULT WINAPI CreateFileMoniker	(	LPCOLESTR	lpszPathName,
		IMoniker **	ppmk
	)

Definition at line 1360 of file filemoniker.c.

{
    FileMonikerImpl *moniker;
    HRESULT  hr;
 
    TRACE("%s, %p.\n", debugstr_w(lpszPathName), ppmk);
 
    if (!ppmk)
        return E_POINTER;
 
    if(!lpszPathName)
        return MK_E_SYNTAX;
 
    *ppmk=NULL;
 
    if (!(moniker = calloc(1, sizeof(*moniker))))
        return E_OUTOFMEMORY;
 
    hr = FileMonikerImpl_Construct(moniker, lpszPathName);
 
    if (SUCCEEDED(hr))
        hr = IMoniker_QueryInterface(&moniker->IMoniker_iface, &IID_IMoniker, (void **)ppmk);
    else
        free(moniker);
 
    return hr;
}

Referenced by FileMoniker_CreateFromDisplayName(), FileMonikerImpl_CommonPrefixWith(), FileMonikerImpl_ComposeWith(), FileMonikerImpl_RelativePathTo(), HlinkParseDisplayName(), IHlink_fnSetStringReference(), OleCreateFromFileEx(), test_file_moniker(), test_file_monikers(), test_HlinkMoniker(), test_MkParseDisplayName(), test_MonikerCommonPrefixWith(), test_ROT(), test_ROT_multiple_entries(), and test_save_load_filemoniker().

FileMoniker_CreateFromDisplayName()

HRESULT FileMoniker_CreateFromDisplayName	(	LPBC	pbc,
		LPCOLESTR	szDisplayName,
		LPDWORD	pchEaten,
		IMoniker **	ppmk
	)

Definition at line 1396 of file filemoniker.c.

{
    LPCWSTR end;
 
    for (end = szDisplayName + lstrlenW(szDisplayName);
         end && (end != szDisplayName);
         end = memrpbrkW(szDisplayName, end - szDisplayName, L":\\/!"))
    {
        HRESULT hr;
        IRunningObjectTable *rot;
        IMoniker *file_moniker;
        LPWSTR file_display_name;
        LPWSTR full_path_name;
        DWORD full_path_name_len;
        int len = end - szDisplayName;
 
        file_display_name = malloc((len + 1) * sizeof(WCHAR));
        if (!file_display_name) return E_OUTOFMEMORY;
        memcpy(file_display_name, szDisplayName, len * sizeof(WCHAR));
        file_display_name[len] = '\0';
 
        hr = CreateFileMoniker(file_display_name, &file_moniker);
        if (FAILED(hr))
        {
            free(file_display_name);
            return hr;
        }
 
        hr = IBindCtx_GetRunningObjectTable(pbc, &rot);
        if (FAILED(hr))
        {
            free(file_display_name);
            IMoniker_Release(file_moniker);
            return hr;
        }
 
        hr = IRunningObjectTable_IsRunning(rot, file_moniker);
        IRunningObjectTable_Release(rot);
        if (FAILED(hr))
        {
            free(file_display_name);
            IMoniker_Release(file_moniker);
            return hr;
        }
        if (hr == S_OK)
        {
            TRACE("found running file moniker for %s\n", debugstr_w(file_display_name));
            *pchEaten = len;
            *ppmk = file_moniker;
            free(file_display_name);
            return S_OK;
        }
 
        full_path_name_len = GetFullPathNameW(file_display_name, 0, NULL, NULL);
        if (!full_path_name_len)
        {
            free(file_display_name);
            IMoniker_Release(file_moniker);
            return MK_E_SYNTAX;
        }
        full_path_name = malloc(full_path_name_len * sizeof(WCHAR));
        if (!full_path_name)
        {
            free(file_display_name);
            IMoniker_Release(file_moniker);
            return E_OUTOFMEMORY;
        }
        GetFullPathNameW(file_display_name, full_path_name_len, full_path_name, NULL);
 
        if (GetFileAttributesW(full_path_name) == INVALID_FILE_ATTRIBUTES)
            TRACE("couldn't open file %s\n", debugstr_w(full_path_name));
        else
        {
            TRACE("got file moniker for %s\n", debugstr_w(szDisplayName));
            *pchEaten = len;
            *ppmk = file_moniker;
            free(file_display_name);
            free(full_path_name);
            return S_OK;
        }
        free(file_display_name);
        free(full_path_name);
        IMoniker_Release(file_moniker);
    }
 
    return MK_E_CANTOPENFILE;
}

Referenced by MkParseDisplayName().

FileMoniker_CreateInstance()

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

Definition at line 1486 of file filemoniker.c.

{
    FileMonikerImpl* newFileMoniker;
    HRESULT  hr;
 
    TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
 
    *ppv = NULL;
 
    if (pUnk)
        return CLASS_E_NOAGGREGATION;
 
    newFileMoniker = calloc(1, sizeof(*newFileMoniker));
    if (!newFileMoniker)
        return E_OUTOFMEMORY;
 
    hr = FileMonikerImpl_Construct(newFileMoniker, L"");
 
    if (SUCCEEDED(hr))
        hr = IMoniker_QueryInterface(&newFileMoniker->IMoniker_iface, riid, ppv);
    if (FAILED(hr))
        free(newFileMoniker);
 
    return hr;
}

FileMonikerImpl_AddRef()

static ULONG WINAPI FileMonikerImpl_AddRef ( IMoniker *  iface )

static

Definition at line 116 of file filemoniker.c.

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

FileMonikerImpl_BindToObject()

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

static

Definition at line 463 of file filemoniker.c.

{
    FileMonikerImpl *This = impl_from_IMoniker(iface);
    HRESULT   res=E_FAIL;
    CLSID     clsID;
    IUnknown* pObj=0;
    IRunningObjectTable *prot=0;
    IPersistFile  *ppf=0;
    IClassFactory *pcf=0;
    IClassActivator *pca=0;
 
    *ppvResult=0;
 
    TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
 
    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,&pObj);
 
            if (res != S_OK){
                /* first activation of this class */
                res=GetClassFile(This->filePathName,&clsID);
                if (SUCCEEDED(res)){
 
                    res=CoCreateInstance(&clsID,NULL,CLSCTX_SERVER,&IID_IPersistFile,(void**)&ppf);
                    if (SUCCEEDED(res)){
 
                        res=IPersistFile_Load(ppf,This->filePathName,STGM_READ);
                        if (SUCCEEDED(res)){
 
                            pObj=(IUnknown*)ppf;
                            IUnknown_AddRef(pObj);
                        }
                    }
                }
            }
        }
    }
    else{
        res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IClassFactory,(void**)&pcf);
 
        if (res==E_NOINTERFACE){
 
            res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IClassActivator,(void**)&pca);
 
            if (res==E_NOINTERFACE)
                return MK_E_INTERMEDIATEINTERFACENOTSUPPORTED;
        }
        if (pcf!=NULL){
 
            IClassFactory_CreateInstance(pcf,NULL,&IID_IPersistFile,(void**)&ppf);
 
            res=IPersistFile_Load(ppf,This->filePathName,STGM_READ);
 
            if (SUCCEEDED(res)){
 
                pObj=(IUnknown*)ppf;
                IUnknown_AddRef(pObj);
            }
        }
        if (pca!=NULL){
 
            FIXME("()\n");
 
            /*res=GetClassFile(This->filePathName,&clsID);
 
            if (SUCCEEDED(res)){
 
                res=IClassActivator_GetClassObject(pca,&clsID,CLSCTX_ALL,0,&IID_IPersistFile,(void**)&ppf);
 
                if (SUCCEEDED(res)){
 
                    pObj=(IUnknown*)ppf;
                    IUnknown_AddRef(pObj);
                }
            }*/
        }
    }
 
    if (pObj!=NULL){
        /* get the requested interface from the loaded class */
        res= IUnknown_QueryInterface(pObj,riid,ppvResult);
 
        IBindCtx_RegisterObjectBound(pbc,*ppvResult);
 
        IUnknown_Release(pObj);
    }
 
    if (prot!=NULL)
        IRunningObjectTable_Release(prot);
 
    if (ppf!=NULL)
        IPersistFile_Release(ppf);
 
    if (pca!=NULL)
        IClassActivator_Release(pca);
 
    if (pcf!=NULL)
        IClassFactory_Release(pcf);
 
    return res;
}

FileMonikerImpl_BindToStorage()

static HRESULT WINAPI FileMonikerImpl_BindToStorage ( IMoniker *  iface, IBindCtx *  pbc, IMoniker *  pmkToLeft, REFIID  riid, void **  object  )

static

Definition at line 575 of file filemoniker.c.

{
    FileMonikerImpl *moniker = impl_from_IMoniker(iface);
    BIND_OPTS bind_opts;
    HRESULT hr;
 
    TRACE("(%p,%p,%p,%s,%p)\n", iface, pbc, pmkToLeft, debugstr_guid(riid), object);
 
    if (!pbc)
        return E_INVALIDARG;
 
    bind_opts.cbStruct = sizeof(bind_opts);
    hr = IBindCtx_GetBindOptions(pbc, &bind_opts);
    if (FAILED(hr))
        return hr;
 
    if (!pmkToLeft)
    {
        if (IsEqualIID(&IID_IStorage, riid))
        {
            return StgOpenStorage(moniker->filePathName, NULL, bind_opts.grfMode, NULL, 0, (IStorage **)object);
        }
        else if ((IsEqualIID(&IID_IStream, riid)) || (IsEqualIID(&IID_ILockBytes, riid)))
            return E_FAIL;
        else
            return E_NOINTERFACE;
    }
 
    FIXME("(%p,%p,%p,%s,%p)\n", iface, pbc, pmkToLeft, debugstr_guid(riid), object);
 
    return E_NOTIMPL;
}

FileMonikerImpl_CommonPrefixWith()

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

static

Definition at line 951 of file filemoniker.c.

{
 
    LPOLESTR pathThis = NULL, pathOther = NULL, *stringTable1 = NULL;
    LPOLESTR *stringTable2 = NULL, commonPath = NULL;
    IBindCtx *bindctx;
    DWORD mkSys;
    ULONG nb1,nb2,i,sameIdx;
    BOOL machineNameCase = FALSE;
    HRESULT ret;
 
    if (ppmkPrefix==NULL)
        return E_POINTER;
 
    if (pmkOther==NULL)
        return E_INVALIDARG;
 
    *ppmkPrefix=0;
 
    /* check if we have the same type of moniker */
    IMoniker_IsSystemMoniker(pmkOther,&mkSys);
    if (mkSys != MKSYS_FILEMONIKER)
        return MonikerCommonPrefixWith(iface, pmkOther, ppmkPrefix);
 
    ret = CreateBindCtx(0, &bindctx);
    if (FAILED(ret))
        return ret;
 
    /* create a string based on common part of the two paths */
    ret = IMoniker_GetDisplayName(iface, bindctx, NULL, &pathThis);
    if (FAILED(ret))
        goto failed;
 
    ret = IMoniker_GetDisplayName(pmkOther, bindctx, NULL, &pathOther);
    if (FAILED(ret))
        goto failed;
 
    nb1 = FileMonikerImpl_DecomposePath(pathThis, &stringTable1);
    if (FAILED(nb1)) {
        ret = nb1;
        goto failed;
    }
 
    nb2 = FileMonikerImpl_DecomposePath(pathOther, &stringTable2);
    if (FAILED(nb2)) {
        ret = nb2;
        goto failed;
    }
 
    if (nb1 == 0 || nb2 == 0) {
        ret = MK_E_NOPREFIX;
        goto failed;
    }
 
    commonPath = CoTaskMemAlloc(sizeof(WCHAR)*(min(lstrlenW(pathThis),lstrlenW(pathOther))+1));
    if (!commonPath) {
        ret = E_OUTOFMEMORY;
        goto failed;
    }
 
    *commonPath = 0;
    for(sameIdx=0; ( (stringTable1[sameIdx]!=NULL) &&
                     (stringTable2[sameIdx]!=NULL) &&
                     (lstrcmpiW(stringTable1[sameIdx],stringTable2[sameIdx])==0)); sameIdx++);
 
    if (sameIdx > 1 && *stringTable1[0]=='\\' && *stringTable2[1]=='\\'){
        machineNameCase = TRUE;
 
    for(i=2;i<sameIdx;i++)
        if( (*stringTable1[i]=='\\') && (i+1 < sameIdx) && (*stringTable1[i+1]=='\\') ){
            machineNameCase = FALSE;
            break;
        }
    }
 
    if (machineNameCase && *stringTable1[sameIdx-1]=='\\')
        sameIdx--;
 
    if (machineNameCase && (sameIdx<=3) && (nb1 > 3 || nb2 > 3) )
        ret = MK_E_NOPREFIX;
    else
    {
        for (i = 0; i < sameIdx; i++)
            lstrcatW(commonPath,stringTable1[i]);
        ret = CreateFileMoniker(commonPath, ppmkPrefix);
    }
 
failed:
    IBindCtx_Release(bindctx);
    CoTaskMemFree(pathThis);
    CoTaskMemFree(pathOther);
    CoTaskMemFree(commonPath);
    if (stringTable1) free_stringtable(stringTable1);
    if (stringTable2) free_stringtable(stringTable2);
 
    return ret;
}

FileMonikerImpl_ComposeWith()

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

static

Definition at line 715 of file filemoniker.c.

{
    HRESULT res;
    LPOLESTR str1=0,str2=0,*strDec1=0,*strDec2=0,newStr=0;
    IBindCtx *bind=0;
    int i=0,j=0,lastIdx1=0,lastIdx2=0;
    DWORD mkSys, order;
 
    TRACE("(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
 
    if (ppmkComposite==NULL)
        return E_POINTER;
 
    if (pmkRight==NULL)
    return E_INVALIDARG;
 
    *ppmkComposite=0;
 
    IMoniker_IsSystemMoniker(pmkRight,&mkSys);
 
    /* check if we have two FileMonikers to compose or not */
    if(mkSys==MKSYS_FILEMONIKER){
 
        CreateBindCtx(0,&bind);
 
        IMoniker_GetDisplayName(iface,bind,NULL,&str1);
        IMoniker_GetDisplayName(pmkRight,bind,NULL,&str2);
 
        /* decompose pathnames of the two monikers : (to prepare the path merge operation ) */
        lastIdx1=FileMonikerImpl_DecomposePath(str1,&strDec1)-1;
        lastIdx2=FileMonikerImpl_DecomposePath(str2,&strDec2)-1;
 
        if ((lastIdx1 == -1 && lastIdx2 > -1) || (lastIdx1 == 1 && !wcscmp(strDec1[0], L"..")))
            res = MK_E_SYNTAX;
        else{
            if (!wcscmp(strDec1[lastIdx1], L"\\"))
                lastIdx1--;
 
            /* for each "..\" in the left of str2 remove the right element from str1 */
            for (i = 0; lastIdx1 >= 0 && strDec2[i] && !wcscmp(strDec2[i], L".."); i += 2)
                lastIdx1-=2;
 
            /* the length of the composed path string is increased by the sum of the two paths' lengths */
            newStr = malloc(sizeof(WCHAR)*(lstrlenW(str1)+lstrlenW(str2)+1));
 
            if (newStr){
                /* new path is the concatenation of the rest of str1 and str2 */
                for(*newStr=0,j=0;j<=lastIdx1;j++)
                    lstrcatW(newStr,strDec1[j]);
 
                if ((!strDec2[i] && lastIdx1 > -1 && lastIdx2 > -1) || wcscmp(strDec2[i], L"\\"))
                    lstrcatW(newStr, L"\\");
 
                for(j=i;j<=lastIdx2;j++)
                    lstrcatW(newStr,strDec2[j]);
 
                /* create a new moniker with the new string */
                res=CreateFileMoniker(newStr,ppmkComposite);
 
                free(newStr);
            }
            else res = E_OUTOFMEMORY;
        }
 
        free_stringtable(strDec1);
        free_stringtable(strDec2);
 
        CoTaskMemFree(str1);
        CoTaskMemFree(str2);
 
        return res;
    }
    else if (is_anti_moniker(pmkRight, &order))
    {
        return order > 1 ? create_anti_moniker(order - 1, ppmkComposite) : S_OK;
    }
    else if (fOnlyIfNotGeneric){
 
        *ppmkComposite=NULL;
        return MK_E_NEEDGENERIC;
    }
    else
 
        return CreateGenericComposite(iface,pmkRight,ppmkComposite);
}

FileMonikerImpl_Construct()

static HRESULT FileMonikerImpl_Construct ( FileMonikerImpl *  iface, LPCOLESTR  lpszPathName  )

static

Definition at line 1290 of file filemoniker.c.

{
    int nb=0,i;
    int sizeStr=lstrlenW(lpszPathName);
    LPOLESTR *tabStr=0;
    BOOL addBkSlash;
 
    TRACE("(%p,%s)\n",This,debugstr_w(lpszPathName));
 
    /* Initialize the virtual function table. */
    This->IMoniker_iface.lpVtbl = &VT_FileMonikerImpl;
    This->IROTData_iface.lpVtbl = &VT_ROTDataImpl;
    This->ref          = 0;
    This->pMarshal     = NULL;
 
    This->filePathName = malloc(sizeof(WCHAR)*(sizeStr+1));
 
    if (This->filePathName==NULL)
        return E_OUTOFMEMORY;
 
    lstrcpyW(This->filePathName,lpszPathName);
 
    nb=FileMonikerImpl_DecomposePath(This->filePathName,&tabStr);
 
    if (nb > 0 ){
 
        addBkSlash = TRUE;
        if (wcscmp(tabStr[0], L".."))
            addBkSlash = FALSE;
        else
            for(i=0;i<nb;i++){
 
                if (wcscmp(tabStr[i], L"..") && wcscmp(tabStr[i], L"\\"))
                {
                    addBkSlash = FALSE;
                    break;
                }
                else
 
                    if (!wcscmp(tabStr[i], L"\\") && i < nb - 1 && !wcscmp(tabStr[i+1], L"\\"))
                    {
                        *tabStr[i]=0;
                        sizeStr--;
                        addBkSlash = FALSE;
                        break;
                    }
            }
 
        if (!wcscmp(tabStr[nb-1], L"\\"))
            addBkSlash = FALSE;
 
        This->filePathName = realloc(This->filePathName, (sizeStr+1)*sizeof(WCHAR));
 
        *This->filePathName=0;
 
        for(i=0;tabStr[i]!=NULL;i++)
            lstrcatW(This->filePathName,tabStr[i]);
 
        if (addBkSlash)
            lstrcatW(This->filePathName, L"\\");
    }
 
    free_stringtable(tabStr);
 
    return S_OK;
}

Referenced by CreateFileMoniker(), and FileMoniker_CreateInstance().

FileMonikerImpl_DecomposePath()

static int FileMonikerImpl_DecomposePath ( LPCOLESTR  str, LPOLESTR **  stringTable  )

static

Definition at line 632 of file filemoniker.c.

{
    LPOLESTR word;
    int i=0,j,tabIndex=0, ret=0;
    LPOLESTR *strgtable ;
 
    int len=lstrlenW(str);
 
    TRACE("%s, %p\n", debugstr_w(str), *stringTable);
 
    strgtable = CoTaskMemAlloc((len + 1)*sizeof(*strgtable));
 
    if (strgtable==NULL)
        return E_OUTOFMEMORY;
 
    word = CoTaskMemAlloc((len + 1)*sizeof(WCHAR));
 
    if (word==NULL)
    {
        ret = E_OUTOFMEMORY;
        goto lend;
    }
 
    while(str[i]!=0){
 
        if (str[i] == L'\\')
        {
 
            strgtable[tabIndex]=CoTaskMemAlloc(2*sizeof(WCHAR));
 
            if (strgtable[tabIndex]==NULL)
            {
                ret = E_OUTOFMEMORY;
                goto lend;
            }
 
            lstrcpyW(strgtable[tabIndex++], L"\\");
 
            i++;
 
        }
        else {
 
            for (j = 0; str[i] && str[i] != L'\\'; i++, j++)
                word[j]=str[i];
 
            word[j]=0;
 
            strgtable[tabIndex]=CoTaskMemAlloc(sizeof(WCHAR)*(j+1));
 
            if (strgtable[tabIndex]==NULL)
            {
                ret = E_OUTOFMEMORY;
                goto lend;
            }
 
            lstrcpyW(strgtable[tabIndex++],word);
        }
    }
    strgtable[tabIndex]=NULL;
 
    *stringTable=strgtable;
 
    ret = tabIndex;
 
lend:
    if (ret < 0)
    {
        for (i = 0; i < tabIndex; i++)
            CoTaskMemFree(strgtable[i]);
 
        CoTaskMemFree(strgtable);
    }
 
    CoTaskMemFree(word);
 
    return ret;
}

Referenced by FileMonikerImpl_CommonPrefixWith(), FileMonikerImpl_ComposeWith(), FileMonikerImpl_Construct(), and FileMonikerImpl_RelativePathTo().

FileMonikerImpl_Enum()

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

static

Definition at line 806 of file filemoniker.c.

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

FileMonikerImpl_GetClassID()

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

static

Definition at line 146 of file filemoniker.c.

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

FileMonikerImpl_GetDisplayName()

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

static

Definition at line 1129 of file filemoniker.c.

{
    FileMonikerImpl *This = impl_from_IMoniker(iface);
    int len=lstrlenW(This->filePathName);
 
    TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName);
 
    if (ppszDisplayName==NULL)
        return E_POINTER;
 
    if (pmkToLeft!=NULL)
        return E_INVALIDARG;
 
    *ppszDisplayName=CoTaskMemAlloc(sizeof(WCHAR)*(len+1));
    if (*ppszDisplayName==NULL)
        return E_OUTOFMEMORY;
 
    lstrcpyW(*ppszDisplayName,This->filePathName);
 
    TRACE("-- %s\n", debugstr_w(*ppszDisplayName));
    
    return S_OK;
}

FileMonikerImpl_GetSizeMax()

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

static

Definition at line 441 of file filemoniker.c.

{
    FileMonikerImpl *This = impl_from_IMoniker(iface);
 
    TRACE("(%p,%p)\n",iface,pcbSize);
 
    if (!pcbSize)
        return E_POINTER;
 
    /* We could calculate exactly (see ...::Save()) but instead
     * we'll make a quick over-estimate, like Windows (NT4, XP) does.
     */
    pcbSize->u.LowPart  = 0x38 + 4 * lstrlenW(This->filePathName);
    pcbSize->u.HighPart = 0;
 
    return S_OK;
}

FileMonikerImpl_GetTimeOfLastChange()

static HRESULT WINAPI FileMonikerImpl_GetTimeOfLastChange ( IMoniker *  iface, IBindCtx *  pbc, IMoniker *  pmkToLeft, FILETIME *  pFileTime  )

static

Definition at line 902 of file filemoniker.c.

{
    FileMonikerImpl *This = impl_from_IMoniker(iface);
    IRunningObjectTable* rot;
    HRESULT res;
    WIN32_FILE_ATTRIBUTE_DATA info;
 
    TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pFileTime);
 
    if (pFileTime==NULL)
        return E_POINTER;
 
    if (pmkToLeft!=NULL)
        return E_INVALIDARG;
 
    res=IBindCtx_GetRunningObjectTable(pbc,&rot);
 
    if (FAILED(res))
        return res;
 
    res= IRunningObjectTable_GetTimeOfLastChange(rot,iface,pFileTime);
 
    if (FAILED(res)){ /* the moniker is not registered */
 
        if (!GetFileAttributesExW(This->filePathName,GetFileExInfoStandard,&info))
            return MK_E_NOOBJECT;
 
        *pFileTime=info.ftLastWriteTime;
    }
 
    return S_OK;
}

FileMonikerImpl_Hash()

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

static

Definition at line 838 of file filemoniker.c.

{
    FileMonikerImpl *This = impl_from_IMoniker(iface);
    int  h = 0,i,skip,len;
    int  off = 0;
    LPOLESTR val;
 
    if (pdwHash==NULL)
        return E_POINTER;
 
    val =  This->filePathName;
    len = lstrlenW(val);
 
    if (len < 16) {
        for (i = len ; i > 0; i--) {
            h = (h * 37) + val[off++];
    }
    } else {
        /* only sample some characters */
    skip = len / 8;
    for (i = len ; i > 0; i -= skip, off += skip) {
            h = (h * 39) + val[off];
    }
    }
 
    *pdwHash=h;
 
    return S_OK;
}

FileMonikerImpl_Inverse()

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

static

Definition at line 940 of file filemoniker.c.

{
    TRACE("(%p,%p)\n",iface,ppmk);
 
    return CreateAntiMoniker(ppmk);
}

FileMonikerImpl_IsDirty()

static HRESULT WINAPI FileMonikerImpl_IsDirty ( IMoniker *  iface )

static

Definition at line 166 of file filemoniker.c.

{
 
    TRACE("(%p)\n",iface);
 
    return S_FALSE;
}

FileMonikerImpl_IsEqual()

static HRESULT WINAPI FileMonikerImpl_IsEqual ( IMoniker *  iface, IMoniker *  other  )

static

Definition at line 818 of file filemoniker.c.

{
    FileMonikerImpl *moniker = impl_from_IMoniker(iface), *other_moniker;
 
    TRACE("%p, %p.\n", iface, other);
 
    if (!other)
        return E_INVALIDARG;
 
    other_moniker = unsafe_impl_from_IMoniker(other);
    if (!other_moniker)
        return S_FALSE;
 
    return !wcsicmp(moniker->filePathName, other_moniker->filePathName) ? S_OK : S_FALSE;
}

FileMonikerImpl_IsRunning()

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

static

Definition at line 872 of file filemoniker.c.

{
    IRunningObjectTable* rot;
    HRESULT res;
 
    TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
 
    if ( (pmkNewlyRunning!=NULL) && (IMoniker_IsEqual(pmkNewlyRunning,iface)==S_OK) )
        return S_OK;
 
    if (pbc==NULL)
        return E_POINTER;
 
    res=IBindCtx_GetRunningObjectTable(pbc,&rot);
 
    if (FAILED(res))
        return res;
 
    res = IRunningObjectTable_IsRunning(rot,iface);
 
    IRunningObjectTable_Release(rot);
 
    return res;
}

FileMonikerImpl_IsSystemMoniker()

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

static

Definition at line 1169 of file filemoniker.c.

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

FileMonikerImpl_Load()

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

static

Definition at line 181 of file filemoniker.c.

{
    FileMonikerImpl *This = impl_from_IMoniker(iface);
    HRESULT res;
    CHAR* filePathA = NULL;
    WCHAR* filePathW = NULL;
    ULONG bread;
    WORD  wbuffer;
    DWORD dwbuffer, bytesA, bytesW, len;
    int i;
 
 
    TRACE("(%p,%p)\n",iface,pStm);
 
    /* first WORD */
    res=IStream_Read(pStm,&wbuffer,sizeof(WORD),&bread);
    if (bread!=sizeof(WORD))
    {
        WARN("Couldn't read 0 word\n");
        goto fail;
    }
 
    /* read filePath string length (plus one) */
    res=IStream_Read(pStm,&bytesA,sizeof(DWORD),&bread);
    if (bread != sizeof(DWORD))
    {
        WARN("Couldn't read file string length\n");
        goto fail;
    }
 
    /* read filePath string */
    filePathA = malloc(bytesA);
    if (!filePathA)
    {
        res = E_OUTOFMEMORY;
        goto fail;
    }
 
    res=IStream_Read(pStm,filePathA,bytesA,&bread);
    if (bread != bytesA)
    {
        WARN("Couldn't read file path string\n");
        goto fail;
    }
 
    /* read the unknown value */
    IStream_Read(pStm,&wbuffer,sizeof(WORD),&bread);
    if (bread != sizeof(WORD))
    {
        WARN("Couldn't read unknown value\n");
        goto fail;
    }
 
    /* read the DEAD constant */
    IStream_Read(pStm,&wbuffer,sizeof(WORD),&bread);
    if (bread != sizeof(WORD))
    {
        WARN("Couldn't read DEAD constant\n");
        goto fail;
    }
 
    for(i=0;i<5;i++)
    {
        res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),&bread);
        if (bread!=sizeof(DWORD))
        {
            WARN("Couldn't read 0 padding\n");
            goto fail;
        }
    }
 
    res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),&bread);
    if (bread!=sizeof(DWORD))
        goto fail;
 
    if (!dwbuffer) /* No W-string */
    {        
        bytesA--;
        len=MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, filePathA, bytesA, NULL, 0);
        if (!len)
            goto fail;
 
        filePathW = malloc((len + 1) * sizeof(WCHAR));
        if (!filePathW)
        {
            res = E_OUTOFMEMORY;
            goto fail;
        }
        MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, filePathA, -1, filePathW, len+1);
        goto succeed;
    }
 
    if (dwbuffer < 6)
        goto fail;
 
    bytesW=dwbuffer - 6;
 
    res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),&bread);
    if (bread!=sizeof(DWORD) || dwbuffer!=bytesW)
        goto fail;
 
    res=IStream_Read(pStm,&wbuffer,sizeof(WORD),&bread);
    if (bread!=sizeof(WORD) || wbuffer!=0x3)
        goto fail;
 
    len=bytesW/sizeof(WCHAR);
    filePathW = malloc((len + 1) * sizeof(WCHAR));
    if(!filePathW)
    {
         res = E_OUTOFMEMORY;
         goto fail;
    }
    res=IStream_Read(pStm,filePathW,bytesW,&bread);
    if (bread!=bytesW)
         goto fail;
 
    filePathW[len]=0;
 
 succeed:
    free(filePathA);
    free(This->filePathName);
    This->filePathName=filePathW;
 
    return S_OK;
 
 fail:
    free(filePathA);
    free(filePathW);
 
    if (SUCCEEDED(res))
         res = E_FAIL;
    return res;
}

FileMonikerImpl_ParseDisplayName()

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

static

Definition at line 1158 of file filemoniker.c.

{
    FIXME("(%p,%p,%p,%p,%p,%p),stub!\n",iface,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
    return E_NOTIMPL;
}

FileMonikerImpl_QueryInterface()

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

static

Definition at line 73 of file filemoniker.c.

{
    FileMonikerImpl *This = impl_from_IMoniker(iface);
 
    TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), ppvObject);
 
    if (!ppvObject)
    return E_INVALIDARG;
 
    *ppvObject = 0;
 
    if (IsEqualIID(&IID_IUnknown, riid)      ||
        IsEqualIID(&IID_IPersist, riid)      ||
        IsEqualIID(&IID_IPersistStream,riid) ||
        IsEqualIID(&IID_IMoniker, riid) ||
        IsEqualGUID(&CLSID_FileMoniker, riid))
    {
        *ppvObject = iface;
    }
    else if (IsEqualIID(&IID_IROTData, riid))
        *ppvObject = &This->IROTData_iface;
    else if (IsEqualIID(&IID_IMarshal, riid))
    {
        HRESULT hr = S_OK;
        if (!This->pMarshal)
            hr = MonikerMarshal_Create(iface, &This->pMarshal);
        if (hr != S_OK)
            return hr;
        return IUnknown_QueryInterface(This->pMarshal, riid, ppvObject);
    }
 
    if (!*ppvObject)
        return E_NOINTERFACE;
 
    IMoniker_AddRef(iface);
 
    return S_OK;
}

Referenced by FileMonikerROTDataImpl_QueryInterface().

FileMonikerImpl_Reduce()

static HRESULT WINAPI FileMonikerImpl_Reduce ( IMoniker *  iface, IBindCtx *  pbc, DWORD  howfar, IMoniker **  toleft, IMoniker **  reduced  )

static

Definition at line 609 of file filemoniker.c.

{
    TRACE("%p, %p, %ld, %p, %p.\n", iface, pbc, howfar, toleft, reduced);
 
    if (!pbc || !reduced)
        return E_INVALIDARG;
 
    IMoniker_AddRef(iface);
    *reduced = iface;
 
    return MK_S_REDUCED_TO_SELF;
}

FileMonikerImpl_RelativePathTo()

static HRESULT WINAPI FileMonikerImpl_RelativePathTo ( IMoniker *  iface, IMoniker *  pmOther, IMoniker **  ppmkRelPath  )

static

Definition at line 1053 of file filemoniker.c.

{
    IBindCtx *bind;
    HRESULT res;
    LPOLESTR str1=0,str2=0,*tabStr1=0,*tabStr2=0,relPath=0;
    DWORD len1=0,len2=0,sameIdx=0,j=0;
 
    TRACE("(%p,%p,%p)\n",iface,pmOther,ppmkRelPath);
 
    if (ppmkRelPath==NULL)
        return E_POINTER;
 
    if (pmOther==NULL)
        return E_INVALIDARG;
 
    res=CreateBindCtx(0,&bind);
    if (FAILED(res))
    return res;
 
    res=IMoniker_GetDisplayName(iface,bind,NULL,&str1);
    if (FAILED(res))
    return res;
    res=IMoniker_GetDisplayName(pmOther,bind,NULL,&str2);
    if (FAILED(res))
    return res;
 
    len1=FileMonikerImpl_DecomposePath(str1,&tabStr1);
    if (FAILED(len1))
        return E_OUTOFMEMORY;
    len2=FileMonikerImpl_DecomposePath(str2,&tabStr2);
 
    if (FAILED(len2))
    {
        free_stringtable(tabStr1);
        return E_OUTOFMEMORY;
    }
 
    /* count the number of similar items from the begin of the two paths */
    for(sameIdx=0; ( (tabStr1[sameIdx]!=NULL) &&
           (tabStr2[sameIdx]!=NULL) &&
               (lstrcmpiW(tabStr1[sameIdx],tabStr2[sameIdx])==0)); sameIdx++);
 
    /* begin the construction of relativePath */
    /* if the two paths have a consecutive similar item from the begin ! the relativePath will be composed */
    /* by "..\\" in the begin */
    relPath = malloc(sizeof(WCHAR)*(1+lstrlenW(str1)+lstrlenW(str2)));
 
    *relPath=0;
 
    if (len2>0 && !(len1==1 && len2==1 && sameIdx==0))
        for(j=sameIdx;(tabStr1[j] != NULL); j++)
            if (*tabStr1[j]!='\\')
                lstrcatW(relPath, L"..\\");
 
    /* add items of the second path (similar items with the first path are not included) to the relativePath */
    for(j=sameIdx;tabStr2[j]!=NULL;j++)
        lstrcatW(relPath,tabStr2[j]);
 
    res=CreateFileMoniker(relPath,ppmkRelPath);
 
    free_stringtable(tabStr1);
    free_stringtable(tabStr2);
    CoTaskMemFree(str1);
    CoTaskMemFree(str2);
    free(relPath);
 
    if (len1==0 || len2==0 || (len1==1 && len2==1 && sameIdx==0))
        return MK_S_HIM;
 
    return res;
}

FileMonikerImpl_Release()

static ULONG WINAPI FileMonikerImpl_Release ( IMoniker *  iface )

static

Definition at line 125 of file filemoniker.c.

{
    FileMonikerImpl *moniker = impl_from_IMoniker(iface);
    ULONG ref = InterlockedDecrement(&moniker->ref);
 
    TRACE("%p, refcount %lu.\n", iface, ref);
 
    if (!ref)
    {
        if (moniker->pMarshal) IUnknown_Release(moniker->pMarshal);
        free(moniker->filePathName);
        free(moniker);
    }
 
    return ref;
}

Referenced by FileMonikerROTDataImpl_Release().

FileMonikerImpl_Save()

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

static

Definition at line 342 of file filemoniker.c.

{
    FileMonikerImpl *This = impl_from_IMoniker(iface);
    HRESULT res;
    LPOLESTR filePathW=This->filePathName;
    CHAR*    filePathA;
    DWORD bytesA, bytesW, len;
 
    static const WORD FFFF = 0xFFFF; /* Constants */
    static const WORD DEAD = 0xDEAD;
    static const DWORD ZERO     = 0;
    static const WORD  THREE    = 0x3;
 
    int i;
    BOOL bUsedDefault, bWriteWide;
 
    TRACE("(%p,%p,%d)\n",iface,pStm,fClearDirty);
 
    if (pStm==NULL)
        return E_POINTER;
 
    /* write a 0 WORD */
    res=IStream_Write(pStm,&ZERO,sizeof(WORD),NULL);
    if (FAILED(res)) return res;
 
    /* write length of filePath string ( 0 included )*/
    bytesA = WideCharToMultiByte( CP_ACP, 0, filePathW, -1, NULL, 0, NULL, NULL );
    res=IStream_Write(pStm,&bytesA,sizeof(DWORD),NULL);
    if (FAILED(res)) return res;
 
    /* write A string (with '\0') */
    filePathA = malloc(bytesA);
    if (!filePathA)
        return E_OUTOFMEMORY;
    WideCharToMultiByte( CP_ACP, 0, filePathW, -1, filePathA, bytesA, NULL, &bUsedDefault);
    res=IStream_Write(pStm,filePathA,bytesA,NULL);
    free(filePathA);
    if (FAILED(res)) return res;
 
    /* write a WORD 0xFFFF */
    res=IStream_Write(pStm,&FFFF,sizeof(WORD),NULL);
    if (FAILED(res)) return res;
 
    /* write a WORD 0xDEAD */
    res=IStream_Write(pStm,&DEAD,sizeof(WORD),NULL);
    if (FAILED(res)) return res;
 
    /* write 5 zero DWORDs */
    for(i=0;i<5;i++)
    {
        res=IStream_Write(pStm,&ZERO,sizeof(DWORD),NULL);
        if (FAILED(res)) return res;
    }
 
    /* Write the wide version if:
     *    + couldn't convert to CP_ACP, 
     * or + it's a directory, 
     * or + there's a character > 0xFF 
     */
    len = lstrlenW(filePathW);
    bWriteWide = (bUsedDefault || (len > 0 && filePathW[len-1]=='\\' ));
    if (!bWriteWide)
    {
        WCHAR* pch;
        for(pch=filePathW;*pch;++pch) 
        {
            if (*pch > 0xFF)
            {
                bWriteWide = TRUE;
                break;
            }
        }
    }
 
    if (!bWriteWide)
        return IStream_Write(pStm,&ZERO,sizeof(DWORD),NULL);
 
    /* write bytes needed for the filepathW (without 0) + 6 */
    bytesW = len*sizeof(WCHAR) + 6;
    res=IStream_Write(pStm,&bytesW,sizeof(DWORD),NULL);
    if (FAILED(res)) return res;
 
    /* try again, without the extra 6 */
    bytesW -= 6;
    res=IStream_Write(pStm,&bytesW,sizeof(DWORD),NULL);
    if (FAILED(res)) return res;
 
    /* write a WORD 3 */
    res=IStream_Write(pStm,&THREE,sizeof(WORD),NULL);
    if (FAILED(res)) return res;
 
    /* write W string (no 0) */
    return IStream_Write(pStm,filePathW,bytesW,NULL);
}

FileMonikerROTDataImpl_AddRef()

static ULONG WINAPI FileMonikerROTDataImpl_AddRef ( IROTData *  iface )

static

Definition at line 1199 of file filemoniker.c.

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

FileMonikerROTDataImpl_GetComparisonData()

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

static

Definition at line 1225 of file filemoniker.c.

{
    FileMonikerImpl *This = impl_from_IROTData(iface);
    int len = lstrlenW(This->filePathName)+1;
    int i;
    LPWSTR pszFileName;
 
    TRACE("%p, %p, %lu, %p.\n", iface, pbData, cbMax, pcbData);
 
    *pcbData = sizeof(CLSID) + len * sizeof(WCHAR);
    if (cbMax < *pcbData)
        return E_OUTOFMEMORY;
 
    memcpy(pbData, &CLSID_FileMoniker, sizeof(CLSID));
    pszFileName = (LPWSTR)(pbData+sizeof(CLSID));
    for (i = 0; i < len; i++)
        pszFileName[i] = towupper(This->filePathName[i]);
 
    return S_OK;
}

FileMonikerROTDataImpl_QueryInterface()

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

static

Definition at line 1185 of file filemoniker.c.

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

FileMonikerROTDataImpl_Release()

static ULONG WINAPI FileMonikerROTDataImpl_Release ( IROTData *  iface )

static

Definition at line 1212 of file filemoniker.c.

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

free_stringtable()

static void free_stringtable ( LPOLESTR *  stringTable )

static

Definition at line 623 of file filemoniker.c.

{
    int i;
 
    for (i=0; stringTable[i]!=NULL; i++)
        CoTaskMemFree(stringTable[i]);
    CoTaskMemFree(stringTable);
}

Referenced by FileMonikerImpl_CommonPrefixWith(), FileMonikerImpl_ComposeWith(), FileMonikerImpl_Construct(), and FileMonikerImpl_RelativePathTo().

impl_from_IMoniker()

static FileMonikerImpl * impl_from_IMoniker ( IMoniker *  iface )

inlinestatic

Definition at line 48 of file filemoniker.c.

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

Referenced by FileMonikerImpl_AddRef(), FileMonikerImpl_BindToObject(), FileMonikerImpl_BindToStorage(), FileMonikerImpl_GetDisplayName(), FileMonikerImpl_GetSizeMax(), FileMonikerImpl_GetTimeOfLastChange(), FileMonikerImpl_Hash(), FileMonikerImpl_IsEqual(), FileMonikerImpl_Load(), FileMonikerImpl_QueryInterface(), FileMonikerImpl_Release(), and FileMonikerImpl_Save().

impl_from_IROTData()

static FileMonikerImpl * impl_from_IROTData ( IROTData *  iface )

inlinestatic

Definition at line 53 of file filemoniker.c.

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

Referenced by FileMonikerROTDataImpl_AddRef(), FileMonikerROTDataImpl_GetComparisonData(), FileMonikerROTDataImpl_QueryInterface(), and FileMonikerROTDataImpl_Release().

memrpbrkW()

static WCHAR * memrpbrkW ( const WCHAR *  ptr, size_t  n, const WCHAR *  accept  )

inlinestatic

Definition at line 1389 of file filemoniker.c.

{
    const WCHAR *end, *ret = NULL;
    for (end = ptr + n; ptr < end; ptr++) if (wcschr(accept, *ptr)) ret = ptr;
    return (WCHAR *)ret;
}

Referenced by FileMoniker_CreateFromDisplayName().

unsafe_impl_from_IMoniker()

static FileMonikerImpl * unsafe_impl_from_IMoniker ( IMoniker *  iface )

static

Definition at line 60 of file filemoniker.c.

{
    if (iface->lpVtbl != &VT_FileMonikerImpl)
        return NULL;
    return CONTAINING_RECORD(iface, FileMonikerImpl, IMoniker_iface);
}

Referenced by FileMonikerImpl_IsEqual().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ole

)

Variable Documentation

VT_FileMonikerImpl

static const IMonikerVtbl VT_FileMonikerImpl

static

Initial value:

=
{
    FileMonikerImpl_QueryInterface,
    FileMonikerImpl_AddRef,
    FileMonikerImpl_Release,
    FileMonikerImpl_GetClassID,
    FileMonikerImpl_IsDirty,
    FileMonikerImpl_Load,
    FileMonikerImpl_Save,
    FileMonikerImpl_GetSizeMax,
    FileMonikerImpl_BindToObject,
    FileMonikerImpl_BindToStorage,
    FileMonikerImpl_Reduce,
    FileMonikerImpl_ComposeWith,
    FileMonikerImpl_Enum,
    FileMonikerImpl_IsEqual,
    FileMonikerImpl_Hash,
    FileMonikerImpl_IsRunning,
    FileMonikerImpl_GetTimeOfLastChange,
    FileMonikerImpl_Inverse,
    FileMonikerImpl_CommonPrefixWith,
    FileMonikerImpl_RelativePathTo,
    FileMonikerImpl_GetDisplayName,
    FileMonikerImpl_ParseDisplayName,
    FileMonikerImpl_IsSystemMoniker
}

Definition at line 58 of file filemoniker.c.

Referenced by FileMonikerImpl_Construct(), and unsafe_impl_from_IMoniker().

VT_ROTDataImpl

const IROTDataVtbl VT_ROTDataImpl

static

Initial value:

=
{
    FileMonikerROTDataImpl_QueryInterface,
    FileMonikerROTDataImpl_AddRef,
    FileMonikerROTDataImpl_Release,
    FileMonikerROTDataImpl_GetComparisonData
}

Definition at line 1279 of file filemoniker.c.

Referenced by FileMonikerImpl_Construct().