2005-05-12 11:57:21 +02:00
|
|
|
/*
|
|
|
|
* FileMonikers implementation
|
1999-01-28 18:56:14 +01:00
|
|
|
*
|
2005-05-12 11:57:21 +02:00
|
|
|
* Copyright 1999 Noomen Hamza
|
2002-03-10 00:29:33 +01:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with this library; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
1999-01-28 18:56:14 +01:00
|
|
|
|
|
|
|
#include <assert.h>
|
2003-09-06 01:08:26 +02:00
|
|
|
#include <stdarg.h>
|
2001-01-26 21:40:50 +01:00
|
|
|
#include <string.h>
|
2003-01-07 21:36:20 +01:00
|
|
|
|
2004-10-07 05:06:48 +02:00
|
|
|
#define COBJMACROS
|
2003-01-07 21:36:20 +01:00
|
|
|
#define NONAMELESSUNION
|
|
|
|
#define NONAMELESSSTRUCT
|
2004-10-07 05:06:48 +02:00
|
|
|
|
2003-09-06 01:08:26 +02:00
|
|
|
#include "windef.h"
|
1999-08-18 20:35:57 +02:00
|
|
|
#include "winbase.h"
|
1999-02-28 20:14:33 +01:00
|
|
|
#include "winerror.h"
|
2000-11-30 02:31:28 +01:00
|
|
|
#include "winnls.h"
|
2000-08-14 16:41:19 +02:00
|
|
|
#include "wine/unicode.h"
|
2002-03-10 00:29:33 +01:00
|
|
|
#include "wine/debug.h"
|
1999-03-23 14:48:56 +01:00
|
|
|
#include "objbase.h"
|
2002-12-19 02:09:40 +01:00
|
|
|
#include "moniker.h"
|
1999-03-23 14:48:56 +01:00
|
|
|
|
2000-11-25 04:08:23 +01:00
|
|
|
#include "compobj_private.h"
|
|
|
|
|
2002-03-10 00:29:33 +01:00
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(ole);
|
1999-04-19 16:56:29 +02:00
|
|
|
|
2002-12-19 02:09:40 +01:00
|
|
|
const CLSID CLSID_FileMoniker = {
|
|
|
|
0x303, 0, 0, {0xC0, 0, 0, 0, 0, 0, 0, 0x46}
|
|
|
|
};
|
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
/* filemoniker data structure */
|
1999-01-28 18:56:14 +01:00
|
|
|
typedef struct FileMonikerImpl{
|
|
|
|
|
2004-08-13 01:00:51 +02:00
|
|
|
IMonikerVtbl* lpvtbl1; /* VTable relative to the IMoniker interface.*/
|
1999-03-23 14:48:56 +01:00
|
|
|
|
2002-06-01 01:06:46 +02:00
|
|
|
/* The ROT (RunningObjectTable implementation) uses the IROTData interface to test whether
|
1999-03-23 14:48:56 +01:00
|
|
|
* two monikers are equal. That's whay IROTData interface is implemented by monikers.
|
|
|
|
*/
|
2004-08-13 01:00:51 +02:00
|
|
|
IROTDataVtbl* lpvtbl2; /* VTable relative to the IROTData interface.*/
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
ULONG ref; /* reference counter for this object */
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
LPOLESTR filePathName; /* path string identified by this filemoniker */
|
1999-01-28 18:56:14 +01:00
|
|
|
|
|
|
|
} FileMonikerImpl;
|
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
/* IROTData prototype function */
|
|
|
|
static HRESULT WINAPI FileMonikerROTDataImpl_GetComparaisonData(IROTData* iface,BYTE* pbData,ULONG cbMax,ULONG* pcbData);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
/* Local function used by filemoniker implementation */
|
2005-05-12 11:57:21 +02:00
|
|
|
static HRESULT WINAPI FileMonikerImpl_Construct(FileMonikerImpl* iface, LPCOLESTR lpszPathName);
|
|
|
|
static HRESULT WINAPI FileMonikerImpl_Destroy(FileMonikerImpl* iface);
|
1999-03-23 14:48:56 +01:00
|
|
|
|
1999-01-28 18:56:14 +01:00
|
|
|
/*******************************************************************************
|
|
|
|
* FileMoniker_QueryInterface
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
2004-09-09 23:03:58 +02:00
|
|
|
FileMonikerImpl *This = (FileMonikerImpl *)iface;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
2005-05-12 11:57:21 +02:00
|
|
|
TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppvObject);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
/* Perform a sanity check on the parameters.*/
|
|
|
|
if ( (This==0) || (ppvObject==0) )
|
|
|
|
return E_INVALIDARG;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
/* Initialize the return parameter */
|
2005-05-12 11:57:21 +02:00
|
|
|
*ppvObject = 0;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
/* 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;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
else if (IsEqualIID(&IID_IROTData, riid))
|
|
|
|
*ppvObject = (IROTData*)&(This->lpvtbl2);
|
|
|
|
|
|
|
|
/* Check that we obtained an interface.*/
|
|
|
|
if ((*ppvObject)==0)
|
|
|
|
return E_NOINTERFACE;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
/* Query Interface always increases the reference count by one when it is successful */
|
2005-05-12 11:57:21 +02:00
|
|
|
IMoniker_AddRef(iface);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
return S_OK;
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_AddRef
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static ULONG WINAPI
|
|
|
|
FileMonikerImpl_AddRef(IMoniker* iface)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
2004-09-09 23:03:58 +02:00
|
|
|
FileMonikerImpl *This = (FileMonikerImpl *)iface;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p)\n",iface);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
2004-09-24 03:16:53 +02:00
|
|
|
return InterlockedIncrement(&This->ref);
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_Release
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static ULONG WINAPI
|
|
|
|
FileMonikerImpl_Release(IMoniker* iface)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
2004-09-09 23:03:58 +02:00
|
|
|
FileMonikerImpl *This = (FileMonikerImpl *)iface;
|
2004-09-24 03:16:53 +02:00
|
|
|
ULONG ref;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p)\n",iface);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
2004-09-24 03:16:53 +02:00
|
|
|
ref = InterlockedDecrement(&This->ref);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
/* destroy the object if there's no more reference on it */
|
2004-09-24 03:16:53 +02:00
|
|
|
if (ref == 0) FileMonikerImpl_Destroy(This);
|
1999-03-23 14:48:56 +01:00
|
|
|
|
2004-09-24 03:16:53 +02:00
|
|
|
return ref;
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_GetClassID
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_GetClassID(IMoniker* iface, CLSID *pClassID)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
2005-02-18 21:13:23 +01:00
|
|
|
TRACE("(%p,%p)\n",iface,pClassID);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
if (pClassID==NULL)
|
|
|
|
return E_POINTER;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
*pClassID = CLSID_FileMoniker;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
return S_OK;
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_IsDirty
|
2005-05-12 11:57:21 +02:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_IsDirty(IMoniker* iface)
|
1999-01-28 18:56:14 +01:00
|
|
|
{
|
1999-02-18 14:26:22 +01:00
|
|
|
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p)\n",iface);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
return S_FALSE;
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_Load
|
2005-05-12 11:57:21 +02:00
|
|
|
*
|
|
|
|
* this function locates and reads from the stream the filePath string
|
|
|
|
* written by FileMonikerImpl_Save
|
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_Load(IMoniker* iface,IStream* pStm)
|
1999-01-28 18:56:14 +01:00
|
|
|
{
|
1999-03-23 14:48:56 +01:00
|
|
|
HRESULT res;
|
|
|
|
CHAR* filePathA;
|
|
|
|
WCHAR* filePathW;
|
|
|
|
ULONG bread;
|
|
|
|
WORD wbuffer;
|
|
|
|
DWORD dwbuffer,length,i,doubleLenHex,doubleLenDec;
|
1999-02-18 14:26:22 +01:00
|
|
|
|
2004-09-09 23:03:58 +02:00
|
|
|
FileMonikerImpl *This = (FileMonikerImpl *)iface;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p,%p)\n",iface,pStm);
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
/* first WORD is non significative */
|
|
|
|
res=IStream_Read(pStm,&wbuffer,sizeof(WORD),&bread);
|
|
|
|
if (bread!=sizeof(WORD) || wbuffer!=0)
|
|
|
|
return E_FAIL;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
/* read filePath string length (plus one) */
|
|
|
|
res=IStream_Read(pStm,&length,sizeof(DWORD),&bread);
|
|
|
|
if (bread != sizeof(DWORD))
|
|
|
|
return E_FAIL;
|
|
|
|
|
|
|
|
/* read filePath string */
|
|
|
|
filePathA=HeapAlloc(GetProcessHeap(),0,length);
|
|
|
|
res=IStream_Read(pStm,filePathA,length,&bread);
|
2003-09-30 02:24:08 +02:00
|
|
|
HeapFree(GetProcessHeap(),0,filePathA);
|
1999-03-23 14:48:56 +01:00
|
|
|
if (bread != length)
|
|
|
|
return E_FAIL;
|
|
|
|
|
|
|
|
/* read the first constant */
|
|
|
|
IStream_Read(pStm,&dwbuffer,sizeof(DWORD),&bread);
|
|
|
|
if (bread != sizeof(DWORD) || dwbuffer != 0xDEADFFFF)
|
|
|
|
return E_FAIL;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
length--;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
for(i=0;i<10;i++){
|
|
|
|
res=IStream_Read(pStm,&wbuffer,sizeof(WORD),&bread);
|
|
|
|
if (bread!=sizeof(WORD) || wbuffer!=0)
|
|
|
|
return E_FAIL;
|
|
|
|
}
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
if (length>8)
|
|
|
|
length=0;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
doubleLenHex=doubleLenDec=2*length;
|
|
|
|
if (length > 5)
|
|
|
|
doubleLenDec+=6;
|
|
|
|
|
|
|
|
res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),&bread);
|
|
|
|
if (bread!=sizeof(DWORD) || dwbuffer!=doubleLenDec)
|
|
|
|
return E_FAIL;
|
|
|
|
|
|
|
|
if (length==0)
|
|
|
|
return res;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),&bread);
|
|
|
|
if (bread!=sizeof(DWORD) || dwbuffer!=doubleLenHex)
|
|
|
|
return E_FAIL;
|
|
|
|
|
|
|
|
res=IStream_Read(pStm,&wbuffer,sizeof(WORD),&bread);
|
|
|
|
if (bread!=sizeof(WORD) || wbuffer!=0x3)
|
|
|
|
return E_FAIL;
|
|
|
|
|
|
|
|
filePathW=HeapAlloc(GetProcessHeap(),0,(length+1)*sizeof(WCHAR));
|
|
|
|
filePathW[length]=0;
|
|
|
|
res=IStream_Read(pStm,filePathW,doubleLenHex,&bread);
|
2003-10-01 05:14:29 +02:00
|
|
|
if (bread!=doubleLenHex) {
|
|
|
|
HeapFree(GetProcessHeap(), 0, filePathW);
|
1999-03-23 14:48:56 +01:00
|
|
|
return E_FAIL;
|
2003-10-01 05:14:29 +02:00
|
|
|
}
|
1999-03-23 14:48:56 +01:00
|
|
|
|
2004-12-23 18:06:43 +01:00
|
|
|
HeapFree(GetProcessHeap(),0,This->filePathName);
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
This->filePathName=filePathW;
|
|
|
|
|
|
|
|
return res;
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
1999-02-18 14:26:22 +01:00
|
|
|
* FileMoniker_Save
|
2005-05-12 11:57:21 +02:00
|
|
|
*
|
|
|
|
* This function saves data of this object. In the beginning I thougth
|
|
|
|
* that I have just to write the filePath string on Stream. But, when I
|
|
|
|
* tested this function whith windows programs samples, I noticed that it
|
|
|
|
* was not the case. So I analysed data written by this function on
|
|
|
|
* Windows and what this did function exactly ! But I have no idea about
|
|
|
|
* its logic !
|
|
|
|
* I guessed data which must be written on stream is:
|
|
|
|
* 1) WORD constant:zero
|
|
|
|
* 2) length of the path string ("\0" included)
|
|
|
|
* 3) path string type A
|
|
|
|
* 4) DWORD constant : 0xDEADFFFF
|
|
|
|
* 5) ten WORD constant: zero
|
|
|
|
* 6) DWORD: double-length of the the path string type W ("\0" not
|
|
|
|
* included)
|
|
|
|
* 7) WORD constant: 0x3
|
|
|
|
* 8) filePath unicode string.
|
|
|
|
* if the length(filePath) > 8 or length(filePath) == 8 stop at step 5)
|
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_Save(IMoniker* iface, IStream* pStm, BOOL fClearDirty)
|
1999-01-28 18:56:14 +01:00
|
|
|
{
|
2004-09-09 23:03:58 +02:00
|
|
|
FileMonikerImpl *This = (FileMonikerImpl *)iface;
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
HRESULT res;
|
|
|
|
LPOLESTR filePathW=This->filePathName;
|
|
|
|
CHAR* filePathA;
|
2000-11-28 23:40:56 +01:00
|
|
|
DWORD len;
|
1999-03-23 14:48:56 +01:00
|
|
|
|
2001-01-26 21:40:50 +01:00
|
|
|
DWORD constant1 = 0xDEADFFFF; /* these constants are detected after analysing the data structure written by */
|
1999-03-23 14:48:56 +01:00
|
|
|
WORD constant2 = 0x3; /* FileMoniker_Save function in a windows program system */
|
|
|
|
|
|
|
|
WORD zero=0;
|
|
|
|
DWORD doubleLenHex;
|
|
|
|
DWORD doubleLenDec;
|
|
|
|
int i=0;
|
|
|
|
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p,%p,%d)\n",iface,pStm,fClearDirty);
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
if (pStm==NULL)
|
|
|
|
return E_POINTER;
|
|
|
|
|
2001-01-26 21:40:50 +01:00
|
|
|
/* write a DWORD set to 0 : constant */
|
1999-03-23 14:48:56 +01:00
|
|
|
res=IStream_Write(pStm,&zero,sizeof(WORD),NULL);
|
|
|
|
|
|
|
|
/* write length of filePath string ( "\0" included )*/
|
2000-11-28 23:40:56 +01:00
|
|
|
len = WideCharToMultiByte( CP_ACP, 0, filePathW, -1, NULL, 0, NULL, NULL );
|
1999-03-23 14:48:56 +01:00
|
|
|
res=IStream_Write(pStm,&len,sizeof(DWORD),NULL);
|
|
|
|
|
|
|
|
/* write filePath string type A */
|
|
|
|
filePathA=HeapAlloc(GetProcessHeap(),0,len);
|
2000-11-28 23:40:56 +01:00
|
|
|
WideCharToMultiByte( CP_ACP, 0, filePathW, -1, filePathA, len, NULL, NULL );
|
1999-03-23 14:48:56 +01:00
|
|
|
res=IStream_Write(pStm,filePathA,len,NULL);
|
|
|
|
HeapFree(GetProcessHeap(),0,filePathA);
|
|
|
|
|
2001-01-26 21:40:50 +01:00
|
|
|
/* write a DWORD set to 0xDEADFFFF: constant */
|
1999-03-23 14:48:56 +01:00
|
|
|
res=IStream_Write(pStm,&constant1,sizeof(DWORD),NULL);
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
len--;
|
2001-01-26 21:40:50 +01:00
|
|
|
/* write 10 times a DWORD set to 0 : constants */
|
1999-03-23 14:48:56 +01:00
|
|
|
for(i=0;i<10;i++)
|
|
|
|
res=IStream_Write(pStm,&zero,sizeof(WORD),NULL);
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
if (len>8)
|
|
|
|
len=0;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
doubleLenHex=doubleLenDec=2*len;
|
|
|
|
if (len > 5)
|
|
|
|
doubleLenDec+=6;
|
|
|
|
|
|
|
|
/* write double-length of the path string ( "\0" included )*/
|
|
|
|
res=IStream_Write(pStm,&doubleLenDec,sizeof(DWORD),NULL);
|
|
|
|
|
|
|
|
if (len==0)
|
|
|
|
return res;
|
|
|
|
|
|
|
|
/* write double-length (hexa representation) of the path string ( "\0" included ) */
|
|
|
|
res=IStream_Write(pStm,&doubleLenHex,sizeof(DWORD),NULL);
|
|
|
|
|
2001-01-26 21:40:50 +01:00
|
|
|
/* write a WORD set to 0x3: constant */
|
1999-03-23 14:48:56 +01:00
|
|
|
res=IStream_Write(pStm,&constant2,sizeof(WORD),NULL);
|
|
|
|
|
|
|
|
/* write path unicode string */
|
|
|
|
res=IStream_Write(pStm,filePathW,doubleLenHex,NULL);
|
|
|
|
|
|
|
|
return res;
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_GetSizeMax
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize)
|
1999-01-28 18:56:14 +01:00
|
|
|
{
|
2004-09-09 23:03:58 +02:00
|
|
|
FileMonikerImpl *This = (FileMonikerImpl *)iface;
|
1999-03-23 14:48:56 +01:00
|
|
|
DWORD len=lstrlenW(This->filePathName);
|
|
|
|
DWORD sizeMAx;
|
1999-02-18 14:26:22 +01:00
|
|
|
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p,%p)\n",iface,pcbSize);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
if (pcbSize!=NULL)
|
|
|
|
return E_POINTER;
|
|
|
|
|
|
|
|
/* for more details see FileMonikerImpl_Save coments */
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
sizeMAx = sizeof(WORD) + /* first WORD is 0 */
|
|
|
|
sizeof(DWORD)+ /* length of filePath including "\0" in the end of the string */
|
|
|
|
(len+1)+ /* filePath string */
|
|
|
|
sizeof(DWORD)+ /* constant : 0xDEADFFFF */
|
|
|
|
10*sizeof(WORD)+ /* 10 zero WORD */
|
|
|
|
sizeof(DWORD); /* size of the unicode filePath: "\0" not included */
|
|
|
|
|
|
|
|
if (len==0 || len > 8)
|
|
|
|
return S_OK;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
sizeMAx += sizeof(DWORD)+ /* size of the unicode filePath: "\0" not included */
|
|
|
|
sizeof(WORD)+ /* constant : 0x3 */
|
|
|
|
len*sizeof(WCHAR); /* unicde filePath string */
|
2002-06-01 01:06:46 +02:00
|
|
|
|
2004-01-23 02:51:33 +01:00
|
|
|
pcbSize->u.LowPart=sizeMAx;
|
|
|
|
pcbSize->u.HighPart=0;
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
return S_OK;
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
1999-03-23 14:48:56 +01:00
|
|
|
* FileMoniker_Destroy (local function)
|
1999-01-28 18:56:14 +01:00
|
|
|
*******************************************************************************/
|
1999-03-23 14:48:56 +01:00
|
|
|
HRESULT WINAPI FileMonikerImpl_Destroy(FileMonikerImpl* This)
|
|
|
|
{
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p)\n",This);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
2004-12-23 18:06:43 +01:00
|
|
|
HeapFree(GetProcessHeap(),0,This->filePathName);
|
1999-03-23 14:48:56 +01:00
|
|
|
HeapFree(GetProcessHeap(),0,This);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_BindToObject
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_BindToObject(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
|
|
|
|
REFIID riid, VOID** ppvResult)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
1999-03-23 14:48:56 +01:00
|
|
|
HRESULT res=E_FAIL;
|
|
|
|
CLSID clsID;
|
|
|
|
IUnknown* pObj=0;
|
|
|
|
IRunningObjectTable *prot=0;
|
|
|
|
IPersistFile *ppf=0;
|
|
|
|
IClassFactory *pcf=0;
|
|
|
|
IClassActivator *pca=0;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
2004-09-09 23:03:58 +02:00
|
|
|
FileMonikerImpl *This = (FileMonikerImpl *)iface;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
*ppvResult=0;
|
|
|
|
|
2005-02-18 21:13:23 +01:00
|
|
|
TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
if(pmkToLeft==NULL){
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
res=IBindCtx_GetRunningObjectTable(pbc,&prot);
|
|
|
|
|
|
|
|
if (SUCCEEDED(res)){
|
2004-01-06 23:08:33 +01:00
|
|
|
/* if the requested class was loaded before ! we don't need to reload it */
|
1999-03-23 14:48:56 +01:00
|
|
|
res = IRunningObjectTable_GetObject(prot,iface,&pObj);
|
|
|
|
|
|
|
|
if (res==S_FALSE){
|
|
|
|
/* first activation of this class */
|
|
|
|
res=GetClassFile(This->filePathName,&clsID);
|
|
|
|
if (SUCCEEDED(res)){
|
|
|
|
|
2004-05-21 22:52:57 +02:00
|
|
|
res=CoCreateInstance(&clsID,NULL,CLSCTX_ALL,&IID_IPersistFile,(void**)&ppf);
|
1999-03-23 14:48:56 +01:00
|
|
|
if (SUCCEEDED(res)){
|
|
|
|
|
|
|
|
res=IPersistFile_Load(ppf,This->filePathName,STGM_READ);
|
|
|
|
if (SUCCEEDED(res)){
|
|
|
|
|
|
|
|
pObj=(IUnknown*)ppf;
|
|
|
|
IUnknown_AddRef(pObj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else{
|
2004-05-21 22:52:57 +02:00
|
|
|
res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IClassFactory,(void**)&pcf);
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
if (res==E_NOINTERFACE){
|
|
|
|
|
2004-05-21 22:52:57 +02:00
|
|
|
res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IClassActivator,(void**)&pca);
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
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){
|
|
|
|
|
2001-05-09 19:31:31 +02:00
|
|
|
FIXME("()\n");
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
/*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);
|
|
|
|
}
|
|
|
|
}*/
|
|
|
|
}
|
2001-05-09 19:31:31 +02:00
|
|
|
}
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
if (pObj!=NULL){
|
|
|
|
/* get the requested interface from the loaded class */
|
|
|
|
res= IUnknown_QueryInterface(pObj,riid,ppvResult);
|
|
|
|
|
|
|
|
IBindCtx_RegisterObjectBound(pbc,(IUnknown*)*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);
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
return res;
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_BindToStorage
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_BindToStorage(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
|
|
|
|
REFIID riid, VOID** ppvObject)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
1999-03-23 14:48:56 +01:00
|
|
|
LPOLESTR filePath=0;
|
|
|
|
IStorage *pstg=0;
|
|
|
|
HRESULT res;
|
|
|
|
|
2005-02-18 21:13:23 +01:00
|
|
|
TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvObject);
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
if (pmkToLeft==NULL){
|
|
|
|
|
|
|
|
if (IsEqualIID(&IID_IStorage, riid)){
|
|
|
|
|
|
|
|
/* get the file name */
|
2005-05-12 11:57:21 +02:00
|
|
|
IMoniker_GetDisplayName(iface,pbc,pmkToLeft,&filePath);
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
/* verifie if the file contains a storage object */
|
|
|
|
res=StgIsStorageFile(filePath);
|
|
|
|
|
|
|
|
if(res==S_OK){
|
|
|
|
|
|
|
|
res=StgOpenStorage(filePath,NULL,STGM_READWRITE|STGM_SHARE_DENY_WRITE,NULL,0,&pstg);
|
|
|
|
|
|
|
|
if (SUCCEEDED(res)){
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
*ppvObject=pstg;
|
|
|
|
|
|
|
|
IStorage_AddRef(pstg);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
CoTaskMemFree(filePath);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
if ( (IsEqualIID(&IID_IStream, riid)) || (IsEqualIID(&IID_ILockBytes, riid)) )
|
2004-04-13 00:02:37 +02:00
|
|
|
return E_FAIL;
|
1999-03-23 14:48:56 +01:00
|
|
|
else
|
|
|
|
return E_NOINTERFACE;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
|
2005-02-18 21:13:23 +01:00
|
|
|
FIXME("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvObject);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
2001-09-11 02:32:32 +02:00
|
|
|
return E_NOTIMPL;
|
|
|
|
}
|
1999-03-23 14:48:56 +01:00
|
|
|
return res;
|
|
|
|
}
|
1999-01-28 18:56:14 +01:00
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_Reduce
|
|
|
|
******************************************************************************/
|
2005-05-12 11:57:21 +02:00
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_Reduce(IMoniker* iface, IBindCtx* pbc, DWORD dwReduceHowFar,
|
|
|
|
IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p,%p,%ld,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
if (ppmkReduced==NULL)
|
|
|
|
return E_POINTER;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
2005-05-12 11:57:21 +02:00
|
|
|
IMoniker_AddRef(iface);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
*ppmkReduced=iface;
|
|
|
|
|
|
|
|
return MK_S_REDUCED_TO_SELF;
|
|
|
|
}
|
2005-05-12 11:57:21 +02:00
|
|
|
|
1999-01-28 18:56:14 +01:00
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_ComposeWith
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_ComposeWith(IMoniker* iface, IMoniker* pmkRight,
|
|
|
|
BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
1999-03-23 14:48:56 +01:00
|
|
|
HRESULT res;
|
|
|
|
LPOLESTR str1=0,str2=0,*strDec1=0,*strDec2=0,newStr=0;
|
2004-04-20 03:12:17 +02:00
|
|
|
static const WCHAR twoPoint[]={'.','.',0};
|
|
|
|
static const WCHAR bkSlash[]={'\\',0};
|
1999-03-23 14:48:56 +01:00
|
|
|
IBindCtx *bind=0;
|
|
|
|
int i=0,j=0,lastIdx1=0,lastIdx2=0;
|
|
|
|
DWORD mkSys;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
if (ppmkComposite==NULL)
|
|
|
|
return E_POINTER;
|
|
|
|
|
|
|
|
if (pmkRight==NULL)
|
|
|
|
return E_INVALIDARG;
|
|
|
|
|
|
|
|
*ppmkComposite=0;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
IMoniker_IsSystemMoniker(pmkRight,&mkSys);
|
|
|
|
|
|
|
|
/* check if we have two filemonikers to compose or not */
|
|
|
|
if(mkSys==MKSYS_FILEMONIKER){
|
|
|
|
|
|
|
|
CreateBindCtx(0,&bind);
|
|
|
|
|
2005-05-12 11:57:21 +02:00
|
|
|
IMoniker_GetDisplayName(iface,bind,NULL,&str1);
|
1999-03-23 14:48:56 +01:00
|
|
|
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 && lstrcmpW(strDec1[0],twoPoint)==0))
|
|
|
|
return MK_E_SYNTAX;
|
|
|
|
|
|
|
|
if(lstrcmpW(strDec1[lastIdx1],bkSlash)==0)
|
|
|
|
lastIdx1--;
|
|
|
|
|
|
|
|
/* for etch "..\" in the left of str2 remove the right element from str1 */
|
|
|
|
for(i=0; ( (lastIdx1>=0) && (strDec2[i]!=NULL) && (lstrcmpW(strDec2[i],twoPoint)==0) ) ;i+=2){
|
|
|
|
|
|
|
|
lastIdx1-=2;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* the length of the composed path string is raised by the sum of the two paths lengths */
|
|
|
|
newStr=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(lstrlenW(str1)+lstrlenW(str2)+1));
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
if (newStr==NULL)
|
|
|
|
return E_OUTOFMEMORY;
|
|
|
|
|
|
|
|
/* new path is the concatenation of the rest of str1 and str2 */
|
|
|
|
for(*newStr=0,j=0;j<=lastIdx1;j++)
|
2000-08-14 16:41:19 +02:00
|
|
|
strcatW(newStr,strDec1[j]);
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
if ((strDec2[i]==NULL && lastIdx1>-1 && lastIdx2>-1) || lstrcmpW(strDec2[i],bkSlash)!=0)
|
2000-08-14 16:41:19 +02:00
|
|
|
strcatW(newStr,bkSlash);
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
for(j=i;j<=lastIdx2;j++)
|
2000-08-14 16:41:19 +02:00
|
|
|
strcatW(newStr,strDec2[j]);
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
/* create a new moniker with the new string */
|
|
|
|
res=CreateFileMoniker(newStr,ppmkComposite);
|
|
|
|
|
|
|
|
/* free all strings space memory used by this function */
|
|
|
|
HeapFree(GetProcessHeap(),0,newStr);
|
|
|
|
|
|
|
|
for(i=0; strDec1[i]!=NULL;i++)
|
|
|
|
CoTaskMemFree(strDec1[i]);
|
|
|
|
for(i=0; strDec2[i]!=NULL;i++)
|
|
|
|
CoTaskMemFree(strDec2[i]);
|
|
|
|
CoTaskMemFree(strDec1);
|
|
|
|
CoTaskMemFree(strDec2);
|
|
|
|
|
|
|
|
CoTaskMemFree(str1);
|
|
|
|
CoTaskMemFree(str2);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
else if(mkSys==MKSYS_ANTIMONIKER){
|
|
|
|
|
|
|
|
*ppmkComposite=NULL;
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
else if (fOnlyIfNotGeneric){
|
|
|
|
|
|
|
|
*ppmkComposite=NULL;
|
|
|
|
return MK_E_NEEDGENERIC;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
|
|
|
|
return CreateGenericComposite(iface,pmkRight,ppmkComposite);
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_Enum
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
if (ppenumMoniker == NULL)
|
|
|
|
return E_POINTER;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
*ppenumMoniker = NULL;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
return S_OK;
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_IsEqual
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
2004-09-09 23:03:58 +02:00
|
|
|
FileMonikerImpl *This = (FileMonikerImpl *)iface;
|
1999-03-23 14:48:56 +01:00
|
|
|
CLSID clsid;
|
|
|
|
LPOLESTR filePath;
|
|
|
|
IBindCtx* bind;
|
|
|
|
HRESULT res;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
if (pmkOtherMoniker==NULL)
|
|
|
|
return S_FALSE;
|
|
|
|
|
|
|
|
IMoniker_GetClassID(pmkOtherMoniker,&clsid);
|
|
|
|
|
|
|
|
if (!IsEqualCLSID(&clsid,&CLSID_FileMoniker))
|
|
|
|
return S_FALSE;
|
|
|
|
|
2002-07-16 03:43:24 +02:00
|
|
|
res = CreateBindCtx(0,&bind);
|
|
|
|
if (FAILED(res)) return res;
|
1999-03-23 14:48:56 +01:00
|
|
|
|
2002-07-16 03:43:24 +02:00
|
|
|
if (SUCCEEDED(IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&filePath))) {
|
|
|
|
int result = lstrcmpiW(filePath, This->filePathName);
|
|
|
|
CoTaskMemFree(filePath);
|
|
|
|
if ( result == 0 ) return S_OK;
|
|
|
|
}
|
|
|
|
return S_FALSE;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_Hash
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
2004-09-09 23:03:58 +02:00
|
|
|
FileMonikerImpl *This = (FileMonikerImpl *)iface;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
int h = 0,i,skip,len;
|
|
|
|
int off = 0;
|
|
|
|
LPOLESTR val;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
if (pdwHash==NULL)
|
|
|
|
return E_POINTER;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
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];
|
|
|
|
}
|
2001-09-11 02:32:32 +02:00
|
|
|
}
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
*pdwHash=h;
|
|
|
|
|
|
|
|
return S_OK;
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_IsRunning
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_IsRunning(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
|
|
|
|
IMoniker* pmkNewlyRunning)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
1999-03-23 14:48:56 +01:00
|
|
|
IRunningObjectTable* rot;
|
|
|
|
HRESULT res;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
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;
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_GetTimeOfLastChange
|
|
|
|
******************************************************************************/
|
2005-05-12 11:57:21 +02:00
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc,
|
|
|
|
IMoniker* pmkToLeft, FILETIME* pFileTime)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
2004-09-09 23:03:58 +02:00
|
|
|
FileMonikerImpl *This = (FileMonikerImpl *)iface;
|
1999-03-23 14:48:56 +01:00
|
|
|
IRunningObjectTable* rot;
|
|
|
|
HRESULT res;
|
|
|
|
WIN32_FILE_ATTRIBUTE_DATA info;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pFileTime);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
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);
|
|
|
|
|
2004-07-24 01:02:09 +02:00
|
|
|
if (FAILED(res)){ /* the moniker is not registered */
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
if (!GetFileAttributesExW(This->filePathName,GetFileExInfoStandard,&info))
|
|
|
|
return MK_E_NOOBJECT;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
*pFileTime=info.ftLastWriteTime;
|
2001-09-11 02:32:32 +02:00
|
|
|
}
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
return S_OK;
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_Inverse
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p,%p)\n",iface,ppmk);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
return CreateAntiMoniker(ppmk);
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_CommonPrefixWith
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
LPOLESTR pathThis,pathOther,*stringTable1,*stringTable2,commonPath;
|
|
|
|
IBindCtx *pbind;
|
|
|
|
DWORD mkSys;
|
|
|
|
ULONG nb1,nb2,i,sameIdx;
|
|
|
|
BOOL machimeNameCase=FALSE;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
if (ppmkPrefix==NULL)
|
|
|
|
return E_POINTER;
|
|
|
|
|
|
|
|
if (pmkOther==NULL)
|
|
|
|
return E_INVALIDARG;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
*ppmkPrefix=0;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
/* check if we have the same type of moniker */
|
|
|
|
IMoniker_IsSystemMoniker(pmkOther,&mkSys);
|
|
|
|
|
|
|
|
if(mkSys==MKSYS_FILEMONIKER){
|
2003-09-30 02:24:08 +02:00
|
|
|
HRESULT ret;
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
CreateBindCtx(0,&pbind);
|
|
|
|
|
|
|
|
/* create a string based on common part of the two paths */
|
|
|
|
|
|
|
|
IMoniker_GetDisplayName(iface,pbind,NULL,&pathThis);
|
|
|
|
IMoniker_GetDisplayName(pmkOther,pbind,NULL,&pathOther);
|
|
|
|
|
|
|
|
nb1=FileMonikerImpl_DecomposePath(pathThis,&stringTable1);
|
|
|
|
nb2=FileMonikerImpl_DecomposePath(pathOther,&stringTable2);
|
|
|
|
|
|
|
|
if (nb1==0 || nb2==0)
|
|
|
|
return MK_E_NOPREFIX;
|
|
|
|
|
|
|
|
commonPath=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(min(lstrlenW(pathThis),lstrlenW(pathOther))+1));
|
|
|
|
|
|
|
|
*commonPath=0;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
for(sameIdx=0; ( (stringTable1[sameIdx]!=NULL) &&
|
|
|
|
(stringTable2[sameIdx]!=NULL) &&
|
|
|
|
(lstrcmpiW(stringTable1[sameIdx],stringTable2[sameIdx])==0)); sameIdx++);
|
|
|
|
|
|
|
|
if (sameIdx > 1 && *stringTable1[0]=='\\' && *stringTable2[1]=='\\'){
|
|
|
|
|
|
|
|
machimeNameCase=TRUE;
|
|
|
|
|
|
|
|
for(i=2;i<sameIdx;i++)
|
|
|
|
|
|
|
|
if( (*stringTable1[i]=='\\') && (i+1 < sameIdx) && (*stringTable1[i+1]=='\\') ){
|
|
|
|
machimeNameCase=FALSE;
|
|
|
|
break;
|
2001-09-11 02:32:32 +02:00
|
|
|
}
|
1999-03-23 14:48:56 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (machimeNameCase && *stringTable1[sameIdx-1]=='\\')
|
|
|
|
sameIdx--;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
if (machimeNameCase && (sameIdx<=3) && (nb1 > 3 || nb2 > 3) )
|
2003-09-30 02:24:08 +02:00
|
|
|
ret = MK_E_NOPREFIX;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for(i=0;i<sameIdx;i++)
|
|
|
|
strcatW(commonPath,stringTable1[i]);
|
|
|
|
|
|
|
|
for(i=0;i<nb1;i++)
|
|
|
|
CoTaskMemFree(stringTable1[i]);
|
|
|
|
|
|
|
|
CoTaskMemFree(stringTable1);
|
|
|
|
|
|
|
|
for(i=0;i<nb2;i++)
|
|
|
|
CoTaskMemFree(stringTable2[i]);
|
|
|
|
|
|
|
|
CoTaskMemFree(stringTable2);
|
|
|
|
|
|
|
|
ret = CreateFileMoniker(commonPath,ppmkPrefix);
|
|
|
|
}
|
1999-03-23 14:48:56 +01:00
|
|
|
HeapFree(GetProcessHeap(),0,commonPath);
|
2003-09-30 02:24:08 +02:00
|
|
|
return ret;
|
1999-03-23 14:48:56 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
return MonikerCommonPrefixWith(iface,pmkOther,ppmkPrefix);
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* DecomposePath (local function)
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
int FileMonikerImpl_DecomposePath(LPCOLESTR str, LPOLESTR** stringTable)
|
1999-03-23 14:48:56 +01:00
|
|
|
{
|
2004-04-20 03:12:17 +02:00
|
|
|
static const WCHAR bSlash[] = {'\\',0};
|
2000-03-07 13:22:51 +01:00
|
|
|
WCHAR word[MAX_PATH];
|
1999-03-23 14:48:56 +01:00
|
|
|
int i=0,j,tabIndex=0;
|
|
|
|
LPOLESTR *strgtable ;
|
|
|
|
|
|
|
|
int len=lstrlenW(str);
|
|
|
|
|
2002-08-16 03:39:12 +02:00
|
|
|
TRACE("%s, %p\n", debugstr_w(str), *stringTable);
|
|
|
|
|
1999-04-25 21:01:52 +02:00
|
|
|
strgtable =CoTaskMemAlloc(len*sizeof(LPOLESTR));
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
if (strgtable==NULL)
|
|
|
|
return E_OUTOFMEMORY;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
while(str[i]!=0){
|
|
|
|
|
|
|
|
if(str[i]==bSlash[0]){
|
|
|
|
|
|
|
|
strgtable[tabIndex]=CoTaskMemAlloc(2*sizeof(WCHAR));
|
|
|
|
|
|
|
|
if (strgtable[tabIndex]==NULL)
|
|
|
|
return E_OUTOFMEMORY;
|
|
|
|
|
2000-08-14 16:41:19 +02:00
|
|
|
strcpyW(strgtable[tabIndex++],bSlash);
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
i++;
|
|
|
|
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
|
|
|
|
for(j=0; str[i]!=0 && str[i]!=bSlash[0] ; i++,j++)
|
|
|
|
word[j]=str[i];
|
|
|
|
|
|
|
|
word[j]=0;
|
|
|
|
|
|
|
|
strgtable[tabIndex]=CoTaskMemAlloc(sizeof(WCHAR)*(j+1));
|
|
|
|
|
|
|
|
if (strgtable[tabIndex]==NULL)
|
|
|
|
return E_OUTOFMEMORY;
|
|
|
|
|
2000-08-14 16:41:19 +02:00
|
|
|
strcpyW(strgtable[tabIndex++],word);
|
1999-03-23 14:48:56 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
strgtable[tabIndex]=NULL;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
*stringTable=strgtable;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
return tabIndex;
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_RelativePathTo
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
1999-03-23 14:48:56 +01:00
|
|
|
IBindCtx *bind;
|
|
|
|
HRESULT res;
|
|
|
|
LPOLESTR str1=0,str2=0,*tabStr1=0,*tabStr2=0,relPath=0;
|
|
|
|
DWORD len1=0,len2=0,sameIdx=0,j=0;
|
2004-04-20 03:12:17 +02:00
|
|
|
static const WCHAR back[] ={'.','.','\\',0};
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p,%p,%p)\n",iface,pmOther,ppmkRelPath);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
if (ppmkRelPath==NULL)
|
|
|
|
return E_POINTER;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
if (pmOther==NULL)
|
|
|
|
return E_INVALIDARG;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
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);
|
|
|
|
len2=FileMonikerImpl_DecomposePath(str2,&tabStr2);
|
|
|
|
|
|
|
|
if (FAILED(len1) || FAILED(len2))
|
|
|
|
return E_OUTOFMEMORY;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
/* 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=HeapAlloc(GetProcessHeap(),0,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]!='\\')
|
2000-08-14 16:41:19 +02:00
|
|
|
strcatW(relPath,back);
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
/* 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++)
|
2000-08-14 16:41:19 +02:00
|
|
|
strcatW(relPath,tabStr2[j]);
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
res=CreateFileMoniker(relPath,ppmkRelPath);
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
for(j=0; tabStr1[j]!=NULL;j++)
|
|
|
|
CoTaskMemFree(tabStr1[j]);
|
|
|
|
for(j=0; tabStr2[j]!=NULL;j++)
|
|
|
|
CoTaskMemFree(tabStr2[j]);
|
|
|
|
CoTaskMemFree(tabStr1);
|
|
|
|
CoTaskMemFree(tabStr2);
|
|
|
|
CoTaskMemFree(str1);
|
|
|
|
CoTaskMemFree(str2);
|
|
|
|
HeapFree(GetProcessHeap(),0,relPath);
|
|
|
|
|
|
|
|
if (len1==0 || len2==0 || (len1==1 && len2==1 && sameIdx==0))
|
|
|
|
return MK_S_HIM;
|
|
|
|
|
|
|
|
return res;
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_GetDisplayName
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_GetDisplayName(IMoniker* iface, IBindCtx* pbc,
|
|
|
|
IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
2004-09-09 23:03:58 +02:00
|
|
|
FileMonikerImpl *This = (FileMonikerImpl *)iface;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
int len=lstrlenW(This->filePathName);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName);
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
if (ppszDisplayName==NULL)
|
|
|
|
return E_POINTER;
|
|
|
|
|
|
|
|
if (pmkToLeft!=NULL)
|
|
|
|
return E_INVALIDARG;
|
|
|
|
|
|
|
|
*ppszDisplayName=CoTaskMemAlloc(sizeof(WCHAR)*(len+1));
|
|
|
|
if (*ppszDisplayName==NULL)
|
|
|
|
return E_OUTOFMEMORY;
|
|
|
|
|
2000-08-14 16:41:19 +02:00
|
|
|
strcpyW(*ppszDisplayName,This->filePathName);
|
2002-06-01 01:06:46 +02:00
|
|
|
|
2005-02-18 21:13:23 +01:00
|
|
|
TRACE("-- %s\n", debugstr_w(*ppszDisplayName));
|
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
return S_OK;
|
1999-01-28 18:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_ParseDisplayName
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_ParseDisplayName(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
|
|
|
|
LPOLESTR pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
1999-07-04 18:02:24 +02:00
|
|
|
FIXME("(%p,%p,%p,%p,%p,%p),stub!\n",iface,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
|
1999-01-28 18:56:14 +01:00
|
|
|
return E_NOTIMPL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
2001-04-20 20:36:05 +02:00
|
|
|
* FileMoniker_IsSystemMoniker
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
|
1999-02-18 14:26:22 +01:00
|
|
|
{
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p,%p)\n",iface,pwdMksys);
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
if (!pwdMksys)
|
|
|
|
return E_POINTER;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
(*pwdMksys)=MKSYS_FILEMONIKER;
|
|
|
|
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
* FileMonikerIROTData_QueryInterface
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerROTDataImpl_QueryInterface(IROTData *iface,REFIID riid,VOID** ppvObject)
|
1999-03-23 14:48:56 +01:00
|
|
|
{
|
|
|
|
|
|
|
|
ICOM_THIS_From_IROTData(IMoniker, iface);
|
|
|
|
|
2005-02-18 21:13:23 +01:00
|
|
|
TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppvObject);
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
return FileMonikerImpl_QueryInterface(This, riid, ppvObject);
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* FileMonikerIROTData_AddRef
|
|
|
|
*/
|
2005-05-12 11:57:21 +02:00
|
|
|
static ULONG WINAPI
|
|
|
|
FileMonikerROTDataImpl_AddRef(IROTData *iface)
|
1999-03-23 14:48:56 +01:00
|
|
|
{
|
|
|
|
ICOM_THIS_From_IROTData(IMoniker, iface);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p)\n",This);
|
1999-03-23 14:48:56 +01:00
|
|
|
|
2005-05-12 11:57:21 +02:00
|
|
|
return IMoniker_AddRef(This);
|
1999-03-23 14:48:56 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* FileMonikerIROTData_Release
|
|
|
|
*/
|
2005-05-12 11:57:21 +02:00
|
|
|
static ULONG WINAPI
|
|
|
|
FileMonikerROTDataImpl_Release(IROTData* iface)
|
1999-03-23 14:48:56 +01:00
|
|
|
{
|
|
|
|
ICOM_THIS_From_IROTData(IMoniker, iface);
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-07-04 18:02:24 +02:00
|
|
|
TRACE("(%p)\n",This);
|
1999-03-23 14:48:56 +01:00
|
|
|
|
|
|
|
return FileMonikerImpl_Release(This);
|
|
|
|
}
|
1999-01-28 18:56:14 +01:00
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
/******************************************************************************
|
|
|
|
* FileMonikerIROTData_GetComparaisonData
|
2005-05-12 11:57:21 +02:00
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerROTDataImpl_GetComparaisonData(IROTData* iface, BYTE* pbData,
|
|
|
|
ULONG cbMax, ULONG* pcbData)
|
1999-03-23 14:48:56 +01:00
|
|
|
{
|
1999-07-04 18:02:24 +02:00
|
|
|
FIXME("(),stub!\n");
|
1999-01-28 18:56:14 +01:00
|
|
|
return E_NOTIMPL;
|
|
|
|
}
|
|
|
|
|
2005-05-12 11:57:21 +02:00
|
|
|
/*
|
|
|
|
* Virtual function table for the FileMonikerImpl class which include IPersist,
|
|
|
|
* IPersistStream and IMoniker functions.
|
|
|
|
*/
|
|
|
|
static IMonikerVtbl VT_FileMonikerImpl =
|
|
|
|
{
|
|
|
|
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
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Virtual function table for the IROTData class. */
|
|
|
|
static IROTDataVtbl VT_ROTDataImpl =
|
|
|
|
{
|
|
|
|
FileMonikerROTDataImpl_QueryInterface,
|
|
|
|
FileMonikerROTDataImpl_AddRef,
|
|
|
|
FileMonikerROTDataImpl_Release,
|
|
|
|
FileMonikerROTDataImpl_GetComparaisonData
|
|
|
|
};
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* FileMoniker_Construct (local function)
|
|
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
|
|
FileMonikerImpl_Construct(FileMonikerImpl* This, LPCOLESTR lpszPathName)
|
|
|
|
{
|
|
|
|
int nb=0,i;
|
|
|
|
int sizeStr=lstrlenW(lpszPathName);
|
|
|
|
LPOLESTR *tabStr=0;
|
|
|
|
static const WCHAR twoPoint[]={'.','.',0};
|
|
|
|
static const WCHAR bkSlash[]={'\\',0};
|
|
|
|
BYTE addBkSlash;
|
|
|
|
|
|
|
|
TRACE("(%p,%s)\n",This,debugstr_w(lpszPathName));
|
|
|
|
|
|
|
|
/* Initialize the virtual fgunction table. */
|
|
|
|
This->lpvtbl1 = &VT_FileMonikerImpl;
|
|
|
|
This->lpvtbl2 = &VT_ROTDataImpl;
|
|
|
|
This->ref = 0;
|
|
|
|
|
|
|
|
This->filePathName=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(sizeStr+1));
|
|
|
|
|
|
|
|
if (This->filePathName==NULL)
|
|
|
|
return E_OUTOFMEMORY;
|
|
|
|
|
|
|
|
strcpyW(This->filePathName,lpszPathName);
|
|
|
|
|
|
|
|
nb=FileMonikerImpl_DecomposePath(This->filePathName,&tabStr);
|
|
|
|
|
|
|
|
if (nb > 0 ){
|
|
|
|
|
|
|
|
addBkSlash=1;
|
|
|
|
if (lstrcmpW(tabStr[0],twoPoint)!=0)
|
|
|
|
addBkSlash=0;
|
|
|
|
else
|
|
|
|
for(i=0;i<nb;i++){
|
|
|
|
|
|
|
|
if ( (lstrcmpW(tabStr[i],twoPoint)!=0) && (lstrcmpW(tabStr[i],bkSlash)!=0) ){
|
|
|
|
addBkSlash=0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
|
|
|
|
if (lstrcmpW(tabStr[i],bkSlash)==0 && i<nb-1 && lstrcmpW(tabStr[i+1],bkSlash)==0){
|
|
|
|
*tabStr[i]=0;
|
|
|
|
sizeStr--;
|
|
|
|
addBkSlash=0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lstrcmpW(tabStr[nb-1],bkSlash)==0)
|
|
|
|
addBkSlash=0;
|
|
|
|
|
|
|
|
This->filePathName=HeapReAlloc(GetProcessHeap(),0,This->filePathName,(sizeStr+1)*sizeof(WCHAR));
|
|
|
|
|
|
|
|
*This->filePathName=0;
|
|
|
|
|
|
|
|
for(i=0;tabStr[i]!=NULL;i++)
|
|
|
|
strcatW(This->filePathName,tabStr[i]);
|
|
|
|
|
|
|
|
if (addBkSlash)
|
|
|
|
strcatW(This->filePathName,bkSlash);
|
|
|
|
}
|
|
|
|
|
|
|
|
for(i=0; tabStr[i]!=NULL;i++)
|
|
|
|
CoTaskMemFree(tabStr[i]);
|
|
|
|
CoTaskMemFree(tabStr);
|
|
|
|
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
1999-01-28 18:56:14 +01:00
|
|
|
/******************************************************************************
|
2003-09-11 05:06:25 +02:00
|
|
|
* CreateFileMoniker (OLE32.@)
|
1999-01-28 18:56:14 +01:00
|
|
|
******************************************************************************/
|
1999-02-26 12:11:13 +01:00
|
|
|
HRESULT WINAPI CreateFileMoniker(LPCOLESTR lpszPathName, LPMONIKER * ppmk)
|
1999-01-28 18:56:14 +01:00
|
|
|
{
|
2005-02-18 21:13:23 +01:00
|
|
|
FileMonikerImpl* newFileMoniker;
|
|
|
|
HRESULT hr;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
2005-02-18 21:13:23 +01:00
|
|
|
TRACE("(%s,%p)\n",debugstr_w(lpszPathName),ppmk);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
2005-02-18 21:13:23 +01:00
|
|
|
if (!ppmk)
|
1999-03-23 14:48:56 +01:00
|
|
|
return E_POINTER;
|
|
|
|
|
2005-02-18 21:13:23 +01:00
|
|
|
if(!lpszPathName)
|
1999-03-23 14:48:56 +01:00
|
|
|
return MK_E_SYNTAX;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
2005-02-18 21:13:23 +01:00
|
|
|
*ppmk=NULL;
|
2002-06-01 01:06:46 +02:00
|
|
|
|
1999-01-28 18:56:14 +01:00
|
|
|
newFileMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(FileMonikerImpl));
|
|
|
|
|
2005-02-18 21:13:23 +01:00
|
|
|
if (!newFileMoniker)
|
1999-03-23 14:48:56 +01:00
|
|
|
return E_OUTOFMEMORY;
|
1999-01-28 18:56:14 +01:00
|
|
|
|
|
|
|
hr = FileMonikerImpl_Construct(newFileMoniker,lpszPathName);
|
|
|
|
|
1999-03-23 14:48:56 +01:00
|
|
|
if (SUCCEEDED(hr))
|
2005-02-18 21:13:23 +01:00
|
|
|
hr = FileMonikerImpl_QueryInterface((IMoniker*)newFileMoniker,&IID_IMoniker,(void**)ppmk);
|
1999-03-23 14:48:56 +01:00
|
|
|
else
|
|
|
|
HeapFree(GetProcessHeap(),0,newFileMoniker);
|
1999-01-28 18:56:14 +01:00
|
|
|
|
|
|
|
return hr;
|
|
|
|
}
|