Sweden-Number/dlls/ole32/itemmoniker.c

985 lines
33 KiB
C
Raw Normal View History

/*
* ItemMonikers implementation
*
* Copyright 1999 Noomen Hamza
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <assert.h>
#include <stdarg.h>
#include <string.h>
#define COBJMACROS
#define NONAMELESSUNION
#include "winerror.h"
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "winnls.h"
#include "wine/debug.h"
#include "ole2.h"
#include "moniker.h"
WINE_DEFAULT_DEBUG_CHANNEL(ole);
/* ItemMoniker data structure */
typedef struct ItemMonikerImpl{
2011-08-24 12:14:29 +02:00
IMoniker IMoniker_iface; /* VTable relative to the IMoniker interface.*/
IROTData IROTData_iface; /* VTable relative to the IROTData interface.*/
LONG ref;
LPOLESTR itemName; /* item name identified by this ItemMoniker */
LPOLESTR itemDelimiter; /* Delimiter string */
IUnknown *pMarshal; /* custom marshaler */
} ItemMonikerImpl;
2011-08-24 12:14:29 +02:00
static inline ItemMonikerImpl *impl_from_IMoniker(IMoniker *iface)
{
2011-08-24 12:14:29 +02:00
return CONTAINING_RECORD(iface, ItemMonikerImpl, IMoniker_iface);
}
static inline ItemMonikerImpl *impl_from_IROTData(IROTData *iface)
{
return CONTAINING_RECORD(iface, ItemMonikerImpl, IROTData_iface);
}
static HRESULT ItemMonikerImpl_Destroy(ItemMonikerImpl* iface);
/*******************************************************************************
* ItemMoniker_QueryInterface
*******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
{
2011-08-24 12:14:29 +02:00
ItemMonikerImpl *This = impl_from_IMoniker(iface);
TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppvObject);
if (!ppvObject)
return E_INVALIDARG;
2002-06-01 01:06:46 +02: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;
else if (IsEqualIID(&IID_IROTData, riid))
2011-08-24 12:14:29 +02:00
*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);
}
else
{
*ppvObject = NULL;
return E_NOINTERFACE;
}
2002-06-01 01:06:46 +02:00
IMoniker_AddRef(iface);
return S_OK;
}
/******************************************************************************
* ItemMoniker_AddRef
******************************************************************************/
static ULONG WINAPI ItemMonikerImpl_AddRef(IMoniker* iface)
{
2011-08-24 12:14:29 +02:00
ItemMonikerImpl *This = impl_from_IMoniker(iface);
TRACE("(%p)\n",This);
2004-09-24 03:16:53 +02:00
return InterlockedIncrement(&This->ref);
}
/******************************************************************************
* ItemMoniker_Release
******************************************************************************/
static ULONG WINAPI ItemMonikerImpl_Release(IMoniker* iface)
{
2011-08-24 12:14:29 +02:00
ItemMonikerImpl *This = impl_from_IMoniker(iface);
2004-09-24 03:16:53 +02:00
ULONG ref;
TRACE("(%p)\n",This);
2004-09-24 03:16:53 +02:00
ref = InterlockedDecrement(&This->ref);
2013-11-20 23:39:28 +01:00
/* destroy the object if there are no more references to it */
2004-09-24 03:16:53 +02:00
if (ref == 0) ItemMonikerImpl_Destroy(This);
2004-09-24 03:16:53 +02:00
return ref;
}
/******************************************************************************
* ItemMoniker_GetClassID
******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_GetClassID(IMoniker* iface,CLSID *pClassID)
{
TRACE("(%p,%p)\n",iface,pClassID);
if (pClassID==NULL)
return E_POINTER;
2002-06-01 01:06:46 +02:00
*pClassID = CLSID_ItemMoniker;
2002-06-01 01:06:46 +02:00
return S_OK;
}
/******************************************************************************
* ItemMoniker_IsDirty
******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_IsDirty(IMoniker* iface)
{
/* Note that the OLE-provided implementations of the IPersistStream::IsDirty
method in the OLE-provided moniker interfaces always return S_FALSE because
their internal state never changes. */
TRACE("(%p)\n",iface);
return S_FALSE;
}
/******************************************************************************
* ItemMoniker_Load
******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_Load(IMoniker* iface,IStream* pStm)
{
2011-08-24 12:14:29 +02:00
ItemMonikerImpl *This = impl_from_IMoniker(iface);
HRESULT res;
DWORD delimiterLength,nameLength,lenW;
CHAR *itemNameA,*itemDelimiterA;
ULONG bread;
TRACE("\n");
2008-04-09 21:33:37 +02:00
/* for more details about data read by this function see comments of ItemMonikerImpl_Save function */
/* read item delimiter string length + 1 */
res=IStream_Read(pStm,&delimiterLength,sizeof(DWORD),&bread);
if (bread != sizeof(DWORD))
return E_FAIL;
/* read item delimiter string */
if (!(itemDelimiterA=HeapAlloc(GetProcessHeap(),0,delimiterLength)))
return E_OUTOFMEMORY;
res=IStream_Read(pStm,itemDelimiterA,delimiterLength,&bread);
if (bread != delimiterLength)
{
HeapFree( GetProcessHeap(), 0, itemDelimiterA );
return E_FAIL;
}
lenW = MultiByteToWideChar( CP_ACP, 0, itemDelimiterA, -1, NULL, 0 );
This->itemDelimiter=HeapReAlloc(GetProcessHeap(),0,This->itemDelimiter,lenW*sizeof(WCHAR));
if (!This->itemDelimiter)
{
HeapFree( GetProcessHeap(), 0, itemDelimiterA );
return E_OUTOFMEMORY;
}
MultiByteToWideChar( CP_ACP, 0, itemDelimiterA, -1, This->itemDelimiter, lenW );
HeapFree( GetProcessHeap(), 0, itemDelimiterA );
/* read item name string length + 1*/
res=IStream_Read(pStm,&nameLength,sizeof(DWORD),&bread);
if (bread != sizeof(DWORD))
return E_FAIL;
/* read item name string */
if (!(itemNameA=HeapAlloc(GetProcessHeap(),0,nameLength)))
return E_OUTOFMEMORY;
res=IStream_Read(pStm,itemNameA,nameLength,&bread);
if (bread != nameLength)
{
HeapFree( GetProcessHeap(), 0, itemNameA );
return E_FAIL;
}
lenW = MultiByteToWideChar( CP_ACP, 0, itemNameA, -1, NULL, 0 );
This->itemName=HeapReAlloc(GetProcessHeap(),0,This->itemName,lenW*sizeof(WCHAR));
if (!This->itemName)
{
HeapFree( GetProcessHeap(), 0, itemNameA );
return E_OUTOFMEMORY;
}
MultiByteToWideChar( CP_ACP, 0, itemNameA, -1, This->itemName, lenW );
HeapFree( GetProcessHeap(), 0, itemNameA );
return res;
}
/******************************************************************************
* ItemMoniker_Save
******************************************************************************/
2011-08-24 12:14:29 +02:00
static HRESULT WINAPI ItemMonikerImpl_Save(IMoniker* iface, IStream* pStm, BOOL fClearDirty)
{
2011-08-24 12:14:29 +02:00
ItemMonikerImpl *This = impl_from_IMoniker(iface);
HRESULT res;
CHAR *itemNameA,*itemDelimiterA;
2003-06-18 05:30:39 +02:00
/* data written by this function are : 1) DWORD : size of item delimiter string ('\0' included ) */
/* 2) String (type A): item delimiter string ('\0' included) */
/* 3) DWORD : size of item name string ('\0' included) */
/* 4) String (type A): item name string ('\0' included) */
DWORD nameLength = WideCharToMultiByte( CP_ACP, 0, This->itemName, -1, NULL, 0, NULL, NULL);
DWORD delimiterLength = WideCharToMultiByte( CP_ACP, 0, This->itemDelimiter, -1, NULL, 0, NULL, NULL);
itemNameA=HeapAlloc(GetProcessHeap(),0,nameLength);
itemDelimiterA=HeapAlloc(GetProcessHeap(),0,delimiterLength);
WideCharToMultiByte( CP_ACP, 0, This->itemName, -1, itemNameA, nameLength, NULL, NULL);
WideCharToMultiByte( CP_ACP, 0, This->itemDelimiter, -1, itemDelimiterA, delimiterLength, NULL, NULL);
TRACE("%p, %s\n", pStm, fClearDirty ? "TRUE" : "FALSE");
res=IStream_Write(pStm,&delimiterLength,sizeof(DWORD),NULL);
res=IStream_Write(pStm,itemDelimiterA,delimiterLength * sizeof(CHAR),NULL);
res=IStream_Write(pStm,&nameLength,sizeof(DWORD),NULL);
res=IStream_Write(pStm,itemNameA,nameLength * sizeof(CHAR),NULL);
HeapFree(GetProcessHeap(), 0, itemNameA);
HeapFree(GetProcessHeap(), 0, itemDelimiterA);
return res;
}
/******************************************************************************
* ItemMoniker_GetSizeMax
******************************************************************************/
2011-08-24 12:14:29 +02:00
static HRESULT WINAPI ItemMonikerImpl_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize)
{
2011-08-24 12:14:29 +02:00
ItemMonikerImpl *This = impl_from_IMoniker(iface);
DWORD delimiterLength=lstrlenW(This->itemDelimiter)+1;
DWORD nameLength=lstrlenW(This->itemName)+1;
TRACE("(%p,%p)\n",iface,pcbSize);
if (!pcbSize)
return E_POINTER;
2008-04-09 21:33:37 +02:00
/* for more details see ItemMonikerImpl_Save comments */
2002-06-01 01:06:46 +02:00
pcbSize->u.LowPart = sizeof(DWORD) + /* DWORD which contains delimiter length */
delimiterLength*4 + /* item delimiter string */
2001-02-28 06:31:02 +01:00
sizeof(DWORD) + /* DWORD which contains item name length */
nameLength*4 + /* item name string */
18; /* strange, but true */
pcbSize->u.HighPart=0;
return S_OK;
}
/******************************************************************************
* ItemMoniker_BindToObject
******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_BindToObject(IMoniker* iface,
IBindCtx* pbc,
IMoniker* pmkToLeft,
REFIID riid,
VOID** ppvResult)
{
2011-08-24 12:14:29 +02:00
ItemMonikerImpl *This = impl_from_IMoniker(iface);
HRESULT res;
IID refid=IID_IOleItemContainer;
IOleItemContainer *poic=0;
TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
if(ppvResult ==NULL)
return E_POINTER;
if(pmkToLeft==NULL)
return E_INVALIDARG;
*ppvResult=0;
2004-05-21 22:52:57 +02:00
res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&refid,(void**)&poic);
if (SUCCEEDED(res)){
res=IOleItemContainer_GetObject(poic,This->itemName,BINDSPEED_MODERATE,pbc,riid,ppvResult);
IOleItemContainer_Release(poic);
}
return res;
}
/******************************************************************************
* ItemMoniker_BindToStorage
******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_BindToStorage(IMoniker* iface,
IBindCtx* pbc,
IMoniker* pmkToLeft,
REFIID riid,
VOID** ppvResult)
{
2011-08-24 12:14:29 +02:00
ItemMonikerImpl *This = impl_from_IMoniker(iface);
HRESULT res;
IOleItemContainer *poic=0;
TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
*ppvResult=0;
if(pmkToLeft==NULL)
return E_INVALIDARG;
2002-06-01 01:06:46 +02:00
2004-05-21 22:52:57 +02:00
res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IOleItemContainer,(void**)&poic);
if (SUCCEEDED(res)){
res=IOleItemContainer_GetObjectStorage(poic,This->itemName,pbc,riid,ppvResult);
IOleItemContainer_Release(poic);
}
return res;
}
/******************************************************************************
* ItemMoniker_Reduce
******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_Reduce(IMoniker* iface,
IBindCtx* pbc,
DWORD dwReduceHowFar,
IMoniker** ppmkToLeft,
IMoniker** ppmkReduced)
{
TRACE("(%p,%p,%d,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
if (ppmkReduced==NULL)
return E_POINTER;
ItemMonikerImpl_AddRef(iface);
*ppmkReduced=iface;
2002-06-01 01:06:46 +02:00
return MK_S_REDUCED_TO_SELF;
}
/******************************************************************************
* ItemMoniker_ComposeWith
******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_ComposeWith(IMoniker* iface,
IMoniker* pmkRight,
BOOL fOnlyIfNotGeneric,
IMoniker** ppmkComposite)
{
HRESULT res=S_OK;
DWORD mkSys,mkSys2;
IEnumMoniker* penumMk=0;
IMoniker *pmostLeftMk=0;
IMoniker* tempMkComposite=0;
TRACE("(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
if ((ppmkComposite==NULL)||(pmkRight==NULL))
return E_POINTER;
*ppmkComposite=0;
2002-06-01 01:06:46 +02:00
IMoniker_IsSystemMoniker(pmkRight,&mkSys);
/* If pmkRight is an anti-moniker, the returned moniker is NULL */
if(mkSys==MKSYS_ANTIMONIKER)
return res;
else
/* if pmkRight is a composite whose leftmost component is an anti-moniker, */
/* the returned moniker is the composite after the leftmost anti-moniker is removed. */
2002-06-01 01:06:46 +02:00
if(mkSys==MKSYS_GENERICCOMPOSITE){
res=IMoniker_Enum(pmkRight,TRUE,&penumMk);
if (FAILED(res))
return res;
res=IEnumMoniker_Next(penumMk,1,&pmostLeftMk,NULL);
IMoniker_IsSystemMoniker(pmostLeftMk,&mkSys2);
if(mkSys2==MKSYS_ANTIMONIKER){
IMoniker_Release(pmostLeftMk);
tempMkComposite=iface;
IMoniker_AddRef(iface);
2002-06-01 01:06:46 +02:00
while(IEnumMoniker_Next(penumMk,1,&pmostLeftMk,NULL)==S_OK){
res=CreateGenericComposite(tempMkComposite,pmostLeftMk,ppmkComposite);
IMoniker_Release(tempMkComposite);
IMoniker_Release(pmostLeftMk);
tempMkComposite=*ppmkComposite;
IMoniker_AddRef(tempMkComposite);
}
return res;
}
else
return CreateGenericComposite(iface,pmkRight,ppmkComposite);
}
/* If pmkRight is not an anti-moniker, the method combines the two monikers into a generic
composite if fOnlyIfNotGeneric is FALSE; if fOnlyIfNotGeneric is TRUE, the method returns
a NULL moniker and a return value of MK_E_NEEDGENERIC */
else
if (!fOnlyIfNotGeneric)
return CreateGenericComposite(iface,pmkRight,ppmkComposite);
else
return MK_E_NEEDGENERIC;
}
/******************************************************************************
* ItemMoniker_Enum
******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
{
TRACE("(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
if (ppenumMoniker == NULL)
return E_POINTER;
*ppenumMoniker = NULL;
return S_OK;
}
/******************************************************************************
* ItemMoniker_IsEqual
******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
{
CLSID clsid;
LPOLESTR dispName1,dispName2;
IBindCtx* bind;
HRESULT res = S_FALSE;
TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
if (!pmkOtherMoniker) return S_FALSE;
2002-06-01 01:06:46 +02:00
/* check if both are ItemMoniker */
if(FAILED (IMoniker_GetClassID(pmkOtherMoniker,&clsid))) return S_FALSE;
if(!IsEqualCLSID(&clsid,&CLSID_ItemMoniker)) return S_FALSE;
2002-06-01 01:06:46 +02:00
/* check if both displaynames are the same */
if(SUCCEEDED ((res = CreateBindCtx(0,&bind)))) {
if(SUCCEEDED (IMoniker_GetDisplayName(iface,bind,NULL,&dispName1))) {
if(SUCCEEDED (IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&dispName2))) {
if(wcscmp(dispName1,dispName2)==0) res = S_OK;
CoTaskMemFree(dispName2);
}
CoTaskMemFree(dispName1);
}
}
return res;
}
/******************************************************************************
* ItemMoniker_Hash
******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
{
2011-08-24 12:14:29 +02:00
ItemMonikerImpl *This = impl_from_IMoniker(iface);
DWORD h = 0;
int i,len;
int off = 0;
LPOLESTR val;
if (pdwHash==NULL)
return E_POINTER;
2002-06-01 01:06:46 +02:00
val = This->itemName;
len = lstrlenW(val);
for (i = len ; i > 0; i--)
h = (h * 3) ^ towupper(val[off++]);
*pdwHash=h;
return S_OK;
}
/******************************************************************************
* ItemMoniker_IsRunning
******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_IsRunning(IMoniker* iface,
IBindCtx* pbc,
IMoniker* pmkToLeft,
IMoniker* pmkNewlyRunning)
{
2011-08-24 12:14:29 +02:00
ItemMonikerImpl *This = impl_from_IMoniker(iface);
IRunningObjectTable* rot;
HRESULT res;
IOleItemContainer *poic=0;
TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
/* If pmkToLeft is NULL, this method returns TRUE if pmkNewlyRunning is non-NULL and is equal to this */
/* moniker. Otherwise, the method checks the ROT to see whether this moniker is running. */
if (pmkToLeft==NULL)
if ((pmkNewlyRunning!=NULL)&&(IMoniker_IsEqual(pmkNewlyRunning,iface)==S_OK))
return S_OK;
else {
if (pbc==NULL)
return E_INVALIDARG;
res=IBindCtx_GetRunningObjectTable(pbc,&rot);
if (FAILED(res))
return res;
res = IRunningObjectTable_IsRunning(rot,iface);
IRunningObjectTable_Release(rot);
}
else{
/* If pmkToLeft is non-NULL, the method calls IMoniker::BindToObject on the pmkToLeft parameter, */
/* requesting an IOleItemContainer interface pointer. The method then calls IOleItemContainer::IsRunning,*/
/* passing the string contained within this moniker. */
2002-06-01 01:06:46 +02:00
2004-05-21 22:52:57 +02:00
res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IOleItemContainer,(void**)&poic);
if (SUCCEEDED(res)){
res=IOleItemContainer_IsRunning(poic,This->itemName);
IOleItemContainer_Release(poic);
}
}
return res;
}
/******************************************************************************
* ItemMoniker_GetTimeOfLastChange
******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_GetTimeOfLastChange(IMoniker* iface,
IBindCtx* pbc,
IMoniker* pmkToLeft,
FILETIME* pItemTime)
{
IRunningObjectTable* rot;
HRESULT res;
IMoniker *compositeMk;
TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pItemTime);
if (pItemTime==NULL)
return E_INVALIDARG;
/* If pmkToLeft is NULL, this method returns MK_E_NOTBINDABLE */
if (pmkToLeft==NULL)
return MK_E_NOTBINDABLE;
else {
/* Otherwise, the method creates a composite of pmkToLeft and this moniker and uses the ROT to access */
/* the time of last change. If the object is not in the ROT, the method calls */
/* IMoniker::GetTimeOfLastChange on the pmkToLeft parameter. */
res=CreateGenericComposite(pmkToLeft,iface,&compositeMk);
if (FAILED(res))
return res;
res=IBindCtx_GetRunningObjectTable(pbc,&rot);
if (FAILED(res)) {
IMoniker_Release(compositeMk);
return res;
}
if (IRunningObjectTable_GetTimeOfLastChange(rot,compositeMk,pItemTime)!=S_OK)
res=IMoniker_GetTimeOfLastChange(pmkToLeft,pbc,NULL,pItemTime);
IMoniker_Release(compositeMk);
}
return res;
}
/******************************************************************************
* ItemMoniker_Inverse
******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
{
TRACE("(%p,%p)\n",iface,ppmk);
if (ppmk==NULL)
return E_POINTER;
return CreateAntiMoniker(ppmk);
}
/******************************************************************************
* ItemMoniker_CommonPrefixWith
******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
{
DWORD mkSys;
TRACE("(%p,%p)\n", pmkOther, ppmkPrefix);
IMoniker_IsSystemMoniker(pmkOther,&mkSys);
/* If the other moniker is an item moniker that is equal to this moniker, this method sets *ppmkPrefix */
/* to this moniker and returns MK_S_US */
if((mkSys==MKSYS_ITEMMONIKER) && (IMoniker_IsEqual(iface,pmkOther)==S_OK) ){
*ppmkPrefix=iface;
2002-06-01 01:06:46 +02:00
IMoniker_AddRef(iface);
2002-06-01 01:06:46 +02:00
return MK_S_US;
}
else
/* otherwise, the method calls the MonikerCommonPrefixWith function. This function correctly handles */
/* the case where the other moniker is a generic composite. */
return MonikerCommonPrefixWith(iface,pmkOther,ppmkPrefix);
}
/******************************************************************************
* ItemMoniker_RelativePathTo
******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
{
TRACE("(%p,%p,%p)\n",iface,pmOther,ppmkRelPath);
if (ppmkRelPath==NULL)
return E_POINTER;
*ppmkRelPath=0;
2002-06-01 01:06:46 +02:00
return MK_E_NOTBINDABLE;
}
/******************************************************************************
* ItemMoniker_GetDisplayName
******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_GetDisplayName(IMoniker* iface,
IBindCtx* pbc,
IMoniker* pmkToLeft,
LPOLESTR *ppszDisplayName)
{
2011-08-24 12:14:29 +02:00
ItemMonikerImpl *This = impl_from_IMoniker(iface);
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)*(lstrlenW(This->itemDelimiter)+lstrlenW(This->itemName)+1));
if (*ppszDisplayName==NULL)
return E_OUTOFMEMORY;
lstrcpyW(*ppszDisplayName,This->itemDelimiter);
lstrcatW(*ppszDisplayName,This->itemName);
2002-06-01 01:06:46 +02:00
TRACE("-- %s\n", debugstr_w(*ppszDisplayName));
return S_OK;
}
/******************************************************************************
* ItemMoniker_ParseDisplayName
******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_ParseDisplayName(IMoniker* iface,
IBindCtx* pbc,
IMoniker* pmkToLeft,
LPOLESTR pszDisplayName,
ULONG* pchEaten,
IMoniker** ppmkOut)
{
2011-08-24 12:14:29 +02:00
ItemMonikerImpl *This = impl_from_IMoniker(iface);
IOleItemContainer* poic=0;
IParseDisplayName* ppdn=0;
LPOLESTR displayName;
HRESULT res;
TRACE("%s\n", debugstr_w(pszDisplayName));
/* If pmkToLeft is NULL, this method returns MK_E_SYNTAX */
if (pmkToLeft==NULL)
return MK_E_SYNTAX;
else{
/* Otherwise, the method calls IMoniker::BindToObject on the pmkToLeft parameter, requesting an */
/* IParseDisplayName interface pointer to the object identified by the moniker, and passes the display */
/* name to IParseDisplayName::ParseDisplayName */
2004-05-21 22:52:57 +02:00
res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IOleItemContainer,(void**)&poic);
if (SUCCEEDED(res)){
2004-05-21 22:52:57 +02:00
res=IOleItemContainer_GetObject(poic,This->itemName,BINDSPEED_MODERATE,pbc,&IID_IParseDisplayName,(void**)&ppdn);
res=IMoniker_GetDisplayName(iface,pbc,NULL,&displayName);
res=IParseDisplayName_ParseDisplayName(ppdn,pbc,displayName,pchEaten,ppmkOut);
IOleItemContainer_Release(poic);
IParseDisplayName_Release(ppdn);
}
}
return res;
}
/******************************************************************************
2001-04-20 20:36:05 +02:00
* ItemMoniker_IsSystemMoniker
******************************************************************************/
static HRESULT WINAPI ItemMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
{
TRACE("(%p,%p)\n",iface,pwdMksys);
if (!pwdMksys)
return E_POINTER;
2002-06-01 01:06:46 +02:00
(*pwdMksys)=MKSYS_ITEMMONIKER;
return S_OK;
}
/*******************************************************************************
* ItemMonikerIROTData_QueryInterface
*******************************************************************************/
2011-08-24 12:14:29 +02:00
static HRESULT WINAPI ItemMonikerROTDataImpl_QueryInterface(IROTData *iface,REFIID riid,
void **ppvObject)
{
2011-08-24 12:14:29 +02:00
ItemMonikerImpl *This = impl_from_IROTData(iface);
TRACE("(%p,%s,%p)\n",iface,debugstr_guid(riid),ppvObject);
2011-08-24 12:14:29 +02:00
return ItemMonikerImpl_QueryInterface(&This->IMoniker_iface, riid, ppvObject);
}
/***********************************************************************
* ItemMonikerIROTData_AddRef
*/
static ULONG WINAPI ItemMonikerROTDataImpl_AddRef(IROTData *iface)
{
2011-08-24 12:14:29 +02:00
ItemMonikerImpl *This = impl_from_IROTData(iface);
TRACE("(%p)\n",iface);
2011-08-24 12:14:29 +02:00
return ItemMonikerImpl_AddRef(&This->IMoniker_iface);
}
/***********************************************************************
* ItemMonikerIROTData_Release
*/
static ULONG WINAPI ItemMonikerROTDataImpl_Release(IROTData* iface)
{
2011-08-24 12:14:29 +02:00
ItemMonikerImpl *This = impl_from_IROTData(iface);
2002-06-01 01:06:46 +02:00
TRACE("(%p)\n",iface);
2011-08-24 12:14:29 +02:00
return ItemMonikerImpl_Release(&This->IMoniker_iface);
}
/******************************************************************************
* ItemMonikerIROTData_GetComparisonData
******************************************************************************/
static HRESULT WINAPI ItemMonikerROTDataImpl_GetComparisonData(IROTData* iface,
BYTE* pbData,
ULONG cbMax,
ULONG* pcbData)
{
2011-08-24 12:14:29 +02:00
ItemMonikerImpl *This = impl_from_IROTData(iface);
int len = (lstrlenW(This->itemName)+1);
int i;
LPWSTR pszItemName;
LPWSTR pszItemDelimiter;
TRACE("(%p, %u, %p)\n", pbData, cbMax, pcbData);
*pcbData = sizeof(CLSID) + sizeof(WCHAR) + len * sizeof(WCHAR);
if (cbMax < *pcbData)
return E_OUTOFMEMORY;
/* write CLSID */
memcpy(pbData, &CLSID_ItemMoniker, sizeof(CLSID));
/* write delimiter */
pszItemDelimiter = (LPWSTR)(pbData+sizeof(CLSID));
2011-08-24 12:14:29 +02:00
*pszItemDelimiter = *This->itemDelimiter;
/* write name */
pszItemName = pszItemDelimiter + 1;
for (i = 0; i < len; i++)
pszItemName[i] = towupper(This->itemName[i]);
return S_OK;
}
/********************************************************************************/
/* Virtual function table for the ItemMonikerImpl class which include IPersist,*/
/* IPersistStream and IMoniker functions. */
static const IMonikerVtbl VT_ItemMonikerImpl =
{
ItemMonikerImpl_QueryInterface,
ItemMonikerImpl_AddRef,
ItemMonikerImpl_Release,
ItemMonikerImpl_GetClassID,
ItemMonikerImpl_IsDirty,
ItemMonikerImpl_Load,
ItemMonikerImpl_Save,
ItemMonikerImpl_GetSizeMax,
ItemMonikerImpl_BindToObject,
ItemMonikerImpl_BindToStorage,
ItemMonikerImpl_Reduce,
ItemMonikerImpl_ComposeWith,
ItemMonikerImpl_Enum,
ItemMonikerImpl_IsEqual,
ItemMonikerImpl_Hash,
ItemMonikerImpl_IsRunning,
ItemMonikerImpl_GetTimeOfLastChange,
ItemMonikerImpl_Inverse,
ItemMonikerImpl_CommonPrefixWith,
ItemMonikerImpl_RelativePathTo,
ItemMonikerImpl_GetDisplayName,
ItemMonikerImpl_ParseDisplayName,
ItemMonikerImpl_IsSystemMoniker
};
/********************************************************************************/
/* Virtual function table for the IROTData class. */
static const IROTDataVtbl VT_ROTDataImpl =
{
ItemMonikerROTDataImpl_QueryInterface,
ItemMonikerROTDataImpl_AddRef,
ItemMonikerROTDataImpl_Release,
ItemMonikerROTDataImpl_GetComparisonData
};
/******************************************************************************
* ItemMoniker_Construct (local function)
*******************************************************************************/
static HRESULT ItemMonikerImpl_Construct(ItemMonikerImpl* This, LPCOLESTR lpszDelim,LPCOLESTR lpszItem)
{
int sizeStr1=lstrlenW(lpszItem), sizeStr2;
static const OLECHAR emptystr[1];
LPCOLESTR delim;
TRACE("(%p,%s,%s)\n",This,debugstr_w(lpszDelim),debugstr_w(lpszItem));
/* Initialize the virtual function table. */
2011-08-24 12:14:29 +02:00
This->IMoniker_iface.lpVtbl = &VT_ItemMonikerImpl;
This->IROTData_iface.lpVtbl = &VT_ROTDataImpl;
This->ref = 0;
This->pMarshal = NULL;
This->itemName=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(sizeStr1+1));
if (!This->itemName)
return E_OUTOFMEMORY;
lstrcpyW(This->itemName,lpszItem);
if (!lpszDelim)
FIXME("lpszDelim is NULL. Using empty string which is possibly wrong.\n");
delim = lpszDelim ? lpszDelim : emptystr;
sizeStr2=lstrlenW(delim);
This->itemDelimiter=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(sizeStr2+1));
if (!This->itemDelimiter) {
HeapFree(GetProcessHeap(),0,This->itemName);
return E_OUTOFMEMORY;
}
lstrcpyW(This->itemDelimiter,delim);
return S_OK;
}
/******************************************************************************
* ItemMoniker_Destroy (local function)
*******************************************************************************/
static HRESULT ItemMonikerImpl_Destroy(ItemMonikerImpl* This)
{
TRACE("(%p)\n",This);
if (This->pMarshal) IUnknown_Release(This->pMarshal);
HeapFree(GetProcessHeap(),0,This->itemName);
HeapFree(GetProcessHeap(),0,This->itemDelimiter);
HeapFree(GetProcessHeap(),0,This);
return S_OK;
}
/******************************************************************************
2003-09-11 05:06:25 +02:00
* CreateItemMoniker [OLE32.@]
******************************************************************************/
2011-08-24 12:14:29 +02:00
HRESULT WINAPI CreateItemMoniker(LPCOLESTR lpszDelim, LPCOLESTR lpszItem, IMoniker **ppmk)
{
ItemMonikerImpl* newItemMoniker;
HRESULT hr;
TRACE("(%s,%s,%p)\n",debugstr_w(lpszDelim),debugstr_w(lpszItem),ppmk);
newItemMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(ItemMonikerImpl));
if (!newItemMoniker)
return STG_E_INSUFFICIENTMEMORY;
hr = ItemMonikerImpl_Construct(newItemMoniker,lpszDelim,lpszItem);
if (FAILED(hr)){
HeapFree(GetProcessHeap(),0,newItemMoniker);
return hr;
}
2011-08-24 12:14:29 +02:00
return ItemMonikerImpl_QueryInterface(&newItemMoniker->IMoniker_iface,&IID_IMoniker,
(void**)ppmk);
}
HRESULT WINAPI ItemMoniker_CreateInstance(IClassFactory *iface,
IUnknown *pUnk, REFIID riid, void **ppv)
{
ItemMonikerImpl* newItemMoniker;
HRESULT hr;
static const WCHAR wszEmpty[] = { 0 };
TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
*ppv = NULL;
if (pUnk)
return CLASS_E_NOAGGREGATION;
newItemMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(ItemMonikerImpl));
if (!newItemMoniker)
return E_OUTOFMEMORY;
hr = ItemMonikerImpl_Construct(newItemMoniker, wszEmpty, wszEmpty);
if (SUCCEEDED(hr))
2011-08-24 12:14:29 +02:00
hr = ItemMonikerImpl_QueryInterface(&newItemMoniker->IMoniker_iface, riid, ppv);
if (FAILED(hr))
HeapFree(GetProcessHeap(),0,newItemMoniker);
return hr;
}