ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Modified so that they do not use the VTABLE_FUNC macros that performed 

casts of all methods put in the jump table. I find it too risky to use
such macros because nothing guarantees that you actually put the right
method at the right place or that the prototype is right.
This commit is contained in:
Francois Gouget 1999-02-18 13:26:22 +00:00 committed by Alexandre Julliard
parent d04d2f1474
commit b0c61294ba
7 changed files with 617 additions and 497 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
dlls/shell32/shelllink.c
View File

@ -48,7 +48,7 @@ LPPERSISTFILE IPersistFile_Constructor(void)
* IPersistFile_QueryInterface
*/
static HRESULT WINAPI IPersistFile_fnQueryInterface(
LPUNKNOWN iface, REFIID riid, LPVOID *ppvObj)
IPersistFile* iface, REFIID riid, LPVOID *ppvObj)
{
ICOM_THIS(IPersistFileImpl,iface);
char xriid[50];
@ -75,7 +75,7 @@ static HRESULT WINAPI IPersistFile_fnQueryInterface(
/******************************************************************************
* IPersistFile_AddRef
*/
static ULONG WINAPI IPersistFile_fnAddRef(LPUNKNOWN iface)
static ULONG WINAPI IPersistFile_fnAddRef(IPersistFile* iface)
{
ICOM_THIS(IPersistFileImpl,iface);
TRACE(shell,"(%p)->(count=%lu)\n",This,This->ref);
@ -86,7 +86,7 @@ static ULONG WINAPI IPersistFile_fnAddRef(LPUNKNOWN iface)
/******************************************************************************
* IPersistFile_Release
*/
static ULONG WINAPI IPersistFile_fnRelease(LPUNKNOWN iface)
static ULONG WINAPI IPersistFile_fnRelease(IPersistFile* iface)
{
ICOM_THIS(IPersistFileImpl,iface);
TRACE(shell,"(%p)->(count=%lu)\n",This,This->ref);
@ -101,7 +101,7 @@ static ULONG WINAPI IPersistFile_fnRelease(LPUNKNOWN iface)
return This->ref;
}
static HRESULT WINAPI IPersistFile_fnGetClassID(const IPersist* iface, CLSID *pClassID)
static HRESULT WINAPI IPersistFile_fnGetClassID(const IPersistFile* iface, CLSID *pClassID)
{
ICOM_CTHIS(IPersistFile,iface);
FIXME(shell,"(%p)\n",This);
@ -140,14 +140,10 @@ static HRESULT WINAPI IPersistFile_fnGetCurFile(const IPersistFile* iface, LPOLE
static struct ICOM_VTABLE(IPersistFile) pfvt =
{
{
{
IPersistFile_fnQueryInterface,
IPersistFile_fnAddRef,
IPersistFile_fnRelease
},
IPersistFile_fnGetClassID
},
IPersistFile_fnQueryInterface,
IPersistFile_fnAddRef,
IPersistFile_fnRelease,
IPersistFile_fnGetClassID,
IPersistFile_fnIsDirty,
IPersistFile_fnLoad,
IPersistFile_fnSave,

152
ole/bindctx.c
View File

@ -24,50 +24,50 @@ typedef struct BindCtxImpl{
} BindCtxImpl;
HRESULT WINAPI BindCtxImpl_QueryInterface(BindCtxImpl* This,REFIID riid,void** ppvObject);
ULONG WINAPI BindCtxImpl_AddRef(BindCtxImpl* This);
ULONG WINAPI BindCtxImpl_Release(BindCtxImpl* This);
HRESULT WINAPI BindCtxImpl_Construct(BindCtxImpl* This);
HRESULT WINAPI BindCtxImpl_destroy(BindCtxImpl* This);
HRESULT WINAPI BindCtxImpl_RegisterObjectBound(BindCtxImpl* This,IUnknown* punk);
HRESULT WINAPI BindCtxImpl_RevokeObjectBound(BindCtxImpl* This, IUnknown* punk);
HRESULT WINAPI BindCtxImpl_ReleaseObjects(BindCtxImpl* This);
HRESULT WINAPI BindCtxImpl_SetBindOptions(BindCtxImpl* This,LPBIND_OPTS2 pbindopts);
HRESULT WINAPI BindCtxImpl_GetBindOptions(BindCtxImpl* This,LPBIND_OPTS2 pbindopts);
HRESULT WINAPI BindCtxImpl_GetRunningObjectTable(BindCtxImpl* This,IRunningObjectTable** pprot);
HRESULT WINAPI BindCtxImpl_RegisterObjectParam(BindCtxImpl* This,LPOLESTR32 pszkey, IUnknown* punk);
HRESULT WINAPI BindCtxImpl_GetObjectParam(BindCtxImpl* This,LPOLESTR32 pszkey, IUnknown* punk);
HRESULT WINAPI BindCtxImpl_EnumObjectParam(BindCtxImpl* This,IEnumString** ppenum);
HRESULT WINAPI BindCtxImpl_RevokeObjectParam(BindCtxImpl* This,LPOLESTR32 pszkey);
HRESULT WINAPI BindCtxImpl_QueryInterface(IBindCtx* iface,REFIID riid,void** ppvObject);
ULONG WINAPI BindCtxImpl_AddRef(IBindCtx* iface);
ULONG WINAPI BindCtxImpl_Release(IBindCtx* iface);
HRESULT WINAPI BindCtxImpl_RegisterObjectBound(IBindCtx* iface,IUnknown* punk);
HRESULT WINAPI BindCtxImpl_RevokeObjectBound(IBindCtx* iface, IUnknown* punk);
HRESULT WINAPI BindCtxImpl_ReleaseObjects(IBindCtx* iface);
HRESULT WINAPI BindCtxImpl_SetBindOptions(IBindCtx* iface,LPBIND_OPTS2 pbindopts);
HRESULT WINAPI BindCtxImpl_GetBindOptions(IBindCtx* iface,LPBIND_OPTS2 pbindopts);
HRESULT WINAPI BindCtxImpl_GetRunningObjectTable(IBindCtx* iface,IRunningObjectTable** pprot);
HRESULT WINAPI BindCtxImpl_RegisterObjectParam(IBindCtx* iface,LPOLESTR32 pszkey, IUnknown* punk);
HRESULT WINAPI BindCtxImpl_GetObjectParam(IBindCtx* iface,LPOLESTR32 pszkey, IUnknown* punk);
HRESULT WINAPI BindCtxImpl_EnumObjectParam(IBindCtx* iface,IEnumString** ppenum);
HRESULT WINAPI BindCtxImpl_RevokeObjectParam(IBindCtx* iface,LPOLESTR32 pszkey);
HRESULT WINAPI CreateBindCtx16(DWORD reserved, LPBC * ppbc);
HRESULT WINAPI CreateBindCtx32(DWORD reserved, LPBC * ppbc);
#define VTABLE_FUNC(a) (void*)(a)
HRESULT WINAPI BindCtxImpl_Construct(BindCtxImpl* This);
HRESULT WINAPI BindCtxImpl_Destroy(BindCtxImpl* This);
// Virtual function table for the BindCtx class.
static ICOM_VTABLE(IBindCtx) VT_BindCtxImpl =
{
{
VTABLE_FUNC(BindCtxImpl_QueryInterface),
VTABLE_FUNC(BindCtxImpl_AddRef),
VTABLE_FUNC(BindCtxImpl_Release)
},
VTABLE_FUNC(BindCtxImpl_RegisterObjectBound),
VTABLE_FUNC(BindCtxImpl_RevokeObjectBound),
VTABLE_FUNC(BindCtxImpl_ReleaseObjects),
VTABLE_FUNC(BindCtxImpl_SetBindOptions),
VTABLE_FUNC(BindCtxImpl_GetBindOptions),
VTABLE_FUNC(BindCtxImpl_GetRunningObjectTable),
VTABLE_FUNC(BindCtxImpl_RegisterObjectParam),
VTABLE_FUNC(BindCtxImpl_GetObjectParam),
VTABLE_FUNC(BindCtxImpl_EnumObjectParam),
VTABLE_FUNC(BindCtxImpl_RevokeObjectParam)
BindCtxImpl_QueryInterface,
BindCtxImpl_AddRef,
BindCtxImpl_Release,
BindCtxImpl_RegisterObjectBound,
BindCtxImpl_RevokeObjectBound,
BindCtxImpl_ReleaseObjects,
BindCtxImpl_SetBindOptions,
BindCtxImpl_GetBindOptions,
BindCtxImpl_GetRunningObjectTable,
BindCtxImpl_RegisterObjectParam,
BindCtxImpl_GetObjectParam,
BindCtxImpl_EnumObjectParam,
BindCtxImpl_RevokeObjectParam
};
/*******************************************************************************
* BindCtx_QueryInterface
*******************************************************************************/
HRESULT WINAPI BindCtxImpl_QueryInterface(BindCtxImpl* This,REFIID riid,void** ppvObject){
HRESULT WINAPI BindCtxImpl_QueryInterface(IBindCtx* iface,REFIID riid,void** ppvObject)
{
ICOM_THIS(BindCtxImpl,iface);
TRACE(ole,"(%p,%p,%p)\n",This,riid,ppvObject);
// Perform a sanity check on the parameters.
if ( (This==0) || (ppvObject==0) ) return E_INVALIDARG;
@ -86,7 +86,7 @@ HRESULT WINAPI BindCtxImpl_QueryInterface(BindCtxImpl* This,REFIID riid,void** p
if ((*ppvObject)==0) return E_NOINTERFACE;
// Query Interface always increases the reference count by one when it is successful
BindCtxImpl_AddRef(This);
BindCtxImpl_AddRef(iface);
return S_OK;
}
@ -94,8 +94,9 @@ HRESULT WINAPI BindCtxImpl_QueryInterface(BindCtxImpl* This,REFIID riid,void** p
/******************************************************************************
* BindCtx_ _AddRef
******************************************************************************/
ULONG WINAPI BindCtxImpl_AddRef(BindCtxImpl* This){
ULONG WINAPI BindCtxImpl_AddRef(IBindCtx* iface)
{
ICOM_THIS(BindCtxImpl,iface);
TRACE(ole,"(%p)\n",This);
return ++(This->ref);
@ -104,14 +105,15 @@ ULONG WINAPI BindCtxImpl_AddRef(BindCtxImpl* This){
/******************************************************************************
* BindCtx_Release
******************************************************************************/
ULONG WINAPI BindCtxImpl_Release(BindCtxImpl* This){
ULONG WINAPI BindCtxImpl_Release(IBindCtx* iface)
{
ICOM_THIS(BindCtxImpl,iface);
TRACE(ole,"(%p)\n",This);
This->ref--;
if (This->ref==0){
BindCtxImpl_destroy(This);
BindCtxImpl_Destroy(This);
return 0;
}
return This->ref;;
@ -119,10 +121,10 @@ ULONG WINAPI BindCtxImpl_Release(BindCtxImpl* This){
/******************************************************************************
* BindCtx_Constructor
* BindCtx_Construct
*******************************************************************************/
HRESULT WINAPI BindCtxImpl_Construct(BindCtxImpl* This){
HRESULT WINAPI BindCtxImpl_Construct(BindCtxImpl* This)
{
FIXME(ole,"(%p),stub!\n",This);
memset(This, 0, sizeof(BindCtxImpl));
@ -134,10 +136,10 @@ HRESULT WINAPI BindCtxImpl_Construct(BindCtxImpl* This){
}
/******************************************************************************
* BindCtx_destructor
* BindCtx_Destroy
*******************************************************************************/
HRESULT WINAPI BindCtxImpl_destroy(BindCtxImpl* This){
HRESULT WINAPI BindCtxImpl_Destroy(BindCtxImpl* This)
{
FIXME(ole,"(%p),stub!\n",This);
SEGPTR_FREE(This);
@ -149,8 +151,9 @@ HRESULT WINAPI BindCtxImpl_destroy(BindCtxImpl* This){
/******************************************************************************
* BindCtx_RegisterObjectBound
******************************************************************************/
HRESULT WINAPI BindCtxImpl_RegisterObjectBound(BindCtxImpl* This,IUnknown* punk){
HRESULT WINAPI BindCtxImpl_RegisterObjectBound(IBindCtx* iface,IUnknown* punk)
{
ICOM_THIS(BindCtxImpl,iface);
FIXME(ole,"(%p,%p),stub!\n",This,punk);
return E_NOTIMPL;
@ -159,8 +162,9 @@ HRESULT WINAPI BindCtxImpl_RegisterObjectBound(BindCtxImpl* This,IUnknown* punk)
/******************************************************************************
* BindCtx_RevokeObjectBound
******************************************************************************/
HRESULT WINAPI BindCtxImpl_RevokeObjectBound(BindCtxImpl* This, IUnknown* punk){
HRESULT WINAPI BindCtxImpl_RevokeObjectBound(IBindCtx* iface, IUnknown* punk)
{
ICOM_THIS(BindCtxImpl,iface);
FIXME(ole,"(%p,%p),stub!\n",This,punk);
return E_NOTIMPL;
@ -169,8 +173,9 @@ HRESULT WINAPI BindCtxImpl_RevokeObjectBound(BindCtxImpl* This, IUnknown* punk){
/******************************************************************************
* BindCtx_ReleaseObjects
******************************************************************************/
HRESULT WINAPI BindCtxImpl_ReleaseObjects(BindCtxImpl* This){
HRESULT WINAPI BindCtxImpl_ReleaseObjects(IBindCtx* iface)
{
ICOM_THIS(BindCtxImpl,iface);
FIXME(ole,"(%p),stub!\n",This);
return E_NOTIMPL;
@ -179,8 +184,9 @@ HRESULT WINAPI BindCtxImpl_ReleaseObjects(BindCtxImpl* This){
/******************************************************************************
* BindCtx_SetBindOptions
******************************************************************************/
HRESULT WINAPI BindCtxImpl_SetBindOptions(BindCtxImpl* This,LPBIND_OPTS2 pbindopts){
HRESULT WINAPI BindCtxImpl_SetBindOptions(IBindCtx* iface,LPBIND_OPTS2 pbindopts)
{
ICOM_THIS(BindCtxImpl,iface);
FIXME(ole,"(%p,%p),stub!\n",This,pbindopts);
return E_NOTIMPL;
@ -189,8 +195,9 @@ HRESULT WINAPI BindCtxImpl_SetBindOptions(BindCtxImpl* This,LPBIND_OPTS2 pbindop
/******************************************************************************
* BindCtx_GetBindOptions
******************************************************************************/
HRESULT WINAPI BindCtxImpl_GetBindOptions(BindCtxImpl* This,LPBIND_OPTS2 pbindopts){
HRESULT WINAPI BindCtxImpl_GetBindOptions(IBindCtx* iface,LPBIND_OPTS2 pbindopts)
{
ICOM_THIS(BindCtxImpl,iface);
FIXME(ole,"(%p,%p),stub!\n",This,pbindopts);
return E_NOTIMPL;
@ -199,8 +206,9 @@ HRESULT WINAPI BindCtxImpl_GetBindOptions(BindCtxImpl* This,LPBIND_OPTS2 pbindop
/******************************************************************************
* BindCtx_GetRunningObjectTable
******************************************************************************/
HRESULT WINAPI BindCtxImpl_GetRunningObjectTable(BindCtxImpl* This,IRunningObjectTable** pprot){
HRESULT WINAPI BindCtxImpl_GetRunningObjectTable(IBindCtx* iface,IRunningObjectTable** pprot)
{
ICOM_THIS(BindCtxImpl,iface);
FIXME(ole,"(%p,%p),stub!\n",This,pprot);
return E_NOTIMPL;
@ -209,8 +217,9 @@ HRESULT WINAPI BindCtxImpl_GetRunningObjectTable(BindCtxImpl* This,IRunningObjec
/******************************************************************************
* BindCtx_RegisterObjectParam
******************************************************************************/
HRESULT WINAPI BindCtxImpl_RegisterObjectParam(BindCtxImpl* This,LPOLESTR32 pszkey, IUnknown* punk){
HRESULT WINAPI BindCtxImpl_RegisterObjectParam(IBindCtx* iface,LPOLESTR32 pszkey, IUnknown* punk)
{
ICOM_THIS(BindCtxImpl,iface);
FIXME(ole,"(%p,%p,%p),stub!\n",This,pszkey,punk);
return E_NOTIMPL;
@ -219,8 +228,9 @@ HRESULT WINAPI BindCtxImpl_RegisterObjectParam(BindCtxImpl* This,LPOLESTR32 pszk
/******************************************************************************
* BindCtx_GetObjectParam
******************************************************************************/
HRESULT WINAPI BindCtxImpl_GetObjectParam(BindCtxImpl* This,LPOLESTR32 pszkey, IUnknown* punk){
HRESULT WINAPI BindCtxImpl_GetObjectParam(IBindCtx* iface,LPOLESTR32 pszkey, IUnknown* punk)
{
ICOM_THIS(BindCtxImpl,iface);
FIXME(ole,"(%p,%p,%p),stub!\n",This,pszkey,punk);
return E_NOTIMPL;
@ -229,8 +239,9 @@ HRESULT WINAPI BindCtxImpl_GetObjectParam(BindCtxImpl* This,LPOLESTR32 pszkey, I
/******************************************************************************
* BindCtx_EnumObjectParam
******************************************************************************/
HRESULT WINAPI BindCtxImpl_EnumObjectParam(BindCtxImpl* This,IEnumString** ppenum){
HRESULT WINAPI BindCtxImpl_EnumObjectParam(IBindCtx* iface,IEnumString** ppenum)
{
ICOM_THIS(BindCtxImpl,iface);
FIXME(ole,"(%p,%p),stub!\n",This,ppenum);
return E_NOTIMPL;
@ -239,8 +250,9 @@ HRESULT WINAPI BindCtxImpl_EnumObjectParam(BindCtxImpl* This,IEnumString** ppenu
/******************************************************************************
* BindCtx_RevokeObjectParam
******************************************************************************/
HRESULT WINAPI BindCtxImpl_RevokeObjectParam(BindCtxImpl* This,LPOLESTR32 pszkey){
HRESULT WINAPI BindCtxImpl_RevokeObjectParam(IBindCtx* iface,LPOLESTR32 pszkey)
{
ICOM_THIS(BindCtxImpl,iface);
FIXME(ole,"(%p,%p),stub!\n",This,pszkey);
return E_NOTIMPL;
@ -250,8 +262,8 @@ HRESULT WINAPI BindCtxImpl_RevokeObjectParam(BindCtxImpl* This,LPOLESTR32 pszkey
/******************************************************************************
* CreateBindCtx16
******************************************************************************/
HRESULT WINAPI CreateBindCtx16(DWORD reserved, LPBC * ppbc){
HRESULT WINAPI CreateBindCtx16(DWORD reserved, LPBC * ppbc)
{
FIXME(ole,"(%ld,%p),stub!\n",reserved,ppbc);
return E_NOTIMPL;
@ -260,8 +272,8 @@ HRESULT WINAPI CreateBindCtx16(DWORD reserved, LPBC * ppbc){
/******************************************************************************
* CreateBindCtx32
******************************************************************************/
HRESULT WINAPI CreateBindCtx32(DWORD reserved, LPBC * ppbc){
HRESULT WINAPI CreateBindCtx32(DWORD reserved, LPBC * ppbc)
{
BindCtxImpl* newBindCtx = 0;
HRESULT hr = S_OK;
@ -277,7 +289,7 @@ HRESULT WINAPI CreateBindCtx32(DWORD reserved, LPBC * ppbc){
if (FAILED(hr))
return hr;
hr = BindCtxImpl_QueryInterface(newBindCtx,&IID_IBindCtx,(void**)ppbc);
hr = BindCtxImpl_QueryInterface((IBindCtx*)newBindCtx,&IID_IBindCtx,(void**)ppbc);
return hr;
}

245
ole/filemoniker.c
View File

@ -23,75 +23,67 @@ typedef struct FileMonikerImpl{
} FileMonikerImpl;
HRESULT WINAPI FileMonikerImpl_QueryInterface(FileMonikerImpl* This,REFIID riid,void** ppvObject);
ULONG WINAPI FileMonikerImpl_AddRef(FileMonikerImpl* This);
ULONG WINAPI FileMonikerImpl_Release(FileMonikerImpl* This);
HRESULT WINAPI FileMonikerImpl_GetClassID(FileMonikerImpl* This, CLSID *pClassID);
HRESULT WINAPI FileMonikerImpl_IsDirty(FileMonikerImpl* This);
HRESULT WINAPI FileMonikerImpl_Load(FileMonikerImpl* This,LPCOLESTR32 pszFileName,DWORD dwMode);
HRESULT WINAPI FileMonikerImpl_Save(FileMonikerImpl* This,LPCOLESTR32 pszFileName,BOOL32 fRemember);
HRESULT WINAPI FileMonikerImpl_GetSizeMax(FileMonikerImpl* This,LPOLESTR32 *ppszFileName);
HRESULT WINAPI FileMonikerImpl_Construct(FileMonikerImpl* This, LPCOLESTR32 lpszPathName);
HRESULT WINAPI FileMonikerImpl_destroy(FileMonikerImpl* This);
HRESULT WINAPI FileMonikerImpl_BindToObject(FileMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult);
HRESULT WINAPI FileMonikerImpl_BindToStorage(FileMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult);
HRESULT WINAPI FileMonikerImpl_Reduce(FileMonikerImpl* This,IBindCtx* pbc, DWORD dwReduceHowFar,IMoniker** ppmkToLeft, IMoniker** ppmkReduced);
HRESULT WINAPI FileMonikerImpl_ComposeWith(FileMonikerImpl* This,IMoniker* pmkRight,BOOL32 fOnlyIfNotGeneric, IMoniker** ppmkComposite);
HRESULT WINAPI FileMonikerImpl_Enum(FileMonikerImpl* This,BOOL32 fForward, IEnumMoniker** ppenumMoniker);
HRESULT WINAPI FileMonikerImpl_IsEqual(FileMonikerImpl* This,IMoniker* pmkOtherMoniker);
HRESULT WINAPI FileMonikerImpl_Hash(FileMonikerImpl* This,DWORD* pdwHash);
HRESULT WINAPI FileMonikerImpl_IsRunning(FileMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning);
HRESULT WINAPI FileMonikerImpl_GetTimeOfLastChange(FileMonikerImpl* This, IBindCtx* pbc, IMoniker* pmkToLeft, FILETIME* pFileTime);
HRESULT WINAPI FileMonikerImpl_Inverse(FileMonikerImpl* This,IMoniker** ppmk);
HRESULT WINAPI FileMonikerImpl_CommonPrefixWith(FileMonikerImpl* This,IMoniker* pmkOther, IMoniker** ppmkPrefix);
HRESULT WINAPI FileMonikerImpl_RelativePathTo(FileMonikerImpl* This,IMoniker* pmOther, IMoniker** ppmkRelPath);
HRESULT WINAPI FileMonikerImpl_GetDisplayName(FileMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR32 *ppszDisplayName);
HRESULT WINAPI FileMonikerImpl_ParseDisplayName(FileMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR32 pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut);
HRESULT WINAPI FileMonikerImpl_IsSystemMoniker(FileMonikerImpl* This,DWORD* pwdMksys);
HRESULT WINAPI CreateFileMoniker16(LPCOLESTR16 lpszPathName,LPMONIKER * ppmk);
HRESULT WINAPI CreateFileMoniker32( LPCOLESTR32 lpszPathName, LPMONIKER * ppmk);
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(const IMoniker* iface, CLSID *pClassID);
static HRESULT WINAPI FileMonikerImpl_IsDirty(IMoniker* iface);
static HRESULT WINAPI FileMonikerImpl_Load(IMoniker* iface, IStream32* pStm);
static HRESULT WINAPI FileMonikerImpl_Save(IMoniker* iface, IStream32* pStm, BOOL32 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** ppvResult);
static HRESULT WINAPI FileMonikerImpl_Reduce(IMoniker* iface,IBindCtx* pbc, DWORD dwReduceHowFar,IMoniker** ppmkToLeft, IMoniker** ppmkReduced);
static HRESULT WINAPI FileMonikerImpl_ComposeWith(IMoniker* iface,IMoniker* pmkRight,BOOL32 fOnlyIfNotGeneric, IMoniker** ppmkComposite);
static HRESULT WINAPI FileMonikerImpl_Enum(IMoniker* iface,BOOL32 fForward, IEnumMoniker** ppenumMoniker);
static HRESULT WINAPI FileMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker);
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, LPOLESTR32 *ppszDisplayName);
static HRESULT WINAPI FileMonikerImpl_ParseDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR32 pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut);
static HRESULT WINAPI FileMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys);
#define VTABLE_FUNC(a) (void*)(a)
static HRESULT WINAPI FileMonikerImpl_Construct(FileMonikerImpl* iface, LPCOLESTR32 lpszPathName);
static HRESULT WINAPI FileMonikerImpl_Destroy(FileMonikerImpl* iface);
// Virtual function table for the FileMonikerImpl class.
static ICOM_VTABLE(IMoniker) VT_FileMonikerImpl =
{
{
{
{
VTABLE_FUNC(FileMonikerImpl_QueryInterface),
VTABLE_FUNC(FileMonikerImpl_AddRef),
VTABLE_FUNC(FileMonikerImpl_Release)
},
VTABLE_FUNC(FileMonikerImpl_GetClassID)
},
VTABLE_FUNC(FileMonikerImpl_IsDirty),
VTABLE_FUNC(FileMonikerImpl_Load),
VTABLE_FUNC(FileMonikerImpl_Save),
VTABLE_FUNC(FileMonikerImpl_GetSizeMax)
},
VTABLE_FUNC(FileMonikerImpl_BindToObject),
VTABLE_FUNC(FileMonikerImpl_BindToStorage),
VTABLE_FUNC(FileMonikerImpl_Reduce),
VTABLE_FUNC(FileMonikerImpl_ComposeWith),
VTABLE_FUNC(FileMonikerImpl_Enum),
VTABLE_FUNC(FileMonikerImpl_IsEqual),
VTABLE_FUNC(FileMonikerImpl_Hash),
VTABLE_FUNC(FileMonikerImpl_IsRunning),
VTABLE_FUNC(FileMonikerImpl_GetTimeOfLastChange),
VTABLE_FUNC(FileMonikerImpl_Inverse),
VTABLE_FUNC(FileMonikerImpl_CommonPrefixWith),
VTABLE_FUNC(FileMonikerImpl_RelativePathTo),
VTABLE_FUNC(FileMonikerImpl_GetDisplayName),
VTABLE_FUNC(FileMonikerImpl_ParseDisplayName),
VTABLE_FUNC(FileMonikerImpl_IsSystemMoniker)
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
};
/*******************************************************************************
* FileMoniker_QueryInterface
*******************************************************************************/
HRESULT WINAPI FileMonikerImpl_QueryInterface(FileMonikerImpl* This,REFIID riid,void** ppvObject){
HRESULT WINAPI FileMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
TRACE(ole,"(%p,%p,%p)\n",This,riid,ppvObject);
// Perform a sanity check on the parameters.
@ -117,7 +109,7 @@ HRESULT WINAPI FileMonikerImpl_QueryInterface(FileMonikerImpl* This,REFIID riid,
if ((*ppvObject)==0) return E_NOINTERFACE;
// Query Interface always increases the reference count by one when it is successful
FileMonikerImpl_AddRef(This);
FileMonikerImpl_AddRef(iface);
return S_OK;;
}
@ -125,7 +117,9 @@ HRESULT WINAPI FileMonikerImpl_QueryInterface(FileMonikerImpl* This,REFIID riid,
/******************************************************************************
* FileMoniker_AddRef
******************************************************************************/
ULONG WINAPI FileMonikerImpl_AddRef(FileMonikerImpl* This){
ULONG WINAPI FileMonikerImpl_AddRef(IMoniker* iface)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
TRACE(ole,"(%p)\n",This);
@ -135,14 +129,16 @@ ULONG WINAPI FileMonikerImpl_AddRef(FileMonikerImpl* This){
/******************************************************************************
* FileMoniker_Release
******************************************************************************/
ULONG WINAPI FileMonikerImpl_Release(FileMonikerImpl* This){
ULONG WINAPI FileMonikerImpl_Release(IMoniker* iface)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
TRACE(ole,"(%p)\n",This);
This->ref--;
if (This->ref==0){
FileMonikerImpl_destroy(This);
FileMonikerImpl_Destroy(This);
return 0;
}
return This->ref;;
@ -151,7 +147,9 @@ ULONG WINAPI FileMonikerImpl_Release(FileMonikerImpl* This){
/******************************************************************************
* FileMoniker_GetClassID
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_GetClassID(FileMonikerImpl* This, CLSID *pClassID){//Pointer to CLSID of object
HRESULT WINAPI FileMonikerImpl_GetClassID(const IMoniker* iface, CLSID *pClassID)//Pointer to CLSID of object
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%p),stub!\n",This,pClassID);
@ -161,8 +159,10 @@ HRESULT WINAPI FileMonikerImpl_GetClassID(FileMonikerImpl* This, CLSID *pClassID
/******************************************************************************
* FileMoniker_IsDirty
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_IsDirty(FileMonikerImpl* This)
HRESULT WINAPI FileMonikerImpl_IsDirty(IMoniker* iface)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p),stub!\n",This);
return E_NOTIMPL;
@ -172,24 +172,27 @@ HRESULT WINAPI FileMonikerImpl_IsDirty(FileMonikerImpl* This)
* FileMoniker_Load
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_Load(
FileMonikerImpl* This,
LPCOLESTR32 pszFileName,//Pointer to absolute path of the file to open
DWORD dwMode) //Specifies the access mode from the STGM enumeration
IMoniker* iface,
IStream32* pStm)
{
FIXME(ole,"(%p,%p,%ld),stub!\n",This,pszFileName,dwMode);
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%p),stub!\n",This,pStm);
return E_NOTIMPL;
}
/******************************************************************************
* FileMoniker_save
* FileMoniker_Save
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_Save(
FileMonikerImpl* This,
LPCOLESTR32 pszFileName, //Pointer to absolute path of the file where the object is saved
BOOL32 fRemember) //Specifies whether the file is to be the current working file or not
IMoniker* iface,
IStream32* pStm,
BOOL32 fClearDirty)
{
FIXME(ole,"(%p,%p,%d),stub!\n",This,pszFileName,fRemember);
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%d),stub!\n",This,pStm,fClearDirty);
return E_NOTIMPL;
}
@ -198,16 +201,18 @@ HRESULT WINAPI FileMonikerImpl_Save(
* FileMoniker_GetSizeMax
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_GetSizeMax(
FileMonikerImpl* This,
LPOLESTR32 *ppszFileName) //Pointer to the path for the current file or the default save prompt
IMoniker* iface,
ULARGE_INTEGER* pcbSize)
{
FIXME(ole,"(%p,%p),stub!\n",This,ppszFileName);
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%p),stub!\n",This,pcbSize);
return E_NOTIMPL;
}
/******************************************************************************
* FileMoniker_Constructor
* FileMoniker_Construct
*******************************************************************************/
HRESULT WINAPI FileMonikerImpl_Construct(FileMonikerImpl* This, LPCOLESTR32 lpszPathName){
@ -221,9 +226,9 @@ HRESULT WINAPI FileMonikerImpl_Construct(FileMonikerImpl* This, LPCOLESTR32 lpsz
}
/******************************************************************************
* FileMoniker_destructor
* FileMoniker_Destroy
*******************************************************************************/
HRESULT WINAPI FileMonikerImpl_destroy(FileMonikerImpl* This){
HRESULT WINAPI FileMonikerImpl_Destroy(FileMonikerImpl* This){
FIXME(ole,"(%p),stub!\n",This);
@ -234,8 +239,10 @@ HRESULT WINAPI FileMonikerImpl_destroy(FileMonikerImpl* This){
/******************************************************************************
* FileMoniker_BindToObject
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_BindToObject(FileMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft,
REFIID riid, VOID** ppvResult){
HRESULT WINAPI FileMonikerImpl_BindToObject(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft,
REFIID riid, VOID** ppvResult)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%p,%p,%p),stub!\n",This,pbc,pmkToLeft,riid,ppvResult);
@ -245,8 +252,10 @@ HRESULT WINAPI FileMonikerImpl_BindToObject(FileMonikerImpl* This,IBindCtx* pbc,
/******************************************************************************
* FileMoniker_BindToStorage
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_BindToStorage(FileMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft,
REFIID riid, VOID** ppvResult){
HRESULT WINAPI FileMonikerImpl_BindToStorage(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft,
REFIID riid, VOID** ppvResult)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%p,%p,%p),stub!\n",This,pbc,pmkToLeft,riid,ppvResult);
@ -256,8 +265,10 @@ HRESULT WINAPI FileMonikerImpl_BindToStorage(FileMonikerImpl* This,IBindCtx* pbc
/******************************************************************************
* FileMoniker_Reduce
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_Reduce(FileMonikerImpl* This,IBindCtx* pbc, DWORD dwReduceHowFar,
IMoniker** ppmkToLeft, IMoniker** ppmkReduced){
HRESULT WINAPI FileMonikerImpl_Reduce(IMoniker* iface,IBindCtx* pbc, DWORD dwReduceHowFar,
IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%ld,%p,%p),stub!\n",This,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
@ -267,8 +278,10 @@ HRESULT WINAPI FileMonikerImpl_Reduce(FileMonikerImpl* This,IBindCtx* pbc, DWORD
/******************************************************************************
* FileMoniker_ComposeWith
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_ComposeWith(FileMonikerImpl* This,IMoniker* pmkRight,BOOL32 fOnlyIfNotGeneric,
IMoniker** ppmkComposite){
HRESULT WINAPI FileMonikerImpl_ComposeWith(IMoniker* iface,IMoniker* pmkRight,BOOL32 fOnlyIfNotGeneric,
IMoniker** ppmkComposite)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%d,%p),stub!\n",This,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
@ -278,7 +291,9 @@ HRESULT WINAPI FileMonikerImpl_ComposeWith(FileMonikerImpl* This,IMoniker* pmkRi
/******************************************************************************
* FileMoniker_Enum
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_Enum(FileMonikerImpl* This,BOOL32 fForward, IEnumMoniker** ppenumMoniker){
HRESULT WINAPI FileMonikerImpl_Enum(IMoniker* iface,BOOL32 fForward, IEnumMoniker** ppenumMoniker)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%d,%p),stub!\n",This,fForward,ppenumMoniker);
@ -289,7 +304,9 @@ HRESULT WINAPI FileMonikerImpl_Enum(FileMonikerImpl* This,BOOL32 fForward, IEnum
/******************************************************************************
* FileMoniker_IsEqual
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_IsEqual(FileMonikerImpl* This,IMoniker* pmkOtherMoniker){
HRESULT WINAPI FileMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%p),stub!\n",This,pmkOtherMoniker);
@ -299,7 +316,9 @@ HRESULT WINAPI FileMonikerImpl_IsEqual(FileMonikerImpl* This,IMoniker* pmkOtherM
/******************************************************************************
* FileMoniker_Hash
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_Hash(FileMonikerImpl* This,DWORD* pdwHash){
HRESULT WINAPI FileMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%p),stub!\n",This,pdwHash);
@ -309,8 +328,10 @@ HRESULT WINAPI FileMonikerImpl_Hash(FileMonikerImpl* This,DWORD* pdwHash){
/******************************************************************************
* FileMoniker_IsRunning
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_IsRunning(FileMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft,
IMoniker* pmkNewlyRunning){
HRESULT WINAPI FileMonikerImpl_IsRunning(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft,
IMoniker* pmkNewlyRunning)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%p,%p),stub!\n",This,pbc,pmkToLeft,pmkNewlyRunning);
@ -320,8 +341,10 @@ HRESULT WINAPI FileMonikerImpl_IsRunning(FileMonikerImpl* This,IBindCtx* pbc, IM
/******************************************************************************
* FileMoniker_GetTimeOfLastChange
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_GetTimeOfLastChange(FileMonikerImpl* This, IBindCtx* pbc, IMoniker* pmkToLeft,
FILETIME* pFileTime){
HRESULT WINAPI FileMonikerImpl_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
FILETIME* pFileTime)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%p,%p),stub!\n",This,pbc,pmkToLeft,pFileTime);
@ -331,7 +354,9 @@ HRESULT WINAPI FileMonikerImpl_GetTimeOfLastChange(FileMonikerImpl* This, IBindC
/******************************************************************************
* FileMoniker_Inverse
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_Inverse(FileMonikerImpl* This,IMoniker** ppmk){
HRESULT WINAPI FileMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%p),stub!\n",This,ppmk);
@ -341,8 +366,10 @@ HRESULT WINAPI FileMonikerImpl_Inverse(FileMonikerImpl* This,IMoniker** ppmk){
/******************************************************************************
* FileMoniker_CommonPrefixWith
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_CommonPrefixWith(FileMonikerImpl* This,IMoniker* pmkOther,
IMoniker** ppmkPrefix){
HRESULT WINAPI FileMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,
IMoniker** ppmkPrefix)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%p),stub!\n",This,pmkOther,ppmkPrefix);
@ -352,7 +379,9 @@ HRESULT WINAPI FileMonikerImpl_CommonPrefixWith(FileMonikerImpl* This,IMoniker*
/******************************************************************************
* FileMoniker_RelativePathTo
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_RelativePathTo(FileMonikerImpl* This,IMoniker* pmOther, IMoniker** ppmkRelPath){
HRESULT WINAPI FileMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%p),stub!\n",This,pmOther,ppmkRelPath);
@ -362,8 +391,10 @@ HRESULT WINAPI FileMonikerImpl_RelativePathTo(FileMonikerImpl* This,IMoniker* pm
/******************************************************************************
* FileMoniker_GetDisplayName
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_GetDisplayName(FileMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft,
LPOLESTR32 *ppszDisplayName){
HRESULT WINAPI FileMonikerImpl_GetDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft,
LPOLESTR32 *ppszDisplayName)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%p,%p),stub!\n",This,pbc,pmkToLeft,ppszDisplayName);
@ -373,8 +404,10 @@ HRESULT WINAPI FileMonikerImpl_GetDisplayName(FileMonikerImpl* This,IBindCtx* pb
/******************************************************************************
* FileMoniker_ParseDisplayName
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_ParseDisplayName(FileMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft,
LPOLESTR32 pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut){
HRESULT WINAPI FileMonikerImpl_ParseDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft,
LPOLESTR32 pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%p,%p,%p,%p),stub!\n",This,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
@ -384,7 +417,9 @@ HRESULT WINAPI FileMonikerImpl_ParseDisplayName(FileMonikerImpl* This,IBindCtx*
/******************************************************************************
* FileMoniker_IsSystemMonker
******************************************************************************/
HRESULT WINAPI FileMonikerImpl_IsSystemMoniker(FileMonikerImpl* This,DWORD* pwdMksys){
HRESULT WINAPI FileMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
{
FileMonikerImpl* This=(FileMonikerImpl*)iface;
FIXME(ole,"(%p,%p),stub!\n",This,pwdMksys);
@ -421,7 +456,7 @@ HRESULT WINAPI CreateFileMoniker32(LPCOLESTR32 lpszPathName, LPMONIKER * ppmk)
if (FAILED(hr))
return hr;
hr = FileMonikerImpl_QueryInterface(newFileMoniker,&IID_IMoniker,(void**)ppmk);
hr = FileMonikerImpl_QueryInterface((IMoniker*)newFileMoniker,&IID_IMoniker,(void**)ppmk);
return hr;
}

249
ole/itemmoniker.c
View File

@ -23,73 +23,67 @@ typedef struct ItemMonikerImpl{
} ItemMonikerImpl;
HRESULT WINAPI ItemMonikerImpl_QueryInterface(ItemMonikerImpl* This,REFIID riid,void** ppvObject);
ULONG WINAPI ItemMonikerImpl_AddRef(ItemMonikerImpl* This);
ULONG WINAPI ItemMonikerImpl_Release(ItemMonikerImpl* This);
HRESULT WINAPI ItemMonikerImpl_GetClassID(ItemMonikerImpl* This, CLSID *pClassID);
HRESULT WINAPI ItemMonikerImpl_IsDirty(ItemMonikerImpl* This);
HRESULT WINAPI ItemMonikerImpl_Load(ItemMonikerImpl* This,LPCOLESTR32 pszItemName,DWORD dwMode);
HRESULT WINAPI ItemMonikerImpl_Save(ItemMonikerImpl* This,LPCOLESTR32 pszItemName,BOOL32 fRemember);
HRESULT WINAPI ItemMonikerImpl_GetSizeMax(ItemMonikerImpl* This,LPOLESTR32 *ppszItemName);
HRESULT WINAPI ItemMonikerImpl_Construct(ItemMonikerImpl* This, LPCOLESTR32 lpszDelim,LPCOLESTR32 lpszItem);
HRESULT WINAPI ItemMonikerImpl_destroy(ItemMonikerImpl* This);
HRESULT WINAPI ItemMonikerImpl_BindToObject(ItemMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult);
HRESULT WINAPI ItemMonikerImpl_BindToStorage(ItemMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult);
HRESULT WINAPI ItemMonikerImpl_Reduce(ItemMonikerImpl* This,IBindCtx* pbc, DWORD dwReduceHowFar,IMoniker** ppmkToLeft, IMoniker** ppmkReduced);
HRESULT WINAPI ItemMonikerImpl_ComposeWith(ItemMonikerImpl* This,IMoniker* pmkRight,BOOL32 fOnlyIfNotGeneric, IMoniker** ppmkComposite);
HRESULT WINAPI ItemMonikerImpl_Enum(ItemMonikerImpl* This,BOOL32 fForward, IEnumMoniker** ppenumMoniker);
HRESULT WINAPI ItemMonikerImpl_IsEqual(ItemMonikerImpl* This,IMoniker* pmkOtherMoniker);
HRESULT WINAPI ItemMonikerImpl_Hash(ItemMonikerImpl* This,DWORD* pdwHash);
HRESULT WINAPI ItemMonikerImpl_IsRunning(ItemMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning);
HRESULT WINAPI ItemMonikerImpl_GetTimeOfLastChange(ItemMonikerImpl* This, IBindCtx* pbc, IMoniker* pmkToLeft, FILETIME* pItemTime);
HRESULT WINAPI ItemMonikerImpl_Inverse(ItemMonikerImpl* This,IMoniker** ppmk);
HRESULT WINAPI ItemMonikerImpl_CommonPrefixWith(ItemMonikerImpl* This,IMoniker* pmkOther, IMoniker** ppmkPrefix);
HRESULT WINAPI ItemMonikerImpl_RelativePathTo(ItemMonikerImpl* This,IMoniker* pmOther, IMoniker** ppmkRelPath);
HRESULT WINAPI ItemMonikerImpl_GetDisplayName(ItemMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR32 *ppszDisplayName);
HRESULT WINAPI ItemMonikerImpl_ParseDisplayName(ItemMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR32 pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut);
HRESULT WINAPI ItemMonikerImpl_IsSystemMoniker(ItemMonikerImpl* This,DWORD* pwdMksys);
HRESULT WINAPI CreateItemMoniker16(LPCOLESTR16 lpszDelim,LPCOLESTR32 lpszItem,LPMONIKER * ppmk);
HRESULT WINAPI CreateItemMoniker32(LPCOLESTR32 lpszDelim,LPCOLESTR32 lpszItem,LPMONIKER * ppmk);
static HRESULT WINAPI ItemMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject);
static ULONG WINAPI ItemMonikerImpl_AddRef(IMoniker* iface);
static ULONG WINAPI ItemMonikerImpl_Release(IMoniker* iface);
static HRESULT WINAPI ItemMonikerImpl_GetClassID(const IMoniker* iface, CLSID *pClassID);
static HRESULT WINAPI ItemMonikerImpl_IsDirty(IMoniker* iface);
static HRESULT WINAPI ItemMonikerImpl_Load(IMoniker* iface, IStream32* pStm);
static HRESULT WINAPI ItemMonikerImpl_Save(IMoniker* iface, IStream32* pStm, BOOL32 fClearDirty);
static HRESULT WINAPI ItemMonikerImpl_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize);
static HRESULT WINAPI ItemMonikerImpl_BindToObject(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult);
static HRESULT WINAPI ItemMonikerImpl_BindToStorage(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult);
static HRESULT WINAPI ItemMonikerImpl_Reduce(IMoniker* iface,IBindCtx* pbc, DWORD dwReduceHowFar,IMoniker** ppmkToLeft, IMoniker** ppmkReduced);
static HRESULT WINAPI ItemMonikerImpl_ComposeWith(IMoniker* iface,IMoniker* pmkRight,BOOL32 fOnlyIfNotGeneric, IMoniker** ppmkComposite);
static HRESULT WINAPI ItemMonikerImpl_Enum(IMoniker* iface,BOOL32 fForward, IEnumMoniker** ppenumMoniker);
static HRESULT WINAPI ItemMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker);
static HRESULT WINAPI ItemMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash);
static HRESULT WINAPI ItemMonikerImpl_IsRunning(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning);
static HRESULT WINAPI ItemMonikerImpl_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft, FILETIME* pItemTime);
static HRESULT WINAPI ItemMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk);
static HRESULT WINAPI ItemMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther, IMoniker** ppmkPrefix);
static HRESULT WINAPI ItemMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath);
static HRESULT WINAPI ItemMonikerImpl_GetDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR32 *ppszDisplayName);
static HRESULT WINAPI ItemMonikerImpl_ParseDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR32 pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut);
static HRESULT WINAPI ItemMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys);
static HRESULT WINAPI ItemMonikerImpl_Construct(ItemMonikerImpl* iface, LPCOLESTR32 lpszDelim,LPCOLESTR32 lpszItem);
static HRESULT WINAPI ItemMonikerImpl_Destroy(ItemMonikerImpl* iface);
#define VTABLE_FUNC(a) (void*)(a)
// Virtual function table for the ItemMonikerImpl class.
static ICOM_VTABLE(IMoniker) VT_ItemMonikerImpl =
{
{
{
{
VTABLE_FUNC(ItemMonikerImpl_QueryInterface),
VTABLE_FUNC(ItemMonikerImpl_AddRef),
VTABLE_FUNC(ItemMonikerImpl_Release)
},
VTABLE_FUNC(ItemMonikerImpl_GetClassID)
},
VTABLE_FUNC(ItemMonikerImpl_IsDirty),
VTABLE_FUNC(ItemMonikerImpl_Load),
VTABLE_FUNC(ItemMonikerImpl_Save),
VTABLE_FUNC(ItemMonikerImpl_GetSizeMax)
},
VTABLE_FUNC(ItemMonikerImpl_BindToObject),
VTABLE_FUNC(ItemMonikerImpl_BindToStorage),
VTABLE_FUNC(ItemMonikerImpl_Reduce),
VTABLE_FUNC(ItemMonikerImpl_ComposeWith),
VTABLE_FUNC(ItemMonikerImpl_Enum),
VTABLE_FUNC(ItemMonikerImpl_IsEqual),
VTABLE_FUNC(ItemMonikerImpl_Hash),
VTABLE_FUNC(ItemMonikerImpl_IsRunning),
VTABLE_FUNC(ItemMonikerImpl_GetTimeOfLastChange),
VTABLE_FUNC(ItemMonikerImpl_Inverse),
VTABLE_FUNC(ItemMonikerImpl_CommonPrefixWith),
VTABLE_FUNC(ItemMonikerImpl_RelativePathTo),
VTABLE_FUNC(ItemMonikerImpl_GetDisplayName),
VTABLE_FUNC(ItemMonikerImpl_ParseDisplayName),
VTABLE_FUNC(ItemMonikerImpl_IsSystemMoniker)
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
};
/*******************************************************************************
* ItemMoniker_QueryInterface
*******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_QueryInterface(ItemMonikerImpl* This,REFIID riid,void** ppvObject){
HRESULT WINAPI ItemMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
TRACE(ole,"(%p,%p,%p)\n",This,riid,ppvObject);
@ -116,15 +110,17 @@ HRESULT WINAPI ItemMonikerImpl_QueryInterface(ItemMonikerImpl* This,REFIID riid,
if ((*ppvObject)==0) return E_NOINTERFACE;
// Query Interface always increases the reference count by one when it is successful
ItemMonikerImpl_AddRef(This);
ItemMonikerImpl_AddRef(iface);
return S_OK;;
return S_OK;
}
/******************************************************************************
* ItemMoniker_AddRef
******************************************************************************/
ULONG WINAPI ItemMonikerImpl_AddRef(ItemMonikerImpl* This){
ULONG WINAPI ItemMonikerImpl_AddRef(IMoniker* iface)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
TRACE(ole,"(%p)\n",This);
@ -134,25 +130,27 @@ ULONG WINAPI ItemMonikerImpl_AddRef(ItemMonikerImpl* This){
/******************************************************************************
* ItemMoniker_Release
******************************************************************************/
ULONG WINAPI ItemMonikerImpl_Release(ItemMonikerImpl* This){
ULONG WINAPI ItemMonikerImpl_Release(IMoniker* iface)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
TRACE(ole,"(%p),stub!\n",This);
This->ref--;
if (This->ref==0){
ItemMonikerImpl_destroy(This);
ItemMonikerImpl_Destroy(This);
return 0;
}
return This->ref;;
return This->ref;
}
/******************************************************************************
* ItemMoniker_GetClassID
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_GetClassID(ItemMonikerImpl* This, CLSID *pClassID){//Pointer to CLSID of object
HRESULT WINAPI ItemMonikerImpl_GetClassID(const IMoniker* iface, CLSID *pClassID)//Pointer to CLSID of object
{
FIXME(ole,"(%p),stub!\n",pClassID);
return E_NOTIMPL;
}
@ -160,8 +158,10 @@ HRESULT WINAPI ItemMonikerImpl_GetClassID(ItemMonikerImpl* This, CLSID *pClassID
/******************************************************************************
* ItemMoniker_IsDirty
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_IsDirty(ItemMonikerImpl* This)
HRESULT WINAPI ItemMonikerImpl_IsDirty(IMoniker* iface)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p),stub!\n",This);
return E_NOTIMPL;
}
@ -170,23 +170,26 @@ HRESULT WINAPI ItemMonikerImpl_IsDirty(ItemMonikerImpl* This)
* ItemMoniker_Load
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_Load(
ItemMonikerImpl* This,
LPCOLESTR32 pszFileName,//Pointer to absolute path of the file to open
DWORD dwMode) //Specifies the access mode from the STGM enumeration
IMoniker* iface,
IStream32* pStm)
{
FIXME(ole,"(%p,%ld),stub!\n",pszFileName,dwMode);
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p,%p),stub!\n",This,pStm);
return E_NOTIMPL;
}
/******************************************************************************
* ItemMoniker_save
* ItemMoniker_Save
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_Save(
ItemMonikerImpl* This,
LPCOLESTR32 pszFileName, //Pointer to absolute path of the file where the object is saved
BOOL32 fRemember) //Specifies whether the file is to be the current working file or not
IMoniker* iface,
IStream32* pStm,
BOOL32 fClearDirty)
{
FIXME(ole,"(%p,%d),stub!\n",pszFileName,fRemember);
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%d),stub!\n",This,pStm,fClearDirty);
return E_NOTIMPL;
}
@ -194,15 +197,17 @@ HRESULT WINAPI ItemMonikerImpl_Save(
* ItemMoniker_GetSizeMax
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_GetSizeMax(
ItemMonikerImpl* This,
LPOLESTR32 *ppszFileName) //Pointer to the path for the current file or the default save prompt
IMoniker* iface,
ULARGE_INTEGER* pcbSize)
{
FIXME(ole,"(%p),stub!\n",ppszFileName);
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p,%p),stub!\n",This,pcbSize);
return E_NOTIMPL;
}
/******************************************************************************
* ItemMoniker_Constructor
* ItemMoniker_Construct
*******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_Construct(ItemMonikerImpl* This, LPCOLESTR32 lpszDelim,LPCOLESTR32 lpszItem){
@ -216,9 +221,9 @@ HRESULT WINAPI ItemMonikerImpl_Construct(ItemMonikerImpl* This, LPCOLESTR32 lpsz
}
/******************************************************************************
* ItemMoniker_destructor
* ItemMoniker_Destroy
*******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_destroy(ItemMonikerImpl* This){
HRESULT WINAPI ItemMonikerImpl_Destroy(ItemMonikerImpl* This){
FIXME(ole,"(%p),stub!\n",This);
@ -229,8 +234,10 @@ HRESULT WINAPI ItemMonikerImpl_destroy(ItemMonikerImpl* This){
/******************************************************************************
* ItemMoniker_BindToObject
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_BindToObject(ItemMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft,
REFIID riid, VOID** ppvResult){
HRESULT WINAPI ItemMonikerImpl_BindToObject(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft,
REFIID riid, VOID** ppvResult)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%p,%p,%p),stub!\n",This,pbc,pmkToLeft,riid,ppvResult);
return E_NOTIMPL;
@ -239,8 +246,10 @@ HRESULT WINAPI ItemMonikerImpl_BindToObject(ItemMonikerImpl* This,IBindCtx* pbc,
/******************************************************************************
* ItemMoniker_BindToStorage
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_BindToStorage(ItemMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft,
REFIID riid, VOID** ppvResult){
HRESULT WINAPI ItemMonikerImpl_BindToStorage(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft,
REFIID riid, VOID** ppvResult)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%p,%p,%p),stub!\n",This,pbc,pmkToLeft,riid,ppvResult);
return E_NOTIMPL;
@ -249,8 +258,10 @@ HRESULT WINAPI ItemMonikerImpl_BindToStorage(ItemMonikerImpl* This,IBindCtx* pbc
/******************************************************************************
* ItemMoniker_Reduce
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_Reduce(ItemMonikerImpl* This,IBindCtx* pbc, DWORD dwReduceHowFar,
IMoniker** ppmkToLeft, IMoniker** ppmkReduced){
HRESULT WINAPI ItemMonikerImpl_Reduce(IMoniker* iface,IBindCtx* pbc, DWORD dwReduceHowFar,
IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%ld,%p,%p),stub!\n",This,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
return E_NOTIMPL;
@ -259,8 +270,10 @@ HRESULT WINAPI ItemMonikerImpl_Reduce(ItemMonikerImpl* This,IBindCtx* pbc, DWORD
/******************************************************************************
* ItemMoniker_ComposeWith
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_ComposeWith(ItemMonikerImpl* This,IMoniker* pmkRight,BOOL32 fOnlyIfNotGeneric,
IMoniker** ppmkComposite){
HRESULT WINAPI ItemMonikerImpl_ComposeWith(IMoniker* iface,IMoniker* pmkRight,BOOL32 fOnlyIfNotGeneric,
IMoniker** ppmkComposite)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%d,%p),stub!\n",This,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
return E_NOTIMPL;
@ -269,7 +282,9 @@ HRESULT WINAPI ItemMonikerImpl_ComposeWith(ItemMonikerImpl* This,IMoniker* pmkRi
/******************************************************************************
* ItemMoniker_Enum
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_Enum(ItemMonikerImpl* This,BOOL32 fForward, IEnumMoniker** ppenumMoniker){
HRESULT WINAPI ItemMonikerImpl_Enum(IMoniker* iface,BOOL32 fForward, IEnumMoniker** ppenumMoniker)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p,%d,%p),stub!\n",This,fForward,ppenumMoniker);
return E_NOTIMPL;
@ -279,7 +294,9 @@ HRESULT WINAPI ItemMonikerImpl_Enum(ItemMonikerImpl* This,BOOL32 fForward, IEnum
/******************************************************************************
* ItemMoniker_IsEqual
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_IsEqual(ItemMonikerImpl* This,IMoniker* pmkOtherMoniker){
HRESULT WINAPI ItemMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p,%p),stub!\n",This,pmkOtherMoniker);
return E_NOTIMPL;
@ -288,7 +305,9 @@ HRESULT WINAPI ItemMonikerImpl_IsEqual(ItemMonikerImpl* This,IMoniker* pmkOtherM
/******************************************************************************
* ItemMoniker_Hash
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_Hash(ItemMonikerImpl* This,DWORD* pdwHash){
HRESULT WINAPI ItemMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p,%p),stub!\n",This,pdwHash);
return E_NOTIMPL;
@ -297,8 +316,10 @@ HRESULT WINAPI ItemMonikerImpl_Hash(ItemMonikerImpl* This,DWORD* pdwHash){
/******************************************************************************
* ItemMoniker_IsRunning
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_IsRunning(ItemMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft,
IMoniker* pmkNewlyRunning){
HRESULT WINAPI ItemMonikerImpl_IsRunning(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft,
IMoniker* pmkNewlyRunning)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%p,%p),stub!\n",This,pbc,pmkToLeft,pmkNewlyRunning);
return E_NOTIMPL;
@ -307,8 +328,10 @@ HRESULT WINAPI ItemMonikerImpl_IsRunning(ItemMonikerImpl* This,IBindCtx* pbc, IM
/******************************************************************************
* ItemMoniker_GetTimeOfLastChange
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_GetTimeOfLastChange(ItemMonikerImpl* This, IBindCtx* pbc, IMoniker* pmkToLeft,
FILETIME* pFileTime){
HRESULT WINAPI ItemMonikerImpl_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
FILETIME* pFileTime)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%p,%p),stub!\n",This,pbc,pmkToLeft,pFileTime);
return E_NOTIMPL;
@ -317,7 +340,9 @@ HRESULT WINAPI ItemMonikerImpl_GetTimeOfLastChange(ItemMonikerImpl* This, IBindC
/******************************************************************************
* ItemMoniker_Inverse
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_Inverse(ItemMonikerImpl* This,IMoniker** ppmk){
HRESULT WINAPI ItemMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p,%p),stub!\n",This,ppmk);
return E_NOTIMPL;
@ -326,8 +351,10 @@ HRESULT WINAPI ItemMonikerImpl_Inverse(ItemMonikerImpl* This,IMoniker** ppmk){
/******************************************************************************
* ItemMoniker_CommonPrefixWith
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_CommonPrefixWith(ItemMonikerImpl* This,IMoniker* pmkOther,
IMoniker** ppmkPrefix){
HRESULT WINAPI ItemMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,
IMoniker** ppmkPrefix)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%p),stub!\n",This,pmkOther,ppmkPrefix);
return E_NOTIMPL;
@ -336,7 +363,9 @@ HRESULT WINAPI ItemMonikerImpl_CommonPrefixWith(ItemMonikerImpl* This,IMoniker*
/******************************************************************************
* ItemMoniker_RelativePathTo
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_RelativePathTo(ItemMonikerImpl* This,IMoniker* pmOther, IMoniker** ppmkRelPath){
HRESULT WINAPI ItemMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%p),stub!\n",This,pmOther,ppmkRelPath);
return E_NOTIMPL;
@ -345,8 +374,10 @@ HRESULT WINAPI ItemMonikerImpl_RelativePathTo(ItemMonikerImpl* This,IMoniker* pm
/******************************************************************************
* ItemMoniker_GetDisplayName
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_GetDisplayName(ItemMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft,
LPOLESTR32 *ppszDisplayName){
HRESULT WINAPI ItemMonikerImpl_GetDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft,
LPOLESTR32 *ppszDisplayName)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%p,%p),stub!\n",This,pbc,pmkToLeft,ppszDisplayName);
return E_NOTIMPL;
@ -355,8 +386,10 @@ HRESULT WINAPI ItemMonikerImpl_GetDisplayName(ItemMonikerImpl* This,IBindCtx* pb
/******************************************************************************
* ItemMoniker_ParseDisplayName
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_ParseDisplayName(ItemMonikerImpl* This,IBindCtx* pbc, IMoniker* pmkToLeft,
LPOLESTR32 pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut){
HRESULT WINAPI ItemMonikerImpl_ParseDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft,
LPOLESTR32 pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p,%p,%p,%p,%p,%p),stub!\n",This,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
return E_NOTIMPL;
@ -365,7 +398,9 @@ HRESULT WINAPI ItemMonikerImpl_ParseDisplayName(ItemMonikerImpl* This,IBindCtx*
/******************************************************************************
* ItemMoniker_IsSystemMonker
******************************************************************************/
HRESULT WINAPI ItemMonikerImpl_IsSystemMoniker(ItemMonikerImpl* This,DWORD* pwdMksys){
HRESULT WINAPI ItemMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
{
ItemMonikerImpl* This=(ItemMonikerImpl*)iface;
FIXME(ole,"(%p,%p),stub!\n",This,pwdMksys);
return E_NOTIMPL;
@ -402,7 +437,7 @@ HRESULT WINAPI CreateItemMoniker32(LPCOLESTR32 lpszDelim,LPCOLESTR32 lpszItem,
if (FAILED(hr))
return hr;
hr = ItemMonikerImpl_QueryInterface(newItemMoniker,&IID_IMoniker,(void**)ppmk);
hr = ItemMonikerImpl_QueryInterface((IMoniker*)newItemMoniker,&IID_IMoniker,(void**)ppmk);
return hr;
}

84
ole/stg_stream.c
View File

@ -28,24 +28,20 @@
*/
static ICOM_VTABLE(IStream32) StgStreamImpl_Vtbl =
{
{
{
VTABLE_FUNC(StgStreamImpl_QueryInterface),
VTABLE_FUNC(StgStreamImpl_AddRef),
VTABLE_FUNC(StgStreamImpl_Release)
},
VTABLE_FUNC(StgStreamImpl_Read),
VTABLE_FUNC(StgStreamImpl_Write)
},
VTABLE_FUNC(StgStreamImpl_Seek),
VTABLE_FUNC(StgStreamImpl_SetSize),
VTABLE_FUNC(StgStreamImpl_CopyTo),
VTABLE_FUNC(StgStreamImpl_Commit),
VTABLE_FUNC(StgStreamImpl_Revert),
VTABLE_FUNC(StgStreamImpl_LockRegion),
VTABLE_FUNC(StgStreamImpl_UnlockRegion),
VTABLE_FUNC(StgStreamImpl_Stat),
VTABLE_FUNC(StgStreamImpl_Clone)
StgStreamImpl_QueryInterface,
StgStreamImpl_AddRef,
StgStreamImpl_Release,
StgStreamImpl_Read,
StgStreamImpl_Write,
StgStreamImpl_Seek,
StgStreamImpl_SetSize,
StgStreamImpl_CopyTo,
StgStreamImpl_Commit,
StgStreamImpl_Revert,
StgStreamImpl_LockRegion,
StgStreamImpl_UnlockRegion,
StgStreamImpl_Stat,
StgStreamImpl_Clone
};
/******************************************************************************
@ -80,7 +76,7 @@ StgStreamImpl* StgStreamImpl_Construct(
* stream out-lives the storage in the client application.
*/
newStream->parentStorage = parentStorage;
IStorage32_AddRef(newStream->parentStorage);
IStorage32_AddRef((IStorage32*)newStream->parentStorage);
newStream->ownerProperty = ownerProperty;
@ -120,7 +116,7 @@ void StgStreamImpl_Destroy(StgStreamImpl* This)
/*
* Release the reference we are holding on the parent storage.
*/
IStorage32_Release(This->parentStorage);
IStorage32_Release((IStorage32*)This->parentStorage);
This->parentStorage = 0;
/*
@ -149,10 +145,12 @@ void StgStreamImpl_Destroy(StgStreamImpl* This)
* class
*/
HRESULT WINAPI StgStreamImpl_QueryInterface(
StgStreamImpl* This,
IStream32* iface,
REFIID riid, /* [in] */
void** ppvObject) /* [iid_is][out] */
{
StgStreamImpl* const This=(StgStreamImpl*)iface;
/*
* Perform a sanity check on the parameters.
*/
@ -186,7 +184,7 @@ HRESULT WINAPI StgStreamImpl_QueryInterface(
* Query Interface always increases the reference count by one when it is
* successful
*/
StgStreamImpl_AddRef(This);
StgStreamImpl_AddRef(iface);
return S_OK;;
}
@ -196,8 +194,10 @@ HRESULT WINAPI StgStreamImpl_QueryInterface(
* class
*/
ULONG WINAPI StgStreamImpl_AddRef(
StgStreamImpl* This)
IStream32* iface)
{
StgStreamImpl* const This=(StgStreamImpl*)iface;
This->ref++;
return This->ref;
@ -208,8 +208,10 @@ ULONG WINAPI StgStreamImpl_AddRef(
* class
*/
ULONG WINAPI StgStreamImpl_Release(
StgStreamImpl* This)
IStream32* iface)
{
StgStreamImpl* const This=(StgStreamImpl*)iface;
ULONG newRef;
This->ref--;
@ -303,11 +305,13 @@ void StgStreamImpl_OpenBlockChain(
* See the documentation of ISequentialStream for more info.
*/
HRESULT WINAPI StgStreamImpl_Read(
StgStreamImpl* This,
IStream32* iface,
void* pv, /* [length_is][size_is][out] */
ULONG cb, /* [in] */
ULONG* pcbRead) /* [out] */
{
StgStreamImpl* const This=(StgStreamImpl*)iface;
ULONG bytesReadBuffer;
ULONG bytesToReadFromBuffer;
@ -381,11 +385,13 @@ HRESULT WINAPI StgStreamImpl_Read(
* See the documentation of ISequentialStream for more info.
*/
HRESULT WINAPI StgStreamImpl_Write(
StgStreamImpl* This,
IStream32* iface,
const void* pv, /* [size_is][in] */
ULONG cb, /* [in] */
ULONG* pcbWritten) /* [out] */
{
StgStreamImpl* const This=(StgStreamImpl*)iface;
ULARGE_INTEGER newSize;
ULONG bytesWritten = 0;
@ -412,7 +418,7 @@ HRESULT WINAPI StgStreamImpl_Write(
if (newSize.LowPart > This->streamSize.LowPart)
{
/* grow stream */
StgStreamImpl_SetSize(This, newSize);
StgStreamImpl_SetSize(iface, newSize);
}
/*
@ -456,11 +462,13 @@ HRESULT WINAPI StgStreamImpl_Write(
* See the documentation of IStream for more info.
*/
HRESULT WINAPI StgStreamImpl_Seek(
StgStreamImpl* This,
IStream32* iface,
LARGE_INTEGER dlibMove, /* [in] */
DWORD dwOrigin, /* [in] */
ULARGE_INTEGER* plibNewPosition) /* [out] */
{
StgStreamImpl* const This=(StgStreamImpl*)iface;
ULARGE_INTEGER newPosition;
/*
@ -531,9 +539,11 @@ HRESULT WINAPI StgStreamImpl_Seek(
* See the documentation of IStream for more info.
*/
HRESULT WINAPI StgStreamImpl_SetSize(
StgStreamImpl* This,
IStream32* iface,
ULARGE_INTEGER libNewSize) /* [in] */
{
StgStreamImpl* const This=(StgStreamImpl*)iface;
StgProperty curProperty;
BOOL32 Success;
@ -621,7 +631,7 @@ HRESULT WINAPI StgStreamImpl_SetSize(
}
HRESULT WINAPI StgStreamImpl_CopyTo(
StgStreamImpl* This,
IStream32* iface,
IStream32* pstm, /* [unique][in] */
ULARGE_INTEGER cb, /* [in] */
ULARGE_INTEGER* pcbRead, /* [out] */
@ -639,7 +649,7 @@ HRESULT WINAPI StgStreamImpl_CopyTo(
* See the documentation of IStream for more info.
*/
HRESULT WINAPI StgStreamImpl_Commit(
StgStreamImpl* This,
IStream32* iface,
DWORD grfCommitFlags) /* [in] */
{
return S_OK;
@ -654,13 +664,13 @@ HRESULT WINAPI StgStreamImpl_Commit(
* See the documentation of IStream for more info.
*/
HRESULT WINAPI StgStreamImpl_Revert(
StgStreamImpl* This)
IStream32* iface)
{
return S_OK;
}
HRESULT WINAPI StgStreamImpl_LockRegion(
StgStreamImpl* This,
IStream32* iface,
ULARGE_INTEGER libOffset, /* [in] */
ULARGE_INTEGER cb, /* [in] */
DWORD dwLockType) /* [in] */
@ -669,7 +679,7 @@ HRESULT WINAPI StgStreamImpl_LockRegion(
}
HRESULT WINAPI StgStreamImpl_UnlockRegion(
StgStreamImpl* This,
IStream32* iface,
ULARGE_INTEGER libOffset, /* [in] */
ULARGE_INTEGER cb, /* [in] */
DWORD dwLockType) /* [in] */
@ -686,10 +696,12 @@ HRESULT WINAPI StgStreamImpl_UnlockRegion(
* See the documentation of IStream for more info.
*/
HRESULT WINAPI StgStreamImpl_Stat(
StgStreamImpl* This,
IStream32* iface,
STATSTG* pstatstg, /* [out] */
DWORD grfStatFlag) /* [in] */
{
StgStreamImpl* const This=(StgStreamImpl*)iface;
StgProperty curProperty;
BOOL32 readSucessful;
@ -713,7 +725,7 @@ HRESULT WINAPI StgStreamImpl_Stat(
}
HRESULT WINAPI StgStreamImpl_Clone(
StgStreamImpl* This,
IStream32* iface,
IStream32** ppstm) /* [out] */
{
return E_NOTIMPL;

272
ole/storage32.c
View File

@ -89,55 +89,51 @@ static DWORD GetCreationModeFromSTGM(DWORD stgm);
/*
* Virtual function table for the IStorage32Impl class.
*/
static ICOM_VTABLE(IStorage32) Storage32Impl_VTable =
static ICOM_VTABLE(IStorage32) Storage32Impl_Vtbl =
{
{
VTABLE_FUNC(Storage32BaseImpl_QueryInterface),
VTABLE_FUNC(Storage32BaseImpl_AddRef),
VTABLE_FUNC(Storage32BaseImpl_Release)
},
VTABLE_FUNC(Storage32BaseImpl_CreateStream),
VTABLE_FUNC(Storage32BaseImpl_OpenStream),
VTABLE_FUNC(Storage32Impl_CreateStorage),
VTABLE_FUNC(Storage32BaseImpl_OpenStorage),
VTABLE_FUNC(Storage32Impl_CopyTo),
VTABLE_FUNC(Storage32Impl_MoveElementTo),
VTABLE_FUNC(Storage32Impl_Commit),
VTABLE_FUNC(Storage32Impl_Revert),
VTABLE_FUNC(Storage32BaseImpl_EnumElements),
VTABLE_FUNC(Storage32Impl_DestroyElement),
VTABLE_FUNC(Storage32BaseImpl_RenameElement),
VTABLE_FUNC(Storage32Impl_SetElementTimes),
VTABLE_FUNC(Storage32BaseImpl_SetClass),
VTABLE_FUNC(Storage32Impl_SetStateBits),
VTABLE_FUNC(Storage32BaseImpl_Stat)
Storage32BaseImpl_QueryInterface,
Storage32BaseImpl_AddRef,
Storage32BaseImpl_Release,
Storage32BaseImpl_CreateStream,
Storage32BaseImpl_OpenStream,
Storage32Impl_CreateStorage,
Storage32BaseImpl_OpenStorage,
Storage32Impl_CopyTo,
Storage32Impl_MoveElementTo,
Storage32Impl_Commit,
Storage32Impl_Revert,
Storage32BaseImpl_EnumElements,
Storage32Impl_DestroyElement,
Storage32BaseImpl_RenameElement,
Storage32Impl_SetElementTimes,
Storage32BaseImpl_SetClass,
Storage32Impl_SetStateBits,
Storage32BaseImpl_Stat
};
/*
* Virtual function table for the Storage32InternalImpl class.
*/
static ICOM_VTABLE(IStorage32) Storage32InternalImpl_VTable =
{
static ICOM_VTABLE(IStorage32) Storage32InternalImpl_Vtbl =
{
VTABLE_FUNC(Storage32BaseImpl_QueryInterface),
VTABLE_FUNC(Storage32BaseImpl_AddRef),
VTABLE_FUNC(Storage32BaseImpl_Release)
},
VTABLE_FUNC(Storage32BaseImpl_CreateStream),
VTABLE_FUNC(Storage32BaseImpl_OpenStream),
VTABLE_FUNC(Storage32Impl_CreateStorage),
VTABLE_FUNC(Storage32BaseImpl_OpenStorage),
VTABLE_FUNC(Storage32Impl_CopyTo),
VTABLE_FUNC(Storage32Impl_MoveElementTo),
VTABLE_FUNC(Storage32InternalImpl_Commit),
VTABLE_FUNC(Storage32InternalImpl_Revert),
VTABLE_FUNC(Storage32BaseImpl_EnumElements),
VTABLE_FUNC(Storage32Impl_DestroyElement),
VTABLE_FUNC(Storage32BaseImpl_RenameElement),
VTABLE_FUNC(Storage32Impl_SetElementTimes),
VTABLE_FUNC(Storage32BaseImpl_SetClass),
VTABLE_FUNC(Storage32Impl_SetStateBits),
VTABLE_FUNC(Storage32BaseImpl_Stat)
Storage32BaseImpl_QueryInterface,
Storage32BaseImpl_AddRef,
Storage32BaseImpl_Release,
Storage32BaseImpl_CreateStream,
Storage32BaseImpl_OpenStream,
Storage32Impl_CreateStorage,
Storage32BaseImpl_OpenStorage,
Storage32Impl_CopyTo,
Storage32Impl_MoveElementTo,
Storage32InternalImpl_Commit,
Storage32InternalImpl_Revert,
Storage32BaseImpl_EnumElements,
Storage32Impl_DestroyElement,
Storage32BaseImpl_RenameElement,
Storage32Impl_SetElementTimes,
Storage32BaseImpl_SetClass,
Storage32Impl_SetStateBits,
Storage32BaseImpl_Stat
};
/*
@ -145,15 +141,13 @@ static ICOM_VTABLE(IStorage32) Storage32InternalImpl_VTable =
*/
static ICOM_VTABLE(IEnumSTATSTG) IEnumSTATSTGImpl_Vtbl =
{
{
VTABLE_FUNC(IEnumSTATSTGImpl_QueryInterface),
VTABLE_FUNC(IEnumSTATSTGImpl_AddRef),
VTABLE_FUNC(IEnumSTATSTGImpl_Release)
},
VTABLE_FUNC(IEnumSTATSTGImpl_Next),
VTABLE_FUNC(IEnumSTATSTGImpl_Skip),
VTABLE_FUNC(IEnumSTATSTGImpl_Reset),
VTABLE_FUNC(IEnumSTATSTGImpl_Clone)
IEnumSTATSTGImpl_QueryInterface,
IEnumSTATSTGImpl_AddRef,
IEnumSTATSTGImpl_Release,
IEnumSTATSTGImpl_Next,
IEnumSTATSTGImpl_Skip,
IEnumSTATSTGImpl_Reset,
IEnumSTATSTGImpl_Clone
};
@ -173,10 +167,11 @@ static ICOM_VTABLE(IEnumSTATSTG) IEnumSTATSTGImpl_Vtbl =
* See Windows documentation for more details on IUnknown methods.
*/
HRESULT WINAPI Storage32BaseImpl_QueryInterface(
Storage32BaseImpl* This,
IStorage32* iface,
REFIID riid,
void** ppvObject)
{
ICOM_THIS(Storage32BaseImpl,iface);
/*
* Perform a sanity check on the parameters.
*/
@ -210,9 +205,9 @@ HRESULT WINAPI Storage32BaseImpl_QueryInterface(
* Query Interface always increases the reference count by one when it is
* successful
*/
Storage32BaseImpl_AddRef(This);
Storage32BaseImpl_AddRef(iface);
return S_OK;;
return S_OK;
}
/************************************************************************
@ -224,8 +219,9 @@ HRESULT WINAPI Storage32BaseImpl_QueryInterface(
* See Windows documentation for more details on IUnknown methods.
*/
ULONG WINAPI Storage32BaseImpl_AddRef(
Storage32BaseImpl* This)
IStorage32* iface)
{
ICOM_THIS(Storage32BaseImpl,iface);
This->ref++;
return This->ref;
@ -240,8 +236,9 @@ ULONG WINAPI Storage32BaseImpl_AddRef(
* See Windows documentation for more details on IUnknown methods.
*/
ULONG WINAPI Storage32BaseImpl_Release(
Storage32BaseImpl* This)
IStorage32* iface)
{
ICOM_THIS(Storage32BaseImpl,iface);
/*
* Decrease the reference count on this object.
*/
@ -273,13 +270,14 @@ ULONG WINAPI Storage32BaseImpl_Release(
* See Windows documentation for more details on IStorage methods.
*/
HRESULT WINAPI Storage32BaseImpl_OpenStream(
Storage32BaseImpl* This,
IStorage32* iface,
const OLECHAR32* pwcsName, /* [string][in] */
void* reserved1, /* [unique][in] */
DWORD grfMode, /* [in] */
DWORD reserved2, /* [in] */
IStream32** ppstm) /* [out] */
{
ICOM_THIS(Storage32BaseImpl,iface);
IEnumSTATSTGImpl* propertyEnumeration;
StgStreamImpl* newStream;
StgProperty currentProperty;
@ -340,13 +338,13 @@ HRESULT WINAPI Storage32BaseImpl_OpenStream(
if (newStream!=0)
{
*ppstm = (IStream32*)newStream;
/*
* Since we are returning a pointer to the interface, we have to
* nail down the reference.
*/
StgStreamImpl_AddRef(newStream);
*ppstm = (IStream32*)newStream;
StgStreamImpl_AddRef(*ppstm);
return S_OK;
}
@ -365,7 +363,7 @@ HRESULT WINAPI Storage32BaseImpl_OpenStream(
* See Windows documentation for more details on IStorage methods.
*/
HRESULT WINAPI Storage32BaseImpl_OpenStorage(
Storage32BaseImpl* This,
IStorage32* iface,
const OLECHAR32* pwcsName, /* [string][unique][in] */
IStorage32* pstgPriority, /* [unique][in] */
DWORD grfMode, /* [in] */
@ -373,6 +371,7 @@ HRESULT WINAPI Storage32BaseImpl_OpenStorage(
DWORD reserved, /* [in] */
IStorage32** ppstg) /* [out] */
{
ICOM_THIS(Storage32BaseImpl,iface);
Storage32InternalImpl* newStorage;
IEnumSTATSTGImpl* propertyEnumeration;
StgProperty currentProperty;
@ -438,13 +437,13 @@ HRESULT WINAPI Storage32BaseImpl_OpenStorage(
if (newStorage != 0)
{
*ppstg = (IStorage32*)newStorage;
/*
* Since we are returning a pointer to the interface,
* we have to nail down the reference.
*/
Storage32BaseImpl_AddRef((Storage32BaseImpl*)newStorage);
*ppstg = (IStorage32*)newStorage;
Storage32BaseImpl_AddRef(*ppstg);
return S_OK;
}
@ -464,12 +463,13 @@ HRESULT WINAPI Storage32BaseImpl_OpenStorage(
* See Windows documentation for more details on IStorage methods.
*/
HRESULT WINAPI Storage32BaseImpl_EnumElements(
Storage32BaseImpl* This,
IStorage32* iface,
DWORD reserved1, /* [in] */
void* reserved2, /* [size_is][unique][in] */
DWORD reserved3, /* [in] */
IEnumSTATSTG** ppenum) /* [out] */
{
ICOM_THIS(Storage32BaseImpl,iface);
IEnumSTATSTGImpl* newEnum;
/*
@ -487,13 +487,13 @@ HRESULT WINAPI Storage32BaseImpl_EnumElements(
if (newEnum!=0)
{
*ppenum = (IEnumSTATSTG*)newEnum;
/*
* Don't forget to nail down a reference to the new object before
* returning it.
*/
IEnumSTATSTGImpl_AddRef(newEnum);
*ppenum = (IEnumSTATSTG*)newEnum;
IEnumSTATSTGImpl_AddRef(*ppenum);
return S_OK;
}
@ -509,10 +509,11 @@ HRESULT WINAPI Storage32BaseImpl_EnumElements(
* See Windows documentation for more details on IStorage methods.
*/
HRESULT WINAPI Storage32BaseImpl_Stat(
Storage32BaseImpl* This,
IStorage32* iface,
STATSTG* pstatstg, /* [out] */
DWORD grfStatFlag) /* [in] */
{
ICOM_THIS(Storage32BaseImpl,iface);
StgProperty curProperty;
BOOL32 readSucessful;
@ -555,10 +556,11 @@ HRESULT WINAPI Storage32BaseImpl_Stat(
* perform a DestroyElement of the old StgProperty.
*/
HRESULT WINAPI Storage32BaseImpl_RenameElement(
Storage32BaseImpl* This,
IStorage32* iface,
const OLECHAR32* pwcsOldName, /* [in] */
const OLECHAR32* pwcsNewName) /* [in] */
{
ICOM_THIS(Storage32BaseImpl,iface);
IEnumSTATSTGImpl* propertyEnumeration;
StgProperty currentProperty;
ULONG foundPropertyIndex;
@ -585,7 +587,7 @@ HRESULT WINAPI Storage32BaseImpl_RenameElement(
return STG_E_FILEALREADYEXISTS;
}
IEnumSTATSTGImpl_Reset(propertyEnumeration);
IEnumSTATSTGImpl_Reset((IEnumSTATSTG*)propertyEnumeration);
/*
* Search the enumeration for the old property name
@ -680,7 +682,7 @@ HRESULT WINAPI Storage32BaseImpl_RenameElement(
* Invoke Destroy to get rid of the ole property and automatically redo
* the linking of it's previous and next members...
*/
Storage32Impl_DestroyElement(This->ancestorStorage, pwcsOldName);
Storage32Impl_DestroyElement((IStorage32*)This->ancestorStorage, pwcsOldName);
}
else
@ -702,13 +704,14 @@ HRESULT WINAPI Storage32BaseImpl_RenameElement(
* See Windows documentation for more details on IStorage methods.
*/
HRESULT WINAPI Storage32BaseImpl_CreateStream(
Storage32BaseImpl* This,
IStorage32* iface,
const OLECHAR32* pwcsName, /* [string][in] */
DWORD grfMode, /* [in] */
DWORD reserved1, /* [in] */
DWORD reserved2, /* [in] */
IStream32** ppstm) /* [out] */
{
ICOM_THIS(Storage32BaseImpl,iface);
IEnumSTATSTGImpl* propertyEnumeration;
StgStreamImpl* newStream;
StgProperty currentProperty, newStreamProperty;
@ -760,7 +763,7 @@ HRESULT WINAPI Storage32BaseImpl_CreateStream(
* An element with this name already exists
*/
if (grfMode & STGM_CREATE)
Storage32Impl_DestroyElement(This->ancestorStorage, pwcsName);
Storage32Impl_DestroyElement((IStorage32*)This->ancestorStorage, pwcsName);
else
return STG_E_FILEALREADYEXISTS;
}
@ -824,13 +827,13 @@ HRESULT WINAPI Storage32BaseImpl_CreateStream(
if (newStream != 0)
{
*ppstm = (IStream32*)newStream;
/*
* Since we are returning a pointer to the interface, we have to nail down
* the reference.
*/
StgStreamImpl_AddRef(newStream);
*ppstm = (IStream32*)newStream;
StgStreamImpl_AddRef(*ppstm);
}
else
{
@ -849,9 +852,10 @@ HRESULT WINAPI Storage32BaseImpl_CreateStream(
* See Windows documentation for more details on IStorage methods.
*/
HRESULT WINAPI Storage32BaseImpl_SetClass(
Storage32BaseImpl* This,
IStorage32* iface,
REFCLSID clsid) /* [in] */
{
ICOM_THIS(Storage32BaseImpl,iface);
HRESULT hRes = E_FAIL;
StgProperty curProperty;
BOOL32 success;
@ -878,20 +882,22 @@ HRESULT WINAPI Storage32BaseImpl_SetClass(
*/
/************************************************************************
* Storage32Impl_CreateStorage
* Storage32Impl_CreateStorage (IStorage)
*
* This method will create the storage object within the provided storage.
*
* See Windows documentation for more details on IStorage methods.
*/
HRESULT WINAPI Storage32Impl_CreateStorage(
Storage32Impl *This,
IStorage32* iface,
const OLECHAR32 *pwcsName, /* [string][in] */
DWORD grfMode, /* [in] */
DWORD reserved1, /* [in] */
DWORD reserved2, /* [in] */
IStorage32 **ppstg) /* [out] */
{
Storage32Impl* const This=(Storage32Impl*)iface;
IEnumSTATSTGImpl *propertyEnumeration;
StgProperty currentProperty;
StgProperty newProperty;
@ -937,7 +943,7 @@ HRESULT WINAPI Storage32Impl_CreateStorage(
* An element with this name already exists
*/
if (grfMode & STGM_CREATE)
Storage32Impl_DestroyElement(This->ancestorStorage, pwcsName);
Storage32Impl_DestroyElement((IStorage32*)This->ancestorStorage, pwcsName);
else
return STG_E_FILEALREADYEXISTS;
}
@ -997,7 +1003,7 @@ HRESULT WINAPI Storage32Impl_CreateStorage(
* Open it to get a pointer to return.
*/
hr = Storage32BaseImpl_OpenStorage(
(Storage32BaseImpl*)This,
iface,
(OLECHAR32*)pwcsName,
0,
grfMode,
@ -1250,8 +1256,11 @@ static void updatePropertyChain(
}
/*************************************************************************
* CopyTo (IStorage)
*/
HRESULT WINAPI Storage32Impl_CopyTo(
Storage32Impl *This,
IStorage32* iface,
DWORD ciidExclude, /* [in] */
const IID *rgiidExclude,/* [size_is][unique][in] */
SNB32 snbExclude, /* [unique][in] */
@ -1260,8 +1269,11 @@ HRESULT WINAPI Storage32Impl_CopyTo(
return E_NOTIMPL;
}
/*************************************************************************
* MoveElementTo (IStorage)
*/
HRESULT WINAPI Storage32Impl_MoveElementTo(
Storage32Impl *This,
IStorage32* iface,
const OLECHAR32 *pwcsName, /* [string][in] */
IStorage32 *pstgDest, /* [unique][in] */
const OLECHAR32 *pwcsNewName,/* [string][in] */
@ -1270,25 +1282,31 @@ HRESULT WINAPI Storage32Impl_MoveElementTo(
return E_NOTIMPL;
}
/*************************************************************************
* Commit (IStorage)
*/
HRESULT WINAPI Storage32Impl_Commit(
Storage32Impl *This,
IStorage32* iface,
DWORD grfCommitFlags)/* [in] */
{
FIXME(ole, "(%ld): stub!\n", grfCommitFlags);
return S_OK;
}
/*************************************************************************
* Revert (IStorage)
*/
HRESULT WINAPI Storage32Impl_Revert(
Storage32Impl* This)
IStorage32* iface)
{
return E_NOTIMPL;
}
/*************************************************************************
* DestroyElement.
* DestroyElement (IStorage)
*
* Stategy: This implementation is build this way for simplicity not for speed.
* I allways delete the top most element of the enumeration and adjust
* I always delete the top most element of the enumeration and adjust
* the deleted element pointer all the time. This takes longer to
* do but allow to reinvoke DestroyElement whenever we encounter a
* storage object. The optimisation reside in the usage of another
@ -1296,9 +1314,11 @@ HRESULT WINAPI Storage32Impl_Revert(
* first. (postfix order)
*/
HRESULT WINAPI Storage32Impl_DestroyElement(
Storage32Impl *This,
IStorage32* iface,
const OLECHAR32 *pwcsName)/* [string][in] */
{
Storage32Impl* const This=(Storage32Impl*)iface;
IEnumSTATSTGImpl* propertyEnumeration;
HRESULT hr = S_OK;
BOOL32 res;
@ -1434,7 +1454,7 @@ static HRESULT deleteStorageProperty(
* Open the storage and enumerate it
*/
hr = Storage32BaseImpl_OpenStorage(
(Storage32BaseImpl*)parentStorage,
(IStorage32*)parentStorage,
propertyToDeleteName,
0,
STGM_SHARE_EXCLUSIVE,
@ -1461,7 +1481,7 @@ static HRESULT deleteStorageProperty(
if (hr==S_OK)
{
destroyHr = Storage32Impl_DestroyElement(
(Storage32Impl*)childStorage,
(IStorage32*)childStorage,
(OLECHAR32*)currentElement.pwcsName);
CoTaskMemFree(currentElement.pwcsName);
@ -1501,7 +1521,7 @@ static HRESULT deleteStreamProperty(
size.LowPart = 0;
hr = Storage32BaseImpl_OpenStream(
(Storage32BaseImpl*)parentStorage,
(IStorage32*)parentStorage,
(OLECHAR32*)propertyToDelete.name,
NULL,
STGM_SHARE_EXCLUSIVE,
@ -1785,8 +1805,11 @@ static HRESULT adjustPropertyChain(
}
/******************************************************************************
* SetElementTimes (IStorage)
*/
HRESULT WINAPI Storage32Impl_SetElementTimes(
Storage32Impl *This,
IStorage32* iface,
const OLECHAR32 *pwcsName,/* [string][in] */
const FILETIME *pctime, /* [in] */
const FILETIME *patime, /* [in] */
@ -1795,8 +1818,11 @@ HRESULT WINAPI Storage32Impl_SetElementTimes(
return E_NOTIMPL;
}
/******************************************************************************
* SetStateBits (IStorage)
*/
HRESULT WINAPI Storage32Impl_SetStateBits(
Storage32Impl *This,
IStorage32* iface,
DWORD grfStateBits,/* [in] */
DWORD grfMask) /* [in] */
{
@ -1821,7 +1847,7 @@ HRESULT Storage32Impl_Construct(
/*
* Initialize the virtual fgunction table.
*/
This->lpvtbl = &Storage32Impl_VTable;
This->lpvtbl = &Storage32Impl_Vtbl;
This->v_destructor = &Storage32Impl_Destroy;
/*
@ -2743,14 +2769,14 @@ Storage32InternalImpl* Storage32InternalImpl_Construct(
/*
* Initialize the virtual function table.
*/
newStorage->lpvtbl = &Storage32InternalImpl_VTable;
newStorage->lpvtbl = &Storage32InternalImpl_Vtbl;
newStorage->v_destructor = &Storage32InternalImpl_Destroy;
/*
* Keep the ancestor storage pointer and nail a reference to it.
*/
newStorage->ancestorStorage = ancestorStorage;
Storage32BaseImpl_AddRef((Storage32BaseImpl*)(newStorage->ancestorStorage));
Storage32BaseImpl_AddRef((IStorage32*)(newStorage->ancestorStorage));
/*
* Keep the index of the root property set for this storage,
@ -2777,7 +2803,7 @@ void Storage32InternalImpl_Destroy(
** does nothing.
*/
HRESULT WINAPI Storage32InternalImpl_Commit(
Storage32InternalImpl* This,
IStorage32* iface,
DWORD grfCommitFlags) /* [in] */
{
return S_OK;
@ -2791,7 +2817,7 @@ HRESULT WINAPI Storage32InternalImpl_Commit(
** does nothing.
*/
HRESULT WINAPI Storage32InternalImpl_Revert(
Storage32InternalImpl* This)
IStorage32* iface)
{
return S_OK;
}
@ -2821,7 +2847,7 @@ IEnumSTATSTGImpl* IEnumSTATSTGImpl_Construct(
* enumeration out-lives the storage in the client application.
*/
newEnumeration->parentStorage = parentStorage;
IStorage32_AddRef(newEnumeration->parentStorage);
IStorage32_AddRef((IStorage32*)newEnumeration->parentStorage);
newEnumeration->firstPropertyNode = firstPropertyNode;
@ -2836,7 +2862,7 @@ IEnumSTATSTGImpl* IEnumSTATSTGImpl_Construct(
/*
* Make sure the current node of the iterator is the first one.
*/
IEnumSTATSTGImpl_Reset(newEnumeration);
IEnumSTATSTGImpl_Reset((IEnumSTATSTG*)newEnumeration);
}
return newEnumeration;
@ -2844,16 +2870,18 @@ IEnumSTATSTGImpl* IEnumSTATSTGImpl_Construct(
void IEnumSTATSTGImpl_Destroy(IEnumSTATSTGImpl* This)
{
IStorage32_Release(This->parentStorage);
IStorage32_Release((IStorage32*)This->parentStorage);
HeapFree(GetProcessHeap(), 0, This->stackToVisit);
HeapFree(GetProcessHeap(), 0, This);
}
HRESULT WINAPI IEnumSTATSTGImpl_QueryInterface(
IEnumSTATSTGImpl* This,
IEnumSTATSTG* iface,
REFIID riid,
void** ppvObject)
{
IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
/*
* Perform a sanity check on the parameters.
*/
@ -2887,21 +2915,25 @@ HRESULT WINAPI IEnumSTATSTGImpl_QueryInterface(
* Query Interface always increases the reference count by one when it is
* successful
*/
IEnumSTATSTGImpl_AddRef(This);
IEnumSTATSTGImpl_AddRef((IEnumSTATSTG*)This);
return S_OK;;
return S_OK;
}
ULONG WINAPI IEnumSTATSTGImpl_AddRef(
IEnumSTATSTGImpl* This)
IEnumSTATSTG* iface)
{
IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
This->ref++;
return This->ref;
}
ULONG WINAPI IEnumSTATSTGImpl_Release(
IEnumSTATSTGImpl* This)
IEnumSTATSTG* iface)
{
IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
ULONG newRef;
This->ref--;
@ -2919,11 +2951,13 @@ ULONG WINAPI IEnumSTATSTGImpl_Release(
}
HRESULT WINAPI IEnumSTATSTGImpl_Next(
IEnumSTATSTGImpl* This,
IEnumSTATSTG* iface,
ULONG celt,
STATSTG* rgelt,
ULONG* pceltFetched)
{
IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
StgProperty currentProperty;
STATSTG* currentReturnStruct = rgelt;
ULONG objectFetched = 0;
@ -3000,9 +3034,11 @@ HRESULT WINAPI IEnumSTATSTGImpl_Next(
HRESULT WINAPI IEnumSTATSTGImpl_Skip(
IEnumSTATSTGImpl* This,
IEnumSTATSTG* iface,
ULONG celt)
{
IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
StgProperty currentProperty;
ULONG objectFetched = 0;
ULONG currentSearchNode;
@ -3050,8 +3086,10 @@ HRESULT WINAPI IEnumSTATSTGImpl_Skip(
}
HRESULT WINAPI IEnumSTATSTGImpl_Reset(
IEnumSTATSTGImpl* This)
IEnumSTATSTG* iface)
{
IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
StgProperty rootProperty;
BOOL32 readSucessful;
@ -3082,9 +3120,11 @@ HRESULT WINAPI IEnumSTATSTGImpl_Reset(
}
HRESULT WINAPI IEnumSTATSTGImpl_Clone(
IEnumSTATSTGImpl* This,
IEnumSTATSTG* iface,
IEnumSTATSTG** ppenum)
{
IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
IEnumSTATSTGImpl* newClone;
/*
@ -3111,13 +3151,13 @@ HRESULT WINAPI IEnumSTATSTGImpl_Clone(
This->stackToVisit,
sizeof(ULONG) * newClone->stackSize);
*ppenum = (IEnumSTATSTG*)newClone;
/*
* Don't forget to nail down a reference to the clone before
* returning it.
*/
IEnumSTATSTGImpl_AddRef(newClone);
*ppenum = (IEnumSTATSTG*)newClone;
IEnumSTATSTGImpl_AddRef(*ppenum);
return S_OK;
}
@ -4609,7 +4649,7 @@ HRESULT WINAPI StgCreateDocfile32(
* Get an "out" pointer for the caller.
*/
hr = Storage32BaseImpl_QueryInterface(
(Storage32BaseImpl*)newStorage,
(IStorage32*)newStorage,
(REFIID)&IID_IStorage,
(void**)ppstgOpen);
@ -4690,7 +4730,7 @@ HRESULT WINAPI StgOpenStorage32(
* Get an "out" pointer for the caller.
*/
hr = Storage32BaseImpl_QueryInterface(
(Storage32BaseImpl*)newStorage,
(IStorage32*)newStorage,
(REFIID)&IID_IStorage,
(void**)ppstgOpen);

92
ole/storage32.h
View File

@ -68,16 +68,6 @@ static const ULONG PROPERTY_NULL = 0xFFFFFFFF;
#define PROPTYPE_STREAM 0x02
#define PROPTYPE_ROOT 0x05
/*
* This define allows me to assign a function to a vtable without having the
* nasty warning about incompatible types.
*
* This is necessary because of the usage of implementation classes pointers
* as the first parameter of the interface functions instead of the pointer
* to the interface
*/
#define VTABLE_FUNC(a) ((void*)a)
/*
* These defines assume a hardcoded blocksize. The code will assert
* if the blocksize is different. Some changes will have to be done if it
@ -206,18 +196,18 @@ struct Storage32BaseImpl
* Prototypes for the methods of the Storage32BaseImpl class.
*/
HRESULT WINAPI Storage32BaseImpl_QueryInterface(
Storage32BaseImpl* This,
IStorage32* iface,
REFIID riid,
void** ppvObject);
ULONG WINAPI Storage32BaseImpl_AddRef(
Storage32BaseImpl* This);
IStorage32* iface);
ULONG WINAPI Storage32BaseImpl_Release(
Storage32BaseImpl* This);
IStorage32* iface);
HRESULT WINAPI Storage32BaseImpl_OpenStream(
Storage32BaseImpl* This,
IStorage32* iface,
const OLECHAR32* pwcsName, /* [string][in] */
void* reserved1, /* [unique][in] */
DWORD grfMode, /* [in] */
@ -225,7 +215,7 @@ HRESULT WINAPI Storage32BaseImpl_OpenStream(
IStream32** ppstm); /* [out] */
HRESULT WINAPI Storage32BaseImpl_OpenStorage(
Storage32BaseImpl* This,
IStorage32* iface,
const OLECHAR32* pwcsName, /* [string][unique][in] */
IStorage32* pstgPriority, /* [unique][in] */
DWORD grfMode, /* [in] */
@ -234,24 +224,24 @@ HRESULT WINAPI Storage32BaseImpl_OpenStorage(
IStorage32** ppstg); /* [out] */
HRESULT WINAPI Storage32BaseImpl_EnumElements(
Storage32BaseImpl* This,
IStorage32* iface,
DWORD reserved1, /* [in] */
void* reserved2, /* [size_is][unique][in] */
DWORD reserved3, /* [in] */
IEnumSTATSTG** ppenum); /* [out] */
HRESULT WINAPI Storage32BaseImpl_Stat(
Storage32BaseImpl* This,
IStorage32* iface,
STATSTG* pstatstg, /* [out] */
DWORD grfStatFlag); /* [in] */
HRESULT WINAPI Storage32BaseImpl_RenameElement(
Storage32BaseImpl* This,
IStorage32* iface,
const OLECHAR32* pwcsOldName, /* [string][in] */
const OLECHAR32* pwcsNewName); /* [string][in] */
HRESULT WINAPI Storage32BaseImpl_CreateStream(
Storage32BaseImpl* This,
IStorage32* iface,
const OLECHAR32* pwcsName, /* [string][in] */
DWORD grfMode, /* [in] */
DWORD reserved1, /* [in] */
@ -259,7 +249,7 @@ HRESULT WINAPI Storage32BaseImpl_CreateStream(
IStream32** ppstm); /* [out] */
HRESULT WINAPI Storage32BaseImpl_SetClass(
Storage32BaseImpl* This,
IStorage32* iface,
REFCLSID clsid); /* [in] */
/****************************************************************************
@ -320,7 +310,7 @@ struct Storage32Impl
*/
HRESULT WINAPI Storage32Impl_CreateStorage(
Storage32Impl* This,
IStorage32* iface,
const OLECHAR32* pwcsName, /* [string][in] */
DWORD grfMode, /* [in] */
DWORD dwStgFmt, /* [in] */
@ -328,39 +318,39 @@ HRESULT WINAPI Storage32Impl_CreateStorage(
IStorage32** ppstg); /* [out] */
HRESULT WINAPI Storage32Impl_CopyTo(
Storage32Impl* This,
IStorage32* iface,
DWORD ciidExclude, /* [in] */
const IID* rgiidExclude, /* [size_is][unique][in] */
SNB32 snbExclude, /* [unique][in] */
IStorage32* pstgDest); /* [unique][in] */
HRESULT WINAPI Storage32Impl_MoveElementTo(
Storage32Impl* This,
IStorage32* iface,
const OLECHAR32* pwcsName, /* [string][in] */
IStorage32* pstgDest, /* [unique][in] */
const OLECHAR32* pwcsNewName, /* [string][in] */
DWORD grfFlags); /* [in] */
HRESULT WINAPI Storage32Impl_Commit(
Storage32Impl* This,
IStorage32* iface,
DWORD grfCommitFlags); /* [in] */
HRESULT WINAPI Storage32Impl_Revert(
Storage32Impl* This);
IStorage32* iface);
HRESULT WINAPI Storage32Impl_DestroyElement(
Storage32Impl* This,
IStorage32* iface,
const OLECHAR32* pwcsName); /* [string][in] */
HRESULT WINAPI Storage32Impl_SetElementTimes(
Storage32Impl* This,
IStorage32* iface,
const OLECHAR32* pwcsName, /* [string][in] */
const FILETIME* pctime, /* [in] */
const FILETIME* patime, /* [in] */
const FILETIME* pmtime); /* [in] */
HRESULT WINAPI Storage32Impl_SetStateBits(
Storage32Impl* This,
IStorage32* iface,
DWORD grfStateBits, /* [in] */
DWORD grfMask); /* [in] */
@ -467,11 +457,11 @@ void Storage32InternalImpl_Destroy(
Storage32InternalImpl* This);
HRESULT WINAPI Storage32InternalImpl_Commit(
Storage32InternalImpl* This,
IStorage32* iface,
DWORD grfCommitFlags); /* [in] */
HRESULT WINAPI Storage32InternalImpl_Revert(
Storage32InternalImpl* This);
IStorage32* iface);
/****************************************************************************
@ -506,31 +496,31 @@ struct IEnumSTATSTGImpl
* Method definitions for the IEnumSTATSTGImpl class.
*/
HRESULT WINAPI IEnumSTATSTGImpl_QueryInterface(
IEnumSTATSTGImpl* This,
IEnumSTATSTG* iface,
REFIID riid,
void** ppvObject);
ULONG WINAPI IEnumSTATSTGImpl_AddRef(
IEnumSTATSTGImpl* This);
IEnumSTATSTG* iface);
ULONG WINAPI IEnumSTATSTGImpl_Release(
IEnumSTATSTGImpl* This);
IEnumSTATSTG* iface);
HRESULT WINAPI IEnumSTATSTGImpl_Next(
IEnumSTATSTGImpl* This,
IEnumSTATSTG* iface,
ULONG celt,
STATSTG* rgelt,
ULONG* pceltFetched);
HRESULT WINAPI IEnumSTATSTGImpl_Skip(
IEnumSTATSTGImpl* This,
IEnumSTATSTG* iface,
ULONG celt);
HRESULT WINAPI IEnumSTATSTGImpl_Reset(
IEnumSTATSTGImpl* This);
IEnumSTATSTG* iface);
HRESULT WINAPI IEnumSTATSTGImpl_Clone(
IEnumSTATSTGImpl* This,
IEnumSTATSTG* iface,
IEnumSTATSTG** ppenum);
IEnumSTATSTGImpl* IEnumSTATSTGImpl_Construct(
@ -620,71 +610,71 @@ void StgStreamImpl_OpenBlockChain(
StgStreamImpl* This);
HRESULT WINAPI StgStreamImpl_QueryInterface(
StgStreamImpl* This,
IStream32* iface,
REFIID riid, /* [in] */
void** ppvObject); /* [iid_is][out] */
ULONG WINAPI StgStreamImpl_AddRef(
StgStreamImpl* This);
IStream32* iface);
ULONG WINAPI StgStreamImpl_Release(
StgStreamImpl* This);
IStream32* iface);
HRESULT WINAPI StgStreamImpl_Read(
StgStreamImpl* This,
IStream32* iface,
void* pv, /* [length_is][size_is][out] */
ULONG cb, /* [in] */
ULONG* pcbRead); /* [out] */
HRESULT WINAPI StgStreamImpl_Write(
StgStreamImpl* This,
IStream32* iface,
const void* pv, /* [size_is][in] */
ULONG cb, /* [in] */
ULONG* pcbWritten); /* [out] */
HRESULT WINAPI StgStreamImpl_Seek(
StgStreamImpl* This,
IStream32* iface,
LARGE_INTEGER dlibMove, /* [in] */
DWORD dwOrigin, /* [in] */
ULARGE_INTEGER* plibNewPosition); /* [out] */
HRESULT WINAPI StgStreamImpl_SetSize(
StgStreamImpl* This,
IStream32* iface,
ULARGE_INTEGER libNewSize); /* [in] */
HRESULT WINAPI StgStreamImpl_CopyTo(
StgStreamImpl* This,
IStream32* iface,
IStream32* pstm, /* [unique][in] */
ULARGE_INTEGER cb, /* [in] */
ULARGE_INTEGER* pcbRead, /* [out] */
ULARGE_INTEGER* pcbWritten); /* [out] */
HRESULT WINAPI StgStreamImpl_Commit(
StgStreamImpl* This,
IStream32* iface,
DWORD grfCommitFlags); /* [in] */
HRESULT WINAPI StgStreamImpl_Revert(
StgStreamImpl* This);
IStream32* iface);
HRESULT WINAPI StgStreamImpl_LockRegion(
StgStreamImpl* This,
IStream32* iface,
ULARGE_INTEGER libOffset, /* [in] */
ULARGE_INTEGER cb, /* [in] */
DWORD dwLockType); /* [in] */
HRESULT WINAPI StgStreamImpl_UnlockRegion(
StgStreamImpl* This,
IStream32* iface,
ULARGE_INTEGER libOffset, /* [in] */
ULARGE_INTEGER cb, /* [in] */
DWORD dwLockType); /* [in] */
HRESULT WINAPI StgStreamImpl_Stat(
StgStreamImpl* This,
IStream32* iface,
STATSTG* pstatstg, /* [out] */
DWORD grfStatFlag); /* [in] */
HRESULT WINAPI StgStreamImpl_Clone(
StgStreamImpl* This,
IStream32* iface,
IStream32** ppstm); /* [out] */