ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/include/objidl.h

8987 lines
268 KiB
C
Raw Blame History

/*** Autogenerated by WIDL 0.1 from objidl.idl - Do not edit ***/
#include "rpc.h"
#include "rpcndr.h"
#ifndef __WIDL_OBJIDL_H
#define __WIDL_OBJIDL_H
#ifdef __cplusplus
extern "C" {
#endif
#include "unknwn.h"
typedef struct IStream IStream;
typedef struct IStream16 IStream16;
typedef struct IEnumString IEnumString;
typedef struct IRunningObjectTable IRunningObjectTable;
typedef struct IMoniker IMoniker;
typedef struct IAdviseSink IAdviseSink;
typedef struct IAsyncManager IAsyncManager;
typedef struct IMarshal IMarshal;
typedef IMarshal *LPMARSHAL;
/*****************************************************************************
* IMarshal interface
*/
DEFINE_GUID(IID_IMarshal, 0x00000003, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IMarshal: IUnknown {
virtual HRESULT CALLBACK GetUnmarshalClass(
REFIID riid,
void* pv,
DWORD dwDestContext,
void* pvDestContext,
DWORD mshlflags,
CLSID* pCid) = 0;
virtual HRESULT CALLBACK GetMarshalSizeMax(
REFIID riid,
void* pv,
DWORD dwDestContext,
void* pvDestContext,
DWORD mshlflags,
DWORD* pSize) = 0;
virtual HRESULT CALLBACK MarshalInterface(
IStream* pStm,
REFIID riid,
void* pv,
DWORD dwDestContext,
void* pvDestContext,
DWORD mshlflags) = 0;
virtual HRESULT CALLBACK UnmarshalInterface(
IStream* pStm,
REFIID riid,
void** ppv) = 0;
virtual HRESULT CALLBACK ReleaseMarshalData(
IStream* pStm) = 0;
virtual HRESULT CALLBACK DisconnectObject(
DWORD dwReserved) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IMarshalVtbl IMarshalVtbl;
struct IMarshal {
const IMarshalVtbl* lpVtbl;
};
struct IMarshalVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IMarshal* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IMarshal* This);
ULONG (CALLBACK *Release)(
IMarshal* This);
/*** IMarshal methods ***/
HRESULT (CALLBACK *GetUnmarshalClass)(
IMarshal* This,
REFIID riid,
void* pv,
DWORD dwDestContext,
void* pvDestContext,
DWORD mshlflags,
CLSID* pCid);
HRESULT (CALLBACK *GetMarshalSizeMax)(
IMarshal* This,
REFIID riid,
void* pv,
DWORD dwDestContext,
void* pvDestContext,
DWORD mshlflags,
DWORD* pSize);
HRESULT (CALLBACK *MarshalInterface)(
IMarshal* This,
IStream* pStm,
REFIID riid,
void* pv,
DWORD dwDestContext,
void* pvDestContext,
DWORD mshlflags);
HRESULT (CALLBACK *UnmarshalInterface)(
IMarshal* This,
IStream* pStm,
REFIID riid,
void** ppv);
HRESULT (CALLBACK *ReleaseMarshalData)(
IMarshal* This,
IStream* pStm);
HRESULT (CALLBACK *DisconnectObject)(
IMarshal* This,
DWORD dwReserved);
};
#define IMarshal_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD6 (HRESULT,GetUnmarshalClass,REFIID,riid,void*,pv,DWORD,dwDestContext,void*,pvDestContext,DWORD,mshlflags,CLSID*,pCid) \
ICOM_METHOD6 (HRESULT,GetMarshalSizeMax,REFIID,riid,void*,pv,DWORD,dwDestContext,void*,pvDestContext,DWORD,mshlflags,DWORD*,pSize) \
ICOM_METHOD6 (HRESULT,MarshalInterface,IStream*,pStm,REFIID,riid,void*,pv,DWORD,dwDestContext,void*,pvDestContext,DWORD,mshlflags) \
ICOM_METHOD3 (HRESULT,UnmarshalInterface,IStream*,pStm,REFIID,riid,void**,ppv) \
ICOM_METHOD1 (HRESULT,ReleaseMarshalData,IStream*,pStm) \
ICOM_METHOD1 (HRESULT,DisconnectObject,DWORD,dwReserved)
/*** IUnknown methods ***/
#define IMarshal_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMarshal_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMarshal_Release(p) (p)->lpVtbl->Release(p)
/*** IMarshal methods ***/
#define IMarshal_GetUnmarshalClass(p,a,b,c,d,e,f) (p)->lpVtbl->GetUnmarshalClass(p,a,b,c,d,e,f)
#define IMarshal_GetMarshalSizeMax(p,a,b,c,d,e,f) (p)->lpVtbl->GetMarshalSizeMax(p,a,b,c,d,e,f)
#define IMarshal_MarshalInterface(p,a,b,c,d,e,f) (p)->lpVtbl->MarshalInterface(p,a,b,c,d,e,f)
#define IMarshal_UnmarshalInterface(p,a,b,c) (p)->lpVtbl->UnmarshalInterface(p,a,b,c)
#define IMarshal_ReleaseMarshalData(p,a) (p)->lpVtbl->ReleaseMarshalData(p,a)
#define IMarshal_DisconnectObject(p,a) (p)->lpVtbl->DisconnectObject(p,a)
#endif
HRESULT CALLBACK IMarshal_GetUnmarshalClass_Proxy(
IMarshal* This,
REFIID riid,
void* pv,
DWORD dwDestContext,
void* pvDestContext,
DWORD mshlflags,
CLSID* pCid);
void __RPC_STUB IMarshal_GetUnmarshalClass_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMarshal_GetMarshalSizeMax_Proxy(
IMarshal* This,
REFIID riid,
void* pv,
DWORD dwDestContext,
void* pvDestContext,
DWORD mshlflags,
DWORD* pSize);
void __RPC_STUB IMarshal_GetMarshalSizeMax_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMarshal_MarshalInterface_Proxy(
IMarshal* This,
IStream* pStm,
REFIID riid,
void* pv,
DWORD dwDestContext,
void* pvDestContext,
DWORD mshlflags);
void __RPC_STUB IMarshal_MarshalInterface_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMarshal_UnmarshalInterface_Proxy(
IMarshal* This,
IStream* pStm,
REFIID riid,
void** ppv);
void __RPC_STUB IMarshal_UnmarshalInterface_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMarshal_ReleaseMarshalData_Proxy(
IMarshal* This,
IStream* pStm);
void __RPC_STUB IMarshal_ReleaseMarshalData_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMarshal_DisconnectObject_Proxy(
IMarshal* This,
DWORD dwReserved);
void __RPC_STUB IMarshal_DisconnectObject_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IStdMarshalInfo IStdMarshalInfo;
typedef IStdMarshalInfo *LPSTDMARSHALINFO;
/*****************************************************************************
* IStdMarshalInfo interface
*/
DEFINE_GUID(IID_IStdMarshalInfo, 0x00000018, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IStdMarshalInfo: IUnknown {
virtual HRESULT CALLBACK GetClassForHandler(
DWORD dwDestContext,
void* pvDestContext,
CLSID* pClsid) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IStdMarshalInfoVtbl IStdMarshalInfoVtbl;
struct IStdMarshalInfo {
const IStdMarshalInfoVtbl* lpVtbl;
};
struct IStdMarshalInfoVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IStdMarshalInfo* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IStdMarshalInfo* This);
ULONG (CALLBACK *Release)(
IStdMarshalInfo* This);
/*** IStdMarshalInfo methods ***/
HRESULT (CALLBACK *GetClassForHandler)(
IStdMarshalInfo* This,
DWORD dwDestContext,
void* pvDestContext,
CLSID* pClsid);
};
#define IStdMarshalInfo_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD3 (HRESULT,GetClassForHandler,DWORD,dwDestContext,void*,pvDestContext,CLSID*,pClsid)
/*** IUnknown methods ***/
#define IStdMarshalInfo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IStdMarshalInfo_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IStdMarshalInfo_Release(p) (p)->lpVtbl->Release(p)
/*** IStdMarshalInfo methods ***/
#define IStdMarshalInfo_GetClassForHandler(p,a,b,c) (p)->lpVtbl->GetClassForHandler(p,a,b,c)
#endif
HRESULT CALLBACK IStdMarshalInfo_GetClassForHandler_Proxy(
IStdMarshalInfo* This,
DWORD dwDestContext,
void* pvDestContext,
CLSID* pClsid);
void __RPC_STUB IStdMarshalInfo_GetClassForHandler_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IExternalConnection IExternalConnection;
typedef IExternalConnection *LPEXTERNALCONNECTION;
typedef enum tagEXTCONN {
EXTCONN_STRONG = 0x1,
EXTCONN_WEAK = 0x2,
EXTCONN_CALLABLE = 0x4
} EXTCONN;
/*****************************************************************************
* IExternalConnection interface
*/
DEFINE_GUID(IID_IExternalConnection, 0x00000019, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IExternalConnection: IUnknown {
virtual DWORD CALLBACK AddConnection(
DWORD extconn,
DWORD reserved) = 0;
virtual DWORD CALLBACK ReleaseConnection(
DWORD extconn,
DWORD reserved,
BOOL fLastReleaseCloses) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IExternalConnectionVtbl IExternalConnectionVtbl;
struct IExternalConnection {
const IExternalConnectionVtbl* lpVtbl;
};
struct IExternalConnectionVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IExternalConnection* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IExternalConnection* This);
ULONG (CALLBACK *Release)(
IExternalConnection* This);
/*** IExternalConnection methods ***/
DWORD (CALLBACK *AddConnection)(
IExternalConnection* This,
DWORD extconn,
DWORD reserved);
DWORD (CALLBACK *ReleaseConnection)(
IExternalConnection* This,
DWORD extconn,
DWORD reserved,
BOOL fLastReleaseCloses);
};
#define IExternalConnection_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD2 (DWORD,AddConnection,DWORD,extconn,DWORD,reserved) \
ICOM_METHOD3 (DWORD,ReleaseConnection,DWORD,extconn,DWORD,reserved,BOOL,fLastReleaseCloses)
/*** IUnknown methods ***/
#define IExternalConnection_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IExternalConnection_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IExternalConnection_Release(p) (p)->lpVtbl->Release(p)
/*** IExternalConnection methods ***/
#define IExternalConnection_AddConnection(p,a,b) (p)->lpVtbl->AddConnection(p,a,b)
#define IExternalConnection_ReleaseConnection(p,a,b,c) (p)->lpVtbl->ReleaseConnection(p,a,b,c)
#endif
DWORD CALLBACK IExternalConnection_AddConnection_Proxy(
IExternalConnection* This,
DWORD extconn,
DWORD reserved);
void __RPC_STUB IExternalConnection_AddConnection_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
DWORD CALLBACK IExternalConnection_ReleaseConnection_Proxy(
IExternalConnection* This,
DWORD extconn,
DWORD reserved,
BOOL fLastReleaseCloses);
void __RPC_STUB IExternalConnection_ReleaseConnection_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IMultiQI IMultiQI;
typedef IMultiQI *LPMULTIQI;
typedef struct tagMULTI_QI {
const IID *pIID;
IUnknown *pItf;
HRESULT hr;
} MULTI_QI;
/*****************************************************************************
* IMultiQI interface
*/
DEFINE_GUID(IID_IMultiQI, 0x00000020, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IMultiQI: IUnknown {
virtual HRESULT CALLBACK QueryMultipleInterfaces(
ULONG cMQIs,
MULTI_QI* pMQIs) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IMultiQIVtbl IMultiQIVtbl;
struct IMultiQI {
const IMultiQIVtbl* lpVtbl;
};
struct IMultiQIVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IMultiQI* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IMultiQI* This);
ULONG (CALLBACK *Release)(
IMultiQI* This);
/*** IMultiQI methods ***/
HRESULT (CALLBACK *QueryMultipleInterfaces)(
IMultiQI* This,
ULONG cMQIs,
MULTI_QI* pMQIs);
};
#define IMultiQI_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD2 (HRESULT,QueryMultipleInterfaces,ULONG,cMQIs,MULTI_QI*,pMQIs)
/*** IUnknown methods ***/
#define IMultiQI_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMultiQI_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMultiQI_Release(p) (p)->lpVtbl->Release(p)
/*** IMultiQI methods ***/
#define IMultiQI_QueryMultipleInterfaces(p,a,b) (p)->lpVtbl->QueryMultipleInterfaces(p,a,b)
#endif
HRESULT CALLBACK IMultiQI_QueryMultipleInterfaces_Proxy(
IMultiQI* This,
ULONG cMQIs,
MULTI_QI* pMQIs);
void __RPC_STUB IMultiQI_QueryMultipleInterfaces_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IMalloc IMalloc;
typedef IMalloc *LPMALLOC;
/*****************************************************************************
* IMalloc interface
*/
DEFINE_GUID(IID_IMalloc, 0x00000002, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IMalloc: IUnknown {
virtual LPVOID CALLBACK Alloc(
ULONG cb) = 0;
virtual LPVOID CALLBACK Realloc(
LPVOID pv,
ULONG cb) = 0;
virtual void CALLBACK Free(
LPVOID pv) = 0;
virtual ULONG CALLBACK GetSize(
LPVOID pv) = 0;
virtual int CALLBACK DidAlloc(
LPVOID pv) = 0;
virtual void CALLBACK HeapMinimize(
) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IMallocVtbl IMallocVtbl;
struct IMalloc {
const IMallocVtbl* lpVtbl;
};
struct IMallocVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IMalloc* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IMalloc* This);
ULONG (CALLBACK *Release)(
IMalloc* This);
/*** IMalloc methods ***/
LPVOID (CALLBACK *Alloc)(
IMalloc* This,
ULONG cb);
LPVOID (CALLBACK *Realloc)(
IMalloc* This,
LPVOID pv,
ULONG cb);
void (CALLBACK *Free)(
IMalloc* This,
LPVOID pv);
ULONG (CALLBACK *GetSize)(
IMalloc* This,
LPVOID pv);
int (CALLBACK *DidAlloc)(
IMalloc* This,
LPVOID pv);
void (CALLBACK *HeapMinimize)(
IMalloc* This);
};
#define IMalloc_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD1 (LPVOID,Alloc,ULONG,cb) \
ICOM_METHOD2 (LPVOID,Realloc,LPVOID,pv,ULONG,cb) \
ICOM_VMETHOD1(Free,LPVOID,pv) \
ICOM_METHOD1 (ULONG,GetSize,LPVOID,pv) \
ICOM_METHOD1 (int,DidAlloc,LPVOID,pv) \
ICOM_VMETHOD (HeapMinimize)
/*** IUnknown methods ***/
#define IMalloc_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMalloc_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMalloc_Release(p) (p)->lpVtbl->Release(p)
/*** IMalloc methods ***/
#define IMalloc_Alloc(p,a) (p)->lpVtbl->Alloc(p,a)
#define IMalloc_Realloc(p,a,b) (p)->lpVtbl->Realloc(p,a,b)
#define IMalloc_Free(p,a) (p)->lpVtbl->Free(p,a)
#define IMalloc_GetSize(p,a) (p)->lpVtbl->GetSize(p,a)
#define IMalloc_DidAlloc(p,a) (p)->lpVtbl->DidAlloc(p,a)
#define IMalloc_HeapMinimize(p) (p)->lpVtbl->HeapMinimize(p)
#endif
LPVOID CALLBACK IMalloc_Alloc_Proxy(
IMalloc* This,
ULONG cb);
void __RPC_STUB IMalloc_Alloc_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
LPVOID CALLBACK IMalloc_Realloc_Proxy(
IMalloc* This,
LPVOID pv,
ULONG cb);
void __RPC_STUB IMalloc_Realloc_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IMalloc_Free_Proxy(
IMalloc* This,
LPVOID pv);
void __RPC_STUB IMalloc_Free_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
ULONG CALLBACK IMalloc_GetSize_Proxy(
IMalloc* This,
LPVOID pv);
void __RPC_STUB IMalloc_GetSize_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
int CALLBACK IMalloc_DidAlloc_Proxy(
IMalloc* This,
LPVOID pv);
void __RPC_STUB IMalloc_DidAlloc_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IMalloc_HeapMinimize_Proxy(
IMalloc* This);
void __RPC_STUB IMalloc_HeapMinimize_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IMallocSpy IMallocSpy;
typedef IMallocSpy *LPMALLOCSPY;
/*****************************************************************************
* IMallocSpy interface
*/
DEFINE_GUID(IID_IMallocSpy, 0x0000001d, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IMallocSpy: IUnknown {
virtual ULONG CALLBACK PreAlloc(
ULONG cbRequest) = 0;
virtual LPVOID CALLBACK PostAlloc(
LPVOID pActual) = 0;
virtual LPVOID CALLBACK PreFree(
LPVOID pRequest,
BOOL fSpyed) = 0;
virtual void CALLBACK PostFree(
BOOL fSpyed) = 0;
virtual ULONG CALLBACK PreRealloc(
LPVOID pRequest,
ULONG cbRequest,
LPVOID* ppNewRequest,
BOOL fSpyed) = 0;
virtual LPVOID CALLBACK PostRealloc(
LPVOID pActual,
BOOL fSpyed) = 0;
virtual LPVOID CALLBACK PreGetSize(
LPVOID pRequest,
BOOL fSpyed) = 0;
virtual ULONG CALLBACK PostGetSize(
ULONG cbActual,
BOOL fSpyed) = 0;
virtual LPVOID CALLBACK PreDidAlloc(
LPVOID pRequest,
BOOL fSpyed) = 0;
virtual int CALLBACK PostDidAlloc(
LPVOID pRequest,
BOOL fSpyed,
int fActual) = 0;
virtual void CALLBACK PreHeapMinimize(
) = 0;
virtual void CALLBACK PostHeapMinimize(
) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IMallocSpyVtbl IMallocSpyVtbl;
struct IMallocSpy {
const IMallocSpyVtbl* lpVtbl;
};
struct IMallocSpyVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IMallocSpy* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IMallocSpy* This);
ULONG (CALLBACK *Release)(
IMallocSpy* This);
/*** IMallocSpy methods ***/
ULONG (CALLBACK *PreAlloc)(
IMallocSpy* This,
ULONG cbRequest);
LPVOID (CALLBACK *PostAlloc)(
IMallocSpy* This,
LPVOID pActual);
LPVOID (CALLBACK *PreFree)(
IMallocSpy* This,
LPVOID pRequest,
BOOL fSpyed);
void (CALLBACK *PostFree)(
IMallocSpy* This,
BOOL fSpyed);
ULONG (CALLBACK *PreRealloc)(
IMallocSpy* This,
LPVOID pRequest,
ULONG cbRequest,
LPVOID* ppNewRequest,
BOOL fSpyed);
LPVOID (CALLBACK *PostRealloc)(
IMallocSpy* This,
LPVOID pActual,
BOOL fSpyed);
LPVOID (CALLBACK *PreGetSize)(
IMallocSpy* This,
LPVOID pRequest,
BOOL fSpyed);
ULONG (CALLBACK *PostGetSize)(
IMallocSpy* This,
ULONG cbActual,
BOOL fSpyed);
LPVOID (CALLBACK *PreDidAlloc)(
IMallocSpy* This,
LPVOID pRequest,
BOOL fSpyed);
int (CALLBACK *PostDidAlloc)(
IMallocSpy* This,
LPVOID pRequest,
BOOL fSpyed,
int fActual);
void (CALLBACK *PreHeapMinimize)(
IMallocSpy* This);
void (CALLBACK *PostHeapMinimize)(
IMallocSpy* This);
};
#define IMallocSpy_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD1 (ULONG,PreAlloc,ULONG,cbRequest) \
ICOM_METHOD1 (LPVOID,PostAlloc,LPVOID,pActual) \
ICOM_METHOD2 (LPVOID,PreFree,LPVOID,pRequest,BOOL,fSpyed) \
ICOM_VMETHOD1(PostFree,BOOL,fSpyed) \
ICOM_METHOD4 (ULONG,PreRealloc,LPVOID,pRequest,ULONG,cbRequest,LPVOID*,ppNewRequest,BOOL,fSpyed) \
ICOM_METHOD2 (LPVOID,PostRealloc,LPVOID,pActual,BOOL,fSpyed) \
ICOM_METHOD2 (LPVOID,PreGetSize,LPVOID,pRequest,BOOL,fSpyed) \
ICOM_METHOD2 (ULONG,PostGetSize,ULONG,cbActual,BOOL,fSpyed) \
ICOM_METHOD2 (LPVOID,PreDidAlloc,LPVOID,pRequest,BOOL,fSpyed) \
ICOM_METHOD3 (int,PostDidAlloc,LPVOID,pRequest,BOOL,fSpyed,int,fActual) \
ICOM_VMETHOD (PreHeapMinimize) \
ICOM_VMETHOD (PostHeapMinimize)
/*** IUnknown methods ***/
#define IMallocSpy_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMallocSpy_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMallocSpy_Release(p) (p)->lpVtbl->Release(p)
/*** IMallocSpy methods ***/
#define IMallocSpy_PreAlloc(p,a) (p)->lpVtbl->PreAlloc(p,a)
#define IMallocSpy_PostAlloc(p,a) (p)->lpVtbl->PostAlloc(p,a)
#define IMallocSpy_PreFree(p,a,b) (p)->lpVtbl->PreFree(p,a,b)
#define IMallocSpy_PostFree(p,a) (p)->lpVtbl->PostFree(p,a)
#define IMallocSpy_PreRealloc(p,a,b,c,d) (p)->lpVtbl->PreRealloc(p,a,b,c,d)
#define IMallocSpy_PostRealloc(p,a,b) (p)->lpVtbl->PostRealloc(p,a,b)
#define IMallocSpy_PreGetSize(p,a,b) (p)->lpVtbl->PreGetSize(p,a,b)
#define IMallocSpy_PostGetSize(p,a,b) (p)->lpVtbl->PostGetSize(p,a,b)
#define IMallocSpy_PreDidAlloc(p,a,b) (p)->lpVtbl->PreDidAlloc(p,a,b)
#define IMallocSpy_PostDidAlloc(p,a,b,c) (p)->lpVtbl->PostDidAlloc(p,a,b,c)
#define IMallocSpy_PreHeapMinimize(p) (p)->lpVtbl->PreHeapMinimize(p)
#define IMallocSpy_PostHeapMinimize(p) (p)->lpVtbl->PostHeapMinimize(p)
#endif
ULONG CALLBACK IMallocSpy_PreAlloc_Proxy(
IMallocSpy* This,
ULONG cbRequest);
void __RPC_STUB IMallocSpy_PreAlloc_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
LPVOID CALLBACK IMallocSpy_PostAlloc_Proxy(
IMallocSpy* This,
LPVOID pActual);
void __RPC_STUB IMallocSpy_PostAlloc_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
LPVOID CALLBACK IMallocSpy_PreFree_Proxy(
IMallocSpy* This,
LPVOID pRequest,
BOOL fSpyed);
void __RPC_STUB IMallocSpy_PreFree_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IMallocSpy_PostFree_Proxy(
IMallocSpy* This,
BOOL fSpyed);
void __RPC_STUB IMallocSpy_PostFree_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
ULONG CALLBACK IMallocSpy_PreRealloc_Proxy(
IMallocSpy* This,
LPVOID pRequest,
ULONG cbRequest,
LPVOID* ppNewRequest,
BOOL fSpyed);
void __RPC_STUB IMallocSpy_PreRealloc_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
LPVOID CALLBACK IMallocSpy_PostRealloc_Proxy(
IMallocSpy* This,
LPVOID pActual,
BOOL fSpyed);
void __RPC_STUB IMallocSpy_PostRealloc_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
LPVOID CALLBACK IMallocSpy_PreGetSize_Proxy(
IMallocSpy* This,
LPVOID pRequest,
BOOL fSpyed);
void __RPC_STUB IMallocSpy_PreGetSize_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
ULONG CALLBACK IMallocSpy_PostGetSize_Proxy(
IMallocSpy* This,
ULONG cbActual,
BOOL fSpyed);
void __RPC_STUB IMallocSpy_PostGetSize_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
LPVOID CALLBACK IMallocSpy_PreDidAlloc_Proxy(
IMallocSpy* This,
LPVOID pRequest,
BOOL fSpyed);
void __RPC_STUB IMallocSpy_PreDidAlloc_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
int CALLBACK IMallocSpy_PostDidAlloc_Proxy(
IMallocSpy* This,
LPVOID pRequest,
BOOL fSpyed,
int fActual);
void __RPC_STUB IMallocSpy_PostDidAlloc_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IMallocSpy_PreHeapMinimize_Proxy(
IMallocSpy* This);
void __RPC_STUB IMallocSpy_PreHeapMinimize_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IMallocSpy_PostHeapMinimize_Proxy(
IMallocSpy* This);
void __RPC_STUB IMallocSpy_PostHeapMinimize_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IEnumUnknown IEnumUnknown;
typedef IEnumUnknown *LPENUMUNKNOWN;
/*****************************************************************************
* IEnumUnknown interface
*/
DEFINE_GUID(IID_IEnumUnknown, 0x00000100, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IEnumUnknown: IUnknown {
virtual HRESULT CALLBACK Next(
ULONG celt,
IUnknown** rgelt,
ULONG* pceltFetched) = 0;
virtual HRESULT CALLBACK Skip(
ULONG celt) = 0;
virtual HRESULT CALLBACK Reset(
) = 0;
virtual HRESULT CALLBACK Clone(
IEnumUnknown** ppenum) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IEnumUnknownVtbl IEnumUnknownVtbl;
struct IEnumUnknown {
const IEnumUnknownVtbl* lpVtbl;
};
struct IEnumUnknownVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IEnumUnknown* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IEnumUnknown* This);
ULONG (CALLBACK *Release)(
IEnumUnknown* This);
/*** IEnumUnknown methods ***/
HRESULT (CALLBACK *Next)(
IEnumUnknown* This,
ULONG celt,
IUnknown** rgelt,
ULONG* pceltFetched);
HRESULT (CALLBACK *Skip)(
IEnumUnknown* This,
ULONG celt);
HRESULT (CALLBACK *Reset)(
IEnumUnknown* This);
HRESULT (CALLBACK *Clone)(
IEnumUnknown* This,
IEnumUnknown** ppenum);
};
#define IEnumUnknown_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD3 (HRESULT,Next,ULONG,celt,IUnknown**,rgelt,ULONG*,pceltFetched) \
ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \
ICOM_METHOD (HRESULT,Reset) \
ICOM_METHOD1 (HRESULT,Clone,IEnumUnknown**,ppenum)
/*** IUnknown methods ***/
#define IEnumUnknown_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IEnumUnknown_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IEnumUnknown_Release(p) (p)->lpVtbl->Release(p)
/*** IEnumUnknown methods ***/
#define IEnumUnknown_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
#define IEnumUnknown_Skip(p,a) (p)->lpVtbl->Skip(p,a)
#define IEnumUnknown_Reset(p) (p)->lpVtbl->Reset(p)
#define IEnumUnknown_Clone(p,a) (p)->lpVtbl->Clone(p,a)
#endif
HRESULT CALLBACK IEnumUnknown_RemoteNext_Proxy(
IEnumUnknown* This,
ULONG celt,
IUnknown** rgelt,
ULONG* pceltFetched);
void __RPC_STUB IEnumUnknown_RemoteNext_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumUnknown_Next_Proxy(
IEnumUnknown* This,
ULONG celt,
IUnknown** rgelt,
ULONG* pceltFetched);
HRESULT __RPC_STUB IEnumUnknown_Next_Stub(
IEnumUnknown* This,
ULONG celt,
IUnknown** rgelt,
ULONG* pceltFetched);
HRESULT CALLBACK IEnumUnknown_Skip_Proxy(
IEnumUnknown* This,
ULONG celt);
void __RPC_STUB IEnumUnknown_Skip_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumUnknown_Reset_Proxy(
IEnumUnknown* This);
void __RPC_STUB IEnumUnknown_Reset_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumUnknown_Clone_Proxy(
IEnumUnknown* This,
IEnumUnknown** ppenum);
void __RPC_STUB IEnumUnknown_Clone_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct ISurrogate ISurrogate;
typedef ISurrogate *LPSURROGATE;
/*****************************************************************************
* ISurrogate interface
*/
DEFINE_GUID(IID_ISurrogate, 0x00000022, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct ISurrogate: IUnknown {
virtual HRESULT CALLBACK LoadDllServer(
REFCLSID Clsid) = 0;
virtual HRESULT CALLBACK FreeSurrogate(
) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct ISurrogateVtbl ISurrogateVtbl;
struct ISurrogate {
const ISurrogateVtbl* lpVtbl;
};
struct ISurrogateVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
ISurrogate* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
ISurrogate* This);
ULONG (CALLBACK *Release)(
ISurrogate* This);
/*** ISurrogate methods ***/
HRESULT (CALLBACK *LoadDllServer)(
ISurrogate* This,
REFCLSID Clsid);
HRESULT (CALLBACK *FreeSurrogate)(
ISurrogate* This);
};
#define ISurrogate_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD1 (HRESULT,LoadDllServer,REFCLSID,Clsid) \
ICOM_METHOD (HRESULT,FreeSurrogate)
/*** IUnknown methods ***/
#define ISurrogate_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define ISurrogate_AddRef(p) (p)->lpVtbl->AddRef(p)
#define ISurrogate_Release(p) (p)->lpVtbl->Release(p)
/*** ISurrogate methods ***/
#define ISurrogate_LoadDllServer(p,a) (p)->lpVtbl->LoadDllServer(p,a)
#define ISurrogate_FreeSurrogate(p) (p)->lpVtbl->FreeSurrogate(p)
#endif
HRESULT CALLBACK ISurrogate_LoadDllServer_Proxy(
ISurrogate* This,
REFCLSID Clsid);
void __RPC_STUB ISurrogate_LoadDllServer_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK ISurrogate_FreeSurrogate_Proxy(
ISurrogate* This);
void __RPC_STUB ISurrogate_FreeSurrogate_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IGlobalInterfaceTable IGlobalInterfaceTable;
typedef IGlobalInterfaceTable *LPGLOBALINTERFACETABLE;
/*****************************************************************************
* IGlobalInterfaceTable interface
*/
DEFINE_GUID(IID_IGlobalInterfaceTable, 0x00000146, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IGlobalInterfaceTable: IUnknown {
virtual HRESULT CALLBACK RegisterInterfaceInGlobal(
IUnknown* pUnk,
REFIID riid,
DWORD* pdwCookie) = 0;
virtual HRESULT CALLBACK RevokeInterfaceFromGlobal(
DWORD dwCookie) = 0;
virtual HRESULT CALLBACK GetInterfaceFromGlobal(
DWORD dwCookie,
REFIID riid,
void** ppv) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IGlobalInterfaceTableVtbl IGlobalInterfaceTableVtbl;
struct IGlobalInterfaceTable {
const IGlobalInterfaceTableVtbl* lpVtbl;
};
struct IGlobalInterfaceTableVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IGlobalInterfaceTable* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IGlobalInterfaceTable* This);
ULONG (CALLBACK *Release)(
IGlobalInterfaceTable* This);
/*** IGlobalInterfaceTable methods ***/
HRESULT (CALLBACK *RegisterInterfaceInGlobal)(
IGlobalInterfaceTable* This,
IUnknown* pUnk,
REFIID riid,
DWORD* pdwCookie);
HRESULT (CALLBACK *RevokeInterfaceFromGlobal)(
IGlobalInterfaceTable* This,
DWORD dwCookie);
HRESULT (CALLBACK *GetInterfaceFromGlobal)(
IGlobalInterfaceTable* This,
DWORD dwCookie,
REFIID riid,
void** ppv);
};
#define IGlobalInterfaceTable_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD3 (HRESULT,RegisterInterfaceInGlobal,IUnknown*,pUnk,REFIID,riid,DWORD*,pdwCookie) \
ICOM_METHOD1 (HRESULT,RevokeInterfaceFromGlobal,DWORD,dwCookie) \
ICOM_METHOD3 (HRESULT,GetInterfaceFromGlobal,DWORD,dwCookie,REFIID,riid,void**,ppv)
/*** IUnknown methods ***/
#define IGlobalInterfaceTable_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IGlobalInterfaceTable_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IGlobalInterfaceTable_Release(p) (p)->lpVtbl->Release(p)
/*** IGlobalInterfaceTable methods ***/
#define IGlobalInterfaceTable_RegisterInterfaceInGlobal(p,a,b,c) (p)->lpVtbl->RegisterInterfaceInGlobal(p,a,b,c)
#define IGlobalInterfaceTable_RevokeInterfaceFromGlobal(p,a) (p)->lpVtbl->RevokeInterfaceFromGlobal(p,a)
#define IGlobalInterfaceTable_GetInterfaceFromGlobal(p,a,b,c) (p)->lpVtbl->GetInterfaceFromGlobal(p,a,b,c)
#endif
HRESULT CALLBACK IGlobalInterfaceTable_RegisterInterfaceInGlobal_Proxy(
IGlobalInterfaceTable* This,
IUnknown* pUnk,
REFIID riid,
DWORD* pdwCookie);
void __RPC_STUB IGlobalInterfaceTable_RegisterInterfaceInGlobal_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IGlobalInterfaceTable_RevokeInterfaceFromGlobal_Proxy(
IGlobalInterfaceTable* This,
DWORD dwCookie);
void __RPC_STUB IGlobalInterfaceTable_RevokeInterfaceFromGlobal_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IGlobalInterfaceTable_GetInterfaceFromGlobal_Proxy(
IGlobalInterfaceTable* This,
DWORD dwCookie,
REFIID riid,
void** ppv);
void __RPC_STUB IGlobalInterfaceTable_GetInterfaceFromGlobal_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IBindCtx IBindCtx;
typedef IBindCtx *LPBINDCTX;
typedef IBindCtx *LPBC;
typedef struct tagBIND_OPTS {
DWORD cbStruct;
DWORD grfFlags;
DWORD grfMode;
DWORD dwTickCountDeadline;
} BIND_OPTS, *LPBIND_OPTS;
typedef struct tagBIND_OPTS2 {
DWORD cbStruct;
DWORD grfFlags;
DWORD grfMode;
DWORD dwTickCountDeadline;
DWORD dwTrackFlags;
DWORD dwClassContext;
LCID locale;
COSERVERINFO *pServerInfo;
} BIND_OPTS2, *LPBIND_OPTS2;
typedef enum tagBIND_FLAGS {
BIND_MAYBOTHERUSER = 1,
BIND_JUSTTESTEXISTENCE = 2
} BIND_FLAGS;
/*****************************************************************************
* IBindCtx interface
*/
DEFINE_GUID(IID_IBindCtx, 0x0000000e, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IBindCtx: IUnknown {
virtual HRESULT CALLBACK RegisterObjectBound(
IUnknown* punk) = 0;
virtual HRESULT CALLBACK RevokeObjectBound(
IUnknown* punk) = 0;
virtual HRESULT CALLBACK ReleaseBoundObjects(
) = 0;
virtual HRESULT CALLBACK SetBindOptions(
BIND_OPTS* pbindopts) = 0;
virtual HRESULT CALLBACK GetBindOptions(
BIND_OPTS* pbindopts) = 0;
virtual HRESULT CALLBACK GetRunningObjectTable(
IRunningObjectTable** pprot) = 0;
virtual HRESULT CALLBACK RegisterObjectParam(
LPOLESTR pszKey,
IUnknown* punk) = 0;
virtual HRESULT CALLBACK GetObjectParam(
LPOLESTR pszKey,
IUnknown** ppunk) = 0;
virtual HRESULT CALLBACK EnumObjectParam(
IEnumString** ppenum) = 0;
virtual HRESULT CALLBACK RevokeObjectParam(
LPOLESTR pszKey) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IBindCtxVtbl IBindCtxVtbl;
struct IBindCtx {
const IBindCtxVtbl* lpVtbl;
};
struct IBindCtxVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IBindCtx* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IBindCtx* This);
ULONG (CALLBACK *Release)(
IBindCtx* This);
/*** IBindCtx methods ***/
HRESULT (CALLBACK *RegisterObjectBound)(
IBindCtx* This,
IUnknown* punk);
HRESULT (CALLBACK *RevokeObjectBound)(
IBindCtx* This,
IUnknown* punk);
HRESULT (CALLBACK *ReleaseBoundObjects)(
IBindCtx* This);
HRESULT (CALLBACK *SetBindOptions)(
IBindCtx* This,
BIND_OPTS* pbindopts);
HRESULT (CALLBACK *GetBindOptions)(
IBindCtx* This,
BIND_OPTS* pbindopts);
HRESULT (CALLBACK *GetRunningObjectTable)(
IBindCtx* This,
IRunningObjectTable** pprot);
HRESULT (CALLBACK *RegisterObjectParam)(
IBindCtx* This,
LPOLESTR pszKey,
IUnknown* punk);
HRESULT (CALLBACK *GetObjectParam)(
IBindCtx* This,
LPOLESTR pszKey,
IUnknown** ppunk);
HRESULT (CALLBACK *EnumObjectParam)(
IBindCtx* This,
IEnumString** ppenum);
HRESULT (CALLBACK *RevokeObjectParam)(
IBindCtx* This,
LPOLESTR pszKey);
};
#define IBindCtx_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD1 (HRESULT,RegisterObjectBound,IUnknown*,punk) \
ICOM_METHOD1 (HRESULT,RevokeObjectBound,IUnknown*,punk) \
ICOM_METHOD (HRESULT,ReleaseBoundObjects) \
ICOM_METHOD1 (HRESULT,SetBindOptions,BIND_OPTS*,pbindopts) \
ICOM_METHOD1 (HRESULT,GetBindOptions,BIND_OPTS*,pbindopts) \
ICOM_METHOD1 (HRESULT,GetRunningObjectTable,IRunningObjectTable**,pprot) \
ICOM_METHOD2 (HRESULT,RegisterObjectParam,LPOLESTR,pszKey,IUnknown*,punk) \
ICOM_METHOD2 (HRESULT,GetObjectParam,LPOLESTR,pszKey,IUnknown**,ppunk) \
ICOM_METHOD1 (HRESULT,EnumObjectParam,IEnumString**,ppenum) \
ICOM_METHOD1 (HRESULT,RevokeObjectParam,LPOLESTR,pszKey)
/*** IUnknown methods ***/
#define IBindCtx_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IBindCtx_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IBindCtx_Release(p) (p)->lpVtbl->Release(p)
/*** IBindCtx methods ***/
#define IBindCtx_RegisterObjectBound(p,a) (p)->lpVtbl->RegisterObjectBound(p,a)
#define IBindCtx_RevokeObjectBound(p,a) (p)->lpVtbl->RevokeObjectBound(p,a)
#define IBindCtx_ReleaseBoundObjects(p) (p)->lpVtbl->ReleaseBoundObjects(p)
#define IBindCtx_SetBindOptions(p,a) (p)->lpVtbl->SetBindOptions(p,a)
#define IBindCtx_GetBindOptions(p,a) (p)->lpVtbl->GetBindOptions(p,a)
#define IBindCtx_GetRunningObjectTable(p,a) (p)->lpVtbl->GetRunningObjectTable(p,a)
#define IBindCtx_RegisterObjectParam(p,a,b) (p)->lpVtbl->RegisterObjectParam(p,a,b)
#define IBindCtx_GetObjectParam(p,a,b) (p)->lpVtbl->GetObjectParam(p,a,b)
#define IBindCtx_EnumObjectParam(p,a) (p)->lpVtbl->EnumObjectParam(p,a)
#define IBindCtx_RevokeObjectParam(p,a) (p)->lpVtbl->RevokeObjectParam(p,a)
#endif
HRESULT CALLBACK IBindCtx_RegisterObjectBound_Proxy(
IBindCtx* This,
IUnknown* punk);
void __RPC_STUB IBindCtx_RegisterObjectBound_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IBindCtx_RevokeObjectBound_Proxy(
IBindCtx* This,
IUnknown* punk);
void __RPC_STUB IBindCtx_RevokeObjectBound_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IBindCtx_ReleaseBoundObjects_Proxy(
IBindCtx* This);
void __RPC_STUB IBindCtx_ReleaseBoundObjects_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IBindCtx_RemoteSetBindOptions_Proxy(
IBindCtx* This,
BIND_OPTS2* pbindopts);
void __RPC_STUB IBindCtx_RemoteSetBindOptions_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IBindCtx_SetBindOptions_Proxy(
IBindCtx* This,
BIND_OPTS* pbindopts);
HRESULT __RPC_STUB IBindCtx_SetBindOptions_Stub(
IBindCtx* This,
BIND_OPTS2* pbindopts);
HRESULT CALLBACK IBindCtx_RemoteGetBindOptions_Proxy(
IBindCtx* This,
BIND_OPTS2* pbindopts);
void __RPC_STUB IBindCtx_RemoteGetBindOptions_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IBindCtx_GetBindOptions_Proxy(
IBindCtx* This,
BIND_OPTS* pbindopts);
HRESULT __RPC_STUB IBindCtx_GetBindOptions_Stub(
IBindCtx* This,
BIND_OPTS2* pbindopts);
HRESULT CALLBACK IBindCtx_GetRunningObjectTable_Proxy(
IBindCtx* This,
IRunningObjectTable** pprot);
void __RPC_STUB IBindCtx_GetRunningObjectTable_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IBindCtx_RegisterObjectParam_Proxy(
IBindCtx* This,
LPOLESTR pszKey,
IUnknown* punk);
void __RPC_STUB IBindCtx_RegisterObjectParam_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IBindCtx_GetObjectParam_Proxy(
IBindCtx* This,
LPOLESTR pszKey,
IUnknown** ppunk);
void __RPC_STUB IBindCtx_GetObjectParam_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IBindCtx_EnumObjectParam_Proxy(
IBindCtx* This,
IEnumString** ppenum);
void __RPC_STUB IBindCtx_EnumObjectParam_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IBindCtx_RevokeObjectParam_Proxy(
IBindCtx* This,
LPOLESTR pszKey);
void __RPC_STUB IBindCtx_RevokeObjectParam_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IEnumMoniker IEnumMoniker;
typedef IEnumMoniker *LPENUMMONIKER;
/*****************************************************************************
* IEnumMoniker interface
*/
DEFINE_GUID(IID_IEnumMoniker, 0x00000102, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IEnumMoniker: IUnknown {
virtual HRESULT CALLBACK Next(
ULONG celt,
IMoniker** rgelt,
ULONG* pceltFetched) = 0;
virtual HRESULT CALLBACK Skip(
ULONG celt) = 0;
virtual HRESULT CALLBACK Reset(
) = 0;
virtual HRESULT CALLBACK Clone(
IEnumMoniker** ppenum) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IEnumMonikerVtbl IEnumMonikerVtbl;
struct IEnumMoniker {
const IEnumMonikerVtbl* lpVtbl;
};
struct IEnumMonikerVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IEnumMoniker* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IEnumMoniker* This);
ULONG (CALLBACK *Release)(
IEnumMoniker* This);
/*** IEnumMoniker methods ***/
HRESULT (CALLBACK *Next)(
IEnumMoniker* This,
ULONG celt,
IMoniker** rgelt,
ULONG* pceltFetched);
HRESULT (CALLBACK *Skip)(
IEnumMoniker* This,
ULONG celt);
HRESULT (CALLBACK *Reset)(
IEnumMoniker* This);
HRESULT (CALLBACK *Clone)(
IEnumMoniker* This,
IEnumMoniker** ppenum);
};
#define IEnumMoniker_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD3 (HRESULT,Next,ULONG,celt,IMoniker**,rgelt,ULONG*,pceltFetched) \
ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \
ICOM_METHOD (HRESULT,Reset) \
ICOM_METHOD1 (HRESULT,Clone,IEnumMoniker**,ppenum)
/*** IUnknown methods ***/
#define IEnumMoniker_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IEnumMoniker_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IEnumMoniker_Release(p) (p)->lpVtbl->Release(p)
/*** IEnumMoniker methods ***/
#define IEnumMoniker_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
#define IEnumMoniker_Skip(p,a) (p)->lpVtbl->Skip(p,a)
#define IEnumMoniker_Reset(p) (p)->lpVtbl->Reset(p)
#define IEnumMoniker_Clone(p,a) (p)->lpVtbl->Clone(p,a)
#endif
HRESULT CALLBACK IEnumMoniker_RemoteNext_Proxy(
IEnumMoniker* This,
ULONG celt,
IMoniker** rgelt,
ULONG* pceltFetched);
void __RPC_STUB IEnumMoniker_RemoteNext_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumMoniker_Next_Proxy(
IEnumMoniker* This,
ULONG celt,
IMoniker** rgelt,
ULONG* pceltFetched);
HRESULT __RPC_STUB IEnumMoniker_Next_Stub(
IEnumMoniker* This,
ULONG celt,
IMoniker** rgelt,
ULONG* pceltFetched);
HRESULT CALLBACK IEnumMoniker_Skip_Proxy(
IEnumMoniker* This,
ULONG celt);
void __RPC_STUB IEnumMoniker_Skip_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumMoniker_Reset_Proxy(
IEnumMoniker* This);
void __RPC_STUB IEnumMoniker_Reset_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumMoniker_Clone_Proxy(
IEnumMoniker* This,
IEnumMoniker** ppenum);
void __RPC_STUB IEnumMoniker_Clone_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IRunnableObject IRunnableObject;
typedef IRunnableObject *LPRUNNABLEOBJECT;
/*****************************************************************************
* IRunnableObject interface
*/
DEFINE_GUID(IID_IRunnableObject, 0x00000126, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IRunnableObject: IUnknown {
virtual HRESULT CALLBACK GetRunningClass(
LPCLSID lpClsid) = 0;
virtual HRESULT CALLBACK Run(
LPBINDCTX pbc) = 0;
virtual BOOL CALLBACK IsRunning(
) = 0;
virtual HRESULT CALLBACK LockRunning(
BOOL fLock,
BOOL fLastUnlockCloses) = 0;
virtual HRESULT CALLBACK SetContainedObject(
BOOL fContained) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IRunnableObjectVtbl IRunnableObjectVtbl;
struct IRunnableObject {
const IRunnableObjectVtbl* lpVtbl;
};
struct IRunnableObjectVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IRunnableObject* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IRunnableObject* This);
ULONG (CALLBACK *Release)(
IRunnableObject* This);
/*** IRunnableObject methods ***/
HRESULT (CALLBACK *GetRunningClass)(
IRunnableObject* This,
LPCLSID lpClsid);
HRESULT (CALLBACK *Run)(
IRunnableObject* This,
LPBINDCTX pbc);
BOOL (CALLBACK *IsRunning)(
IRunnableObject* This);
HRESULT (CALLBACK *LockRunning)(
IRunnableObject* This,
BOOL fLock,
BOOL fLastUnlockCloses);
HRESULT (CALLBACK *SetContainedObject)(
IRunnableObject* This,
BOOL fContained);
};
#define IRunnableObject_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD1 (HRESULT,GetRunningClass,LPCLSID,lpClsid) \
ICOM_METHOD1 (HRESULT,Run,LPBINDCTX,pbc) \
ICOM_METHOD (BOOL,IsRunning) \
ICOM_METHOD2 (HRESULT,LockRunning,BOOL,fLock,BOOL,fLastUnlockCloses) \
ICOM_METHOD1 (HRESULT,SetContainedObject,BOOL,fContained)
/*** IUnknown methods ***/
#define IRunnableObject_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IRunnableObject_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IRunnableObject_Release(p) (p)->lpVtbl->Release(p)
/*** IRunnableObject methods ***/
#define IRunnableObject_GetRunningClass(p,a) (p)->lpVtbl->GetRunningClass(p,a)
#define IRunnableObject_Run(p,a) (p)->lpVtbl->Run(p,a)
#define IRunnableObject_IsRunning(p) (p)->lpVtbl->IsRunning(p)
#define IRunnableObject_LockRunning(p,a,b) (p)->lpVtbl->LockRunning(p,a,b)
#define IRunnableObject_SetContainedObject(p,a) (p)->lpVtbl->SetContainedObject(p,a)
#endif
HRESULT CALLBACK IRunnableObject_GetRunningClass_Proxy(
IRunnableObject* This,
LPCLSID lpClsid);
void __RPC_STUB IRunnableObject_GetRunningClass_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRunnableObject_Run_Proxy(
IRunnableObject* This,
LPBINDCTX pbc);
void __RPC_STUB IRunnableObject_Run_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRunnableObject_RemoteIsRunning_Proxy(
IRunnableObject* This);
void __RPC_STUB IRunnableObject_RemoteIsRunning_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
BOOL CALLBACK IRunnableObject_IsRunning_Proxy(
IRunnableObject* This);
HRESULT __RPC_STUB IRunnableObject_IsRunning_Stub(
IRunnableObject* This);
HRESULT CALLBACK IRunnableObject_LockRunning_Proxy(
IRunnableObject* This,
BOOL fLock,
BOOL fLastUnlockCloses);
void __RPC_STUB IRunnableObject_LockRunning_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRunnableObject_SetContainedObject_Proxy(
IRunnableObject* This,
BOOL fContained);
void __RPC_STUB IRunnableObject_SetContainedObject_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
#ifdef __WINESRC__
#undef GetObject
#endif
typedef IRunningObjectTable *LPRUNNINGOBJECTTABLE;
/*****************************************************************************
* IRunningObjectTable interface
*/
DEFINE_GUID(IID_IRunningObjectTable, 0x00000010, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IRunningObjectTable: IUnknown {
virtual HRESULT CALLBACK Register(
DWORD grfFlags,
IUnknown* punkObject,
IMoniker* pmkObjectName,
DWORD* pdwRegister) = 0;
virtual HRESULT CALLBACK Revoke(
DWORD dwRegister) = 0;
virtual HRESULT CALLBACK IsRunning(
IMoniker* pmkObjectName) = 0;
virtual HRESULT CALLBACK GetObject(
IMoniker* pmkObjectName,
IUnknown** ppunkObject) = 0;
virtual HRESULT CALLBACK NoteChangeTime(
DWORD dwRegister,
FILETIME* pfiletime) = 0;
virtual HRESULT CALLBACK GetTimeOfLastChange(
IMoniker* pmkObjectName,
FILETIME* pfiletime) = 0;
virtual HRESULT CALLBACK EnumRunning(
IEnumMoniker** ppenumMoniker) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IRunningObjectTableVtbl IRunningObjectTableVtbl;
struct IRunningObjectTable {
const IRunningObjectTableVtbl* lpVtbl;
};
struct IRunningObjectTableVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IRunningObjectTable* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IRunningObjectTable* This);
ULONG (CALLBACK *Release)(
IRunningObjectTable* This);
/*** IRunningObjectTable methods ***/
HRESULT (CALLBACK *Register)(
IRunningObjectTable* This,
DWORD grfFlags,
IUnknown* punkObject,
IMoniker* pmkObjectName,
DWORD* pdwRegister);
HRESULT (CALLBACK *Revoke)(
IRunningObjectTable* This,
DWORD dwRegister);
HRESULT (CALLBACK *IsRunning)(
IRunningObjectTable* This,
IMoniker* pmkObjectName);
HRESULT (CALLBACK *GetObject)(
IRunningObjectTable* This,
IMoniker* pmkObjectName,
IUnknown** ppunkObject);
HRESULT (CALLBACK *NoteChangeTime)(
IRunningObjectTable* This,
DWORD dwRegister,
FILETIME* pfiletime);
HRESULT (CALLBACK *GetTimeOfLastChange)(
IRunningObjectTable* This,
IMoniker* pmkObjectName,
FILETIME* pfiletime);
HRESULT (CALLBACK *EnumRunning)(
IRunningObjectTable* This,
IEnumMoniker** ppenumMoniker);
};
#define IRunningObjectTable_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD4 (HRESULT,Register,DWORD,grfFlags,IUnknown*,punkObject,IMoniker*,pmkObjectName,DWORD*,pdwRegister) \
ICOM_METHOD1 (HRESULT,Revoke,DWORD,dwRegister) \
ICOM_METHOD1 (HRESULT,IsRunning,IMoniker*,pmkObjectName) \
ICOM_METHOD2 (HRESULT,GetObject,IMoniker*,pmkObjectName,IUnknown**,ppunkObject) \
ICOM_METHOD2 (HRESULT,NoteChangeTime,DWORD,dwRegister,FILETIME*,pfiletime) \
ICOM_METHOD2 (HRESULT,GetTimeOfLastChange,IMoniker*,pmkObjectName,FILETIME*,pfiletime) \
ICOM_METHOD1 (HRESULT,EnumRunning,IEnumMoniker**,ppenumMoniker)
/*** IUnknown methods ***/
#define IRunningObjectTable_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IRunningObjectTable_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IRunningObjectTable_Release(p) (p)->lpVtbl->Release(p)
/*** IRunningObjectTable methods ***/
#define IRunningObjectTable_Register(p,a,b,c,d) (p)->lpVtbl->Register(p,a,b,c,d)
#define IRunningObjectTable_Revoke(p,a) (p)->lpVtbl->Revoke(p,a)
#define IRunningObjectTable_IsRunning(p,a) (p)->lpVtbl->IsRunning(p,a)
#define IRunningObjectTable_GetObject(p,a,b) (p)->lpVtbl->GetObject(p,a,b)
#define IRunningObjectTable_NoteChangeTime(p,a,b) (p)->lpVtbl->NoteChangeTime(p,a,b)
#define IRunningObjectTable_GetTimeOfLastChange(p,a,b) (p)->lpVtbl->GetTimeOfLastChange(p,a,b)
#define IRunningObjectTable_EnumRunning(p,a) (p)->lpVtbl->EnumRunning(p,a)
#endif
HRESULT CALLBACK IRunningObjectTable_Register_Proxy(
IRunningObjectTable* This,
DWORD grfFlags,
IUnknown* punkObject,
IMoniker* pmkObjectName,
DWORD* pdwRegister);
void __RPC_STUB IRunningObjectTable_Register_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRunningObjectTable_Revoke_Proxy(
IRunningObjectTable* This,
DWORD dwRegister);
void __RPC_STUB IRunningObjectTable_Revoke_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRunningObjectTable_IsRunning_Proxy(
IRunningObjectTable* This,
IMoniker* pmkObjectName);
void __RPC_STUB IRunningObjectTable_IsRunning_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRunningObjectTable_GetObject_Proxy(
IRunningObjectTable* This,
IMoniker* pmkObjectName,
IUnknown** ppunkObject);
void __RPC_STUB IRunningObjectTable_GetObject_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRunningObjectTable_NoteChangeTime_Proxy(
IRunningObjectTable* This,
DWORD dwRegister,
FILETIME* pfiletime);
void __RPC_STUB IRunningObjectTable_NoteChangeTime_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRunningObjectTable_GetTimeOfLastChange_Proxy(
IRunningObjectTable* This,
IMoniker* pmkObjectName,
FILETIME* pfiletime);
void __RPC_STUB IRunningObjectTable_GetTimeOfLastChange_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRunningObjectTable_EnumRunning_Proxy(
IRunningObjectTable* This,
IEnumMoniker** ppenumMoniker);
void __RPC_STUB IRunningObjectTable_EnumRunning_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IPersist IPersist;
typedef IPersist *LPPERSIST;
/*****************************************************************************
* IPersist interface
*/
DEFINE_GUID(IID_IPersist, 0x0000010c, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IPersist: IUnknown {
virtual HRESULT CALLBACK GetClassID(
CLSID* pClassID) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IPersistVtbl IPersistVtbl;
struct IPersist {
const IPersistVtbl* lpVtbl;
};
struct IPersistVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IPersist* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IPersist* This);
ULONG (CALLBACK *Release)(
IPersist* This);
/*** IPersist methods ***/
HRESULT (CALLBACK *GetClassID)(
IPersist* This,
CLSID* pClassID);
};
#define IPersist_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD1 (HRESULT,GetClassID,CLSID*,pClassID)
/*** IUnknown methods ***/
#define IPersist_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IPersist_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IPersist_Release(p) (p)->lpVtbl->Release(p)
/*** IPersist methods ***/
#define IPersist_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a)
#endif
HRESULT CALLBACK IPersist_GetClassID_Proxy(
IPersist* This,
CLSID* pClassID);
void __RPC_STUB IPersist_GetClassID_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IPersistStream IPersistStream;
typedef IPersistStream *LPPERSISTSTREAM;
/*****************************************************************************
* IPersistStream interface
*/
DEFINE_GUID(IID_IPersistStream, 0x00000109, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IPersistStream: IPersist {
virtual HRESULT CALLBACK IsDirty(
) = 0;
virtual HRESULT CALLBACK Load(
IStream* pStm) = 0;
virtual HRESULT CALLBACK Save(
IStream* pStm,
BOOL fClearDirty) = 0;
virtual HRESULT CALLBACK GetSizeMax(
ULARGE_INTEGER* pcbSize) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IPersistStreamVtbl IPersistStreamVtbl;
struct IPersistStream {
const IPersistStreamVtbl* lpVtbl;
};
struct IPersistStreamVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IPersistStream* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IPersistStream* This);
ULONG (CALLBACK *Release)(
IPersistStream* This);
/*** IPersist methods ***/
HRESULT (CALLBACK *GetClassID)(
IPersistStream* This,
CLSID* pClassID);
/*** IPersistStream methods ***/
HRESULT (CALLBACK *IsDirty)(
IPersistStream* This);
HRESULT (CALLBACK *Load)(
IPersistStream* This,
IStream* pStm);
HRESULT (CALLBACK *Save)(
IPersistStream* This,
IStream* pStm,
BOOL fClearDirty);
HRESULT (CALLBACK *GetSizeMax)(
IPersistStream* This,
ULARGE_INTEGER* pcbSize);
};
#define IPersistStream_IMETHODS \
IPersist_IMETHODS \
ICOM_METHOD (HRESULT,IsDirty) \
ICOM_METHOD1 (HRESULT,Load,IStream*,pStm) \
ICOM_METHOD2 (HRESULT,Save,IStream*,pStm,BOOL,fClearDirty) \
ICOM_METHOD1 (HRESULT,GetSizeMax,ULARGE_INTEGER*,pcbSize)
/*** IUnknown methods ***/
#define IPersistStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IPersistStream_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IPersistStream_Release(p) (p)->lpVtbl->Release(p)
/*** IPersist methods ***/
#define IPersistStream_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a)
/*** IPersistStream methods ***/
#define IPersistStream_IsDirty(p) (p)->lpVtbl->IsDirty(p)
#define IPersistStream_Load(p,a) (p)->lpVtbl->Load(p,a)
#define IPersistStream_Save(p,a,b) (p)->lpVtbl->Save(p,a,b)
#define IPersistStream_GetSizeMax(p,a) (p)->lpVtbl->GetSizeMax(p,a)
#endif
HRESULT CALLBACK IPersistStream_IsDirty_Proxy(
IPersistStream* This);
void __RPC_STUB IPersistStream_IsDirty_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistStream_Load_Proxy(
IPersistStream* This,
IStream* pStm);
void __RPC_STUB IPersistStream_Load_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistStream_Save_Proxy(
IPersistStream* This,
IStream* pStm,
BOOL fClearDirty);
void __RPC_STUB IPersistStream_Save_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistStream_GetSizeMax_Proxy(
IPersistStream* This,
ULARGE_INTEGER* pcbSize);
void __RPC_STUB IPersistStream_GetSizeMax_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef IMoniker *LPMONIKER;
typedef enum tagMKSYS {
MKSYS_NONE = 0,
MKSYS_GENERICCOMPOSITE = 1,
MKSYS_FILEMONIKER = 2,
MKSYS_ANTIMONIKER = 3,
MKSYS_ITEMMONIKER = 4,
MKSYS_POINTERMONIKER = 5,
MKSYS_CLASSMONIKER = 7
} MKSYS;
typedef enum tagMKREDUCE {
MKRREDUCE_ONE = 3 << 16,
MKRREDUCE_TOUSER = 2 << 16,
MKRREDUCE_THROUGHUSER = 1 << 16,
MKRREDUCE_ALL = 0
} MKRREDUCE;
/*****************************************************************************
* IMoniker interface
*/
DEFINE_GUID(IID_IMoniker, 0x0000000f, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IMoniker: IPersistStream {
virtual HRESULT CALLBACK BindToObject(
IBindCtx* pbc,
IMoniker* pmkToLeft,
REFIID riidResult,
void** ppvResult) = 0;
virtual HRESULT CALLBACK BindToStorage(
IBindCtx* pbc,
IMoniker* pmkToLeft,
REFIID riid,
void** ppvObj) = 0;
virtual HRESULT CALLBACK Reduce(
IBindCtx* pbc,
DWORD dwReduceHowFar,
IMoniker** ppmkToLeft,
IMoniker** ppmkReduced) = 0;
virtual HRESULT CALLBACK ComposeWith(
IMoniker* pmkRight,
BOOL fOnlyIfNotGeneric,
IMoniker** ppmkComposite) = 0;
virtual HRESULT CALLBACK Enum(
BOOL fForward,
IEnumMoniker** ppenumMoniker) = 0;
virtual HRESULT CALLBACK IsEqual(
IMoniker* pmkOtherMoniker) = 0;
virtual HRESULT CALLBACK Hash(
DWORD* pdwHash) = 0;
virtual HRESULT CALLBACK IsRunning(
IBindCtx* pbc,
IMoniker* pmkToLeft,
IMoniker* pmkNewlyRunning) = 0;
virtual HRESULT CALLBACK GetTimeOfLastChange(
IBindCtx* pbc,
IMoniker* pmkToLeft,
FILETIME* pFileTime) = 0;
virtual HRESULT CALLBACK Inverse(
IMoniker** ppmk) = 0;
virtual HRESULT CALLBACK CommonPrefixWith(
IMoniker* pmkOther,
IMoniker** ppmkPrefix) = 0;
virtual HRESULT CALLBACK RelativePathTo(
IMoniker* pmkOther,
IMoniker** ppmkRelPath) = 0;
virtual HRESULT CALLBACK GetDisplayName(
IBindCtx* pbc,
IMoniker* pmkToLeft,
LPOLESTR* ppszDisplayName) = 0;
virtual HRESULT CALLBACK ParseDisplayName(
IBindCtx* pbc,
IMoniker* pmkToLeft,
LPOLESTR pszDisplayName,
ULONG* pchEaten,
IMoniker** ppmkOut) = 0;
virtual HRESULT CALLBACK IsSystemMoniker(
DWORD* pdwMksys) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IMonikerVtbl IMonikerVtbl;
struct IMoniker {
const IMonikerVtbl* lpVtbl;
};
struct IMonikerVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IMoniker* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IMoniker* This);
ULONG (CALLBACK *Release)(
IMoniker* This);
/*** IPersist methods ***/
HRESULT (CALLBACK *GetClassID)(
IMoniker* This,
CLSID* pClassID);
/*** IPersistStream methods ***/
HRESULT (CALLBACK *IsDirty)(
IMoniker* This);
HRESULT (CALLBACK *Load)(
IMoniker* This,
IStream* pStm);
HRESULT (CALLBACK *Save)(
IMoniker* This,
IStream* pStm,
BOOL fClearDirty);
HRESULT (CALLBACK *GetSizeMax)(
IMoniker* This,
ULARGE_INTEGER* pcbSize);
/*** IMoniker methods ***/
HRESULT (CALLBACK *BindToObject)(
IMoniker* This,
IBindCtx* pbc,
IMoniker* pmkToLeft,
REFIID riidResult,
void** ppvResult);
HRESULT (CALLBACK *BindToStorage)(
IMoniker* This,
IBindCtx* pbc,
IMoniker* pmkToLeft,
REFIID riid,
void** ppvObj);
HRESULT (CALLBACK *Reduce)(
IMoniker* This,
IBindCtx* pbc,
DWORD dwReduceHowFar,
IMoniker** ppmkToLeft,
IMoniker** ppmkReduced);
HRESULT (CALLBACK *ComposeWith)(
IMoniker* This,
IMoniker* pmkRight,
BOOL fOnlyIfNotGeneric,
IMoniker** ppmkComposite);
HRESULT (CALLBACK *Enum)(
IMoniker* This,
BOOL fForward,
IEnumMoniker** ppenumMoniker);
HRESULT (CALLBACK *IsEqual)(
IMoniker* This,
IMoniker* pmkOtherMoniker);
HRESULT (CALLBACK *Hash)(
IMoniker* This,
DWORD* pdwHash);
HRESULT (CALLBACK *IsRunning)(
IMoniker* This,
IBindCtx* pbc,
IMoniker* pmkToLeft,
IMoniker* pmkNewlyRunning);
HRESULT (CALLBACK *GetTimeOfLastChange)(
IMoniker* This,
IBindCtx* pbc,
IMoniker* pmkToLeft,
FILETIME* pFileTime);
HRESULT (CALLBACK *Inverse)(
IMoniker* This,
IMoniker** ppmk);
HRESULT (CALLBACK *CommonPrefixWith)(
IMoniker* This,
IMoniker* pmkOther,
IMoniker** ppmkPrefix);
HRESULT (CALLBACK *RelativePathTo)(
IMoniker* This,
IMoniker* pmkOther,
IMoniker** ppmkRelPath);
HRESULT (CALLBACK *GetDisplayName)(
IMoniker* This,
IBindCtx* pbc,
IMoniker* pmkToLeft,
LPOLESTR* ppszDisplayName);
HRESULT (CALLBACK *ParseDisplayName)(
IMoniker* This,
IBindCtx* pbc,
IMoniker* pmkToLeft,
LPOLESTR pszDisplayName,
ULONG* pchEaten,
IMoniker** ppmkOut);
HRESULT (CALLBACK *IsSystemMoniker)(
IMoniker* This,
DWORD* pdwMksys);
};
#define IMoniker_IMETHODS \
IPersistStream_IMETHODS \
ICOM_METHOD4 (HRESULT,BindToObject,IBindCtx*,pbc,IMoniker*,pmkToLeft,REFIID,riidResult,void**,ppvResult) \
ICOM_METHOD4 (HRESULT,BindToStorage,IBindCtx*,pbc,IMoniker*,pmkToLeft,REFIID,riid,void**,ppvObj) \
ICOM_METHOD4 (HRESULT,Reduce,IBindCtx*,pbc,DWORD,dwReduceHowFar,IMoniker**,ppmkToLeft,IMoniker**,ppmkReduced) \
ICOM_METHOD3 (HRESULT,ComposeWith,IMoniker*,pmkRight,BOOL,fOnlyIfNotGeneric,IMoniker**,ppmkComposite) \
ICOM_METHOD2 (HRESULT,Enum,BOOL,fForward,IEnumMoniker**,ppenumMoniker) \
ICOM_METHOD1 (HRESULT,IsEqual,IMoniker*,pmkOtherMoniker) \
ICOM_METHOD1 (HRESULT,Hash,DWORD*,pdwHash) \
ICOM_METHOD3 (HRESULT,IsRunning,IBindCtx*,pbc,IMoniker*,pmkToLeft,IMoniker*,pmkNewlyRunning) \
ICOM_METHOD3 (HRESULT,GetTimeOfLastChange,IBindCtx*,pbc,IMoniker*,pmkToLeft,FILETIME*,pFileTime) \
ICOM_METHOD1 (HRESULT,Inverse,IMoniker**,ppmk) \
ICOM_METHOD2 (HRESULT,CommonPrefixWith,IMoniker*,pmkOther,IMoniker**,ppmkPrefix) \
ICOM_METHOD2 (HRESULT,RelativePathTo,IMoniker*,pmkOther,IMoniker**,ppmkRelPath) \
ICOM_METHOD3 (HRESULT,GetDisplayName,IBindCtx*,pbc,IMoniker*,pmkToLeft,LPOLESTR*,ppszDisplayName) \
ICOM_METHOD5 (HRESULT,ParseDisplayName,IBindCtx*,pbc,IMoniker*,pmkToLeft,LPOLESTR,pszDisplayName,ULONG*,pchEaten,IMoniker**,ppmkOut) \
ICOM_METHOD1 (HRESULT,IsSystemMoniker,DWORD*,pdwMksys)
/*** IUnknown methods ***/
#define IMoniker_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMoniker_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMoniker_Release(p) (p)->lpVtbl->Release(p)
/*** IPersist methods ***/
#define IMoniker_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a)
/*** IPersistStream methods ***/
#define IMoniker_IsDirty(p) (p)->lpVtbl->IsDirty(p)
#define IMoniker_Load(p,a) (p)->lpVtbl->Load(p,a)
#define IMoniker_Save(p,a,b) (p)->lpVtbl->Save(p,a,b)
#define IMoniker_GetSizeMax(p,a) (p)->lpVtbl->GetSizeMax(p,a)
/*** IMoniker methods ***/
#define IMoniker_BindToObject(p,a,b,c,d) (p)->lpVtbl->BindToObject(p,a,b,c,d)
#define IMoniker_BindToStorage(p,a,b,c,d) (p)->lpVtbl->BindToStorage(p,a,b,c,d)
#define IMoniker_Reduce(p,a,b,c,d) (p)->lpVtbl->Reduce(p,a,b,c,d)
#define IMoniker_ComposeWith(p,a,b,c) (p)->lpVtbl->ComposeWith(p,a,b,c)
#define IMoniker_Enum(p,a,b) (p)->lpVtbl->Enum(p,a,b)
#define IMoniker_IsEqual(p,a) (p)->lpVtbl->IsEqual(p,a)
#define IMoniker_Hash(p,a) (p)->lpVtbl->Hash(p,a)
#define IMoniker_IsRunning(p,a,b,c) (p)->lpVtbl->IsRunning(p,a,b,c)
#define IMoniker_GetTimeOfLastChange(p,a,b,c) (p)->lpVtbl->GetTimeOfLastChange(p,a,b,c)
#define IMoniker_Inverse(p,a) (p)->lpVtbl->Inverse(p,a)
#define IMoniker_CommonPrefixWith(p,a,b) (p)->lpVtbl->CommonPrefixWith(p,a,b)
#define IMoniker_RelativePathTo(p,a,b) (p)->lpVtbl->RelativePathTo(p,a,b)
#define IMoniker_GetDisplayName(p,a,b,c) (p)->lpVtbl->GetDisplayName(p,a,b,c)
#define IMoniker_ParseDisplayName(p,a,b,c,d,e) (p)->lpVtbl->ParseDisplayName(p,a,b,c,d,e)
#define IMoniker_IsSystemMoniker(p,a) (p)->lpVtbl->IsSystemMoniker(p,a)
#endif
HRESULT CALLBACK IMoniker_RemoteBindToObject_Proxy(
IMoniker* This,
IBindCtx* pbc,
IMoniker* pmkToLeft,
REFIID riidResult,
IUnknown** ppvResult);
void __RPC_STUB IMoniker_RemoteBindToObject_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_BindToObject_Proxy(
IMoniker* This,
IBindCtx* pbc,
IMoniker* pmkToLeft,
REFIID riidResult,
void** ppvResult);
HRESULT __RPC_STUB IMoniker_BindToObject_Stub(
IMoniker* This,
IBindCtx* pbc,
IMoniker* pmkToLeft,
REFIID riidResult,
IUnknown** ppvResult);
HRESULT CALLBACK IMoniker_RemoteBindToStorage_Proxy(
IMoniker* This,
IBindCtx* pbc,
IMoniker* pmkToLeft,
REFIID riid,
IUnknown** ppvObj);
void __RPC_STUB IMoniker_RemoteBindToStorage_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_BindToStorage_Proxy(
IMoniker* This,
IBindCtx* pbc,
IMoniker* pmkToLeft,
REFIID riid,
void** ppvObj);
HRESULT __RPC_STUB IMoniker_BindToStorage_Stub(
IMoniker* This,
IBindCtx* pbc,
IMoniker* pmkToLeft,
REFIID riid,
IUnknown** ppvObj);
HRESULT CALLBACK IMoniker_Reduce_Proxy(
IMoniker* This,
IBindCtx* pbc,
DWORD dwReduceHowFar,
IMoniker** ppmkToLeft,
IMoniker** ppmkReduced);
void __RPC_STUB IMoniker_Reduce_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_ComposeWith_Proxy(
IMoniker* This,
IMoniker* pmkRight,
BOOL fOnlyIfNotGeneric,
IMoniker** ppmkComposite);
void __RPC_STUB IMoniker_ComposeWith_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_Enum_Proxy(
IMoniker* This,
BOOL fForward,
IEnumMoniker** ppenumMoniker);
void __RPC_STUB IMoniker_Enum_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_IsEqual_Proxy(
IMoniker* This,
IMoniker* pmkOtherMoniker);
void __RPC_STUB IMoniker_IsEqual_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_Hash_Proxy(
IMoniker* This,
DWORD* pdwHash);
void __RPC_STUB IMoniker_Hash_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_IsRunning_Proxy(
IMoniker* This,
IBindCtx* pbc,
IMoniker* pmkToLeft,
IMoniker* pmkNewlyRunning);
void __RPC_STUB IMoniker_IsRunning_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_GetTimeOfLastChange_Proxy(
IMoniker* This,
IBindCtx* pbc,
IMoniker* pmkToLeft,
FILETIME* pFileTime);
void __RPC_STUB IMoniker_GetTimeOfLastChange_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_Inverse_Proxy(
IMoniker* This,
IMoniker** ppmk);
void __RPC_STUB IMoniker_Inverse_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_CommonPrefixWith_Proxy(
IMoniker* This,
IMoniker* pmkOther,
IMoniker** ppmkPrefix);
void __RPC_STUB IMoniker_CommonPrefixWith_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_RelativePathTo_Proxy(
IMoniker* This,
IMoniker* pmkOther,
IMoniker** ppmkRelPath);
void __RPC_STUB IMoniker_RelativePathTo_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_GetDisplayName_Proxy(
IMoniker* This,
IBindCtx* pbc,
IMoniker* pmkToLeft,
LPOLESTR* ppszDisplayName);
void __RPC_STUB IMoniker_GetDisplayName_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_ParseDisplayName_Proxy(
IMoniker* This,
IBindCtx* pbc,
IMoniker* pmkToLeft,
LPOLESTR pszDisplayName,
ULONG* pchEaten,
IMoniker** ppmkOut);
void __RPC_STUB IMoniker_ParseDisplayName_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IMoniker_IsSystemMoniker_Proxy(
IMoniker* This,
DWORD* pdwMksys);
void __RPC_STUB IMoniker_IsSystemMoniker_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IROTData IROTData;
/*****************************************************************************
* IROTData interface
*/
DEFINE_GUID(IID_IROTData, 0xf29f6bc0, 0x5021, 0x11ce, 0xaa,0x15, 0x00,0x00,0x69,0x01,0x29,0x3f);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IROTData: IUnknown {
virtual HRESULT CALLBACK GetComparisonData(
byte* pbData,
ULONG cbMax,
ULONG* pcbData) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IROTDataVtbl IROTDataVtbl;
struct IROTData {
const IROTDataVtbl* lpVtbl;
};
struct IROTDataVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IROTData* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IROTData* This);
ULONG (CALLBACK *Release)(
IROTData* This);
/*** IROTData methods ***/
HRESULT (CALLBACK *GetComparisonData)(
IROTData* This,
byte* pbData,
ULONG cbMax,
ULONG* pcbData);
};
#define IROTData_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD3 (HRESULT,GetComparisonData,byte*,pbData,ULONG,cbMax,ULONG*,pcbData)
/*** IUnknown methods ***/
#define IROTData_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IROTData_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IROTData_Release(p) (p)->lpVtbl->Release(p)
/*** IROTData methods ***/
#define IROTData_GetComparisonData(p,a,b,c) (p)->lpVtbl->GetComparisonData(p,a,b,c)
#endif
HRESULT CALLBACK IROTData_GetComparisonData_Proxy(
IROTData* This,
byte* pbData,
ULONG cbMax,
ULONG* pcbData);
void __RPC_STUB IROTData_GetComparisonData_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef IEnumString *LPENUMSTRING;
/*****************************************************************************
* IEnumString interface
*/
DEFINE_GUID(IID_IEnumString, 0x00000101, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IEnumString: IUnknown {
virtual HRESULT CALLBACK Next(
ULONG celt,
LPOLESTR* rgelt,
ULONG* pceltFetched) = 0;
virtual HRESULT CALLBACK Skip(
ULONG celt) = 0;
virtual HRESULT CALLBACK Reset(
) = 0;
virtual HRESULT CALLBACK Clone(
IEnumString** ppenum) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IEnumStringVtbl IEnumStringVtbl;
struct IEnumString {
const IEnumStringVtbl* lpVtbl;
};
struct IEnumStringVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IEnumString* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IEnumString* This);
ULONG (CALLBACK *Release)(
IEnumString* This);
/*** IEnumString methods ***/
HRESULT (CALLBACK *Next)(
IEnumString* This,
ULONG celt,
LPOLESTR* rgelt,
ULONG* pceltFetched);
HRESULT (CALLBACK *Skip)(
IEnumString* This,
ULONG celt);
HRESULT (CALLBACK *Reset)(
IEnumString* This);
HRESULT (CALLBACK *Clone)(
IEnumString* This,
IEnumString** ppenum);
};
#define IEnumString_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD3 (HRESULT,Next,ULONG,celt,LPOLESTR*,rgelt,ULONG*,pceltFetched) \
ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \
ICOM_METHOD (HRESULT,Reset) \
ICOM_METHOD1 (HRESULT,Clone,IEnumString**,ppenum)
/*** IUnknown methods ***/
#define IEnumString_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IEnumString_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IEnumString_Release(p) (p)->lpVtbl->Release(p)
/*** IEnumString methods ***/
#define IEnumString_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
#define IEnumString_Skip(p,a) (p)->lpVtbl->Skip(p,a)
#define IEnumString_Reset(p) (p)->lpVtbl->Reset(p)
#define IEnumString_Clone(p,a) (p)->lpVtbl->Clone(p,a)
#endif
HRESULT CALLBACK IEnumString_RemoteNext_Proxy(
IEnumString* This,
ULONG celt,
LPOLESTR* rgelt,
ULONG* pceltFetched);
void __RPC_STUB IEnumString_RemoteNext_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumString_Next_Proxy(
IEnumString* This,
ULONG celt,
LPOLESTR* rgelt,
ULONG* pceltFetched);
HRESULT __RPC_STUB IEnumString_Next_Stub(
IEnumString* This,
ULONG celt,
LPOLESTR* rgelt,
ULONG* pceltFetched);
HRESULT CALLBACK IEnumString_Skip_Proxy(
IEnumString* This,
ULONG celt);
void __RPC_STUB IEnumString_Skip_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumString_Reset_Proxy(
IEnumString* This);
void __RPC_STUB IEnumString_Reset_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumString_Clone_Proxy(
IEnumString* This,
IEnumString** ppenum);
void __RPC_STUB IEnumString_Clone_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IClassActivator IClassActivator;
/*****************************************************************************
* IClassActivator interface
*/
DEFINE_GUID(IID_IClassActivator, 0x00000140, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IClassActivator: IUnknown {
virtual HRESULT CALLBACK GetClassObject(
REFCLSID rclsid,
DWORD dwClassContext,
LCID locale,
REFIID riid,
void** ppv) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IClassActivatorVtbl IClassActivatorVtbl;
struct IClassActivator {
const IClassActivatorVtbl* lpVtbl;
};
struct IClassActivatorVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IClassActivator* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IClassActivator* This);
ULONG (CALLBACK *Release)(
IClassActivator* This);
/*** IClassActivator methods ***/
HRESULT (CALLBACK *GetClassObject)(
IClassActivator* This,
REFCLSID rclsid,
DWORD dwClassContext,
LCID locale,
REFIID riid,
void** ppv);
};
#define IClassActivator_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD5 (HRESULT,GetClassObject,REFCLSID,rclsid,DWORD,dwClassContext,LCID,locale,REFIID,riid,void**,ppv)
/*** IUnknown methods ***/
#define IClassActivator_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IClassActivator_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IClassActivator_Release(p) (p)->lpVtbl->Release(p)
/*** IClassActivator methods ***/
#define IClassActivator_GetClassObject(p,a,b,c,d,e) (p)->lpVtbl->GetClassObject(p,a,b,c,d,e)
#endif
HRESULT CALLBACK IClassActivator_GetClassObject_Proxy(
IClassActivator* This,
REFCLSID rclsid,
DWORD dwClassContext,
LCID locale,
REFIID riid,
void** ppv);
void __RPC_STUB IClassActivator_GetClassObject_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct ISequentialStream ISequentialStream;
/*****************************************************************************
* ISequentialStream interface
*/
DEFINE_GUID(IID_ISequentialStream, 0x0c733a30, 0x2a1c, 0x11ce, 0xad,0xe5, 0x00,0xaa,0x00,0x44,0x77,0x3d);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct ISequentialStream: IUnknown {
virtual HRESULT CALLBACK Read(
void* pv,
ULONG cb,
ULONG* pcbRead) = 0;
virtual HRESULT CALLBACK Write(
const void* pv,
ULONG cb,
ULONG* pcbWritten) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct ISequentialStreamVtbl ISequentialStreamVtbl;
struct ISequentialStream {
const ISequentialStreamVtbl* lpVtbl;
};
struct ISequentialStreamVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
ISequentialStream* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
ISequentialStream* This);
ULONG (CALLBACK *Release)(
ISequentialStream* This);
/*** ISequentialStream methods ***/
HRESULT (CALLBACK *Read)(
ISequentialStream* This,
void* pv,
ULONG cb,
ULONG* pcbRead);
HRESULT (CALLBACK *Write)(
ISequentialStream* This,
const void* pv,
ULONG cb,
ULONG* pcbWritten);
};
#define ISequentialStream_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD3 (HRESULT,Read,void*,pv,ULONG,cb,ULONG*,pcbRead) \
ICOM_METHOD3 (HRESULT,Write,const void*,pv,ULONG,cb,ULONG*,pcbWritten)
/*** IUnknown methods ***/
#define ISequentialStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define ISequentialStream_AddRef(p) (p)->lpVtbl->AddRef(p)
#define ISequentialStream_Release(p) (p)->lpVtbl->Release(p)
/*** ISequentialStream methods ***/
#define ISequentialStream_Read(p,a,b,c) (p)->lpVtbl->Read(p,a,b,c)
#define ISequentialStream_Write(p,a,b,c) (p)->lpVtbl->Write(p,a,b,c)
#endif
HRESULT CALLBACK ISequentialStream_RemoteRead_Proxy(
ISequentialStream* This,
byte* pv,
ULONG cb,
ULONG* pcbRead);
void __RPC_STUB ISequentialStream_RemoteRead_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK ISequentialStream_Read_Proxy(
ISequentialStream* This,
void* pv,
ULONG cb,
ULONG* pcbRead);
HRESULT __RPC_STUB ISequentialStream_Read_Stub(
ISequentialStream* This,
byte* pv,
ULONG cb,
ULONG* pcbRead);
HRESULT CALLBACK ISequentialStream_RemoteWrite_Proxy(
ISequentialStream* This,
const byte* pv,
ULONG cb,
ULONG* pcbWritten);
void __RPC_STUB ISequentialStream_RemoteWrite_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK ISequentialStream_Write_Proxy(
ISequentialStream* This,
const void* pv,
ULONG cb,
ULONG* pcbWritten);
HRESULT __RPC_STUB ISequentialStream_Write_Stub(
ISequentialStream* This,
const byte* pv,
ULONG cb,
ULONG* pcbWritten);
typedef IStream *LPSTREAM;
typedef struct tagSTATSTG {
LPOLESTR pwcsName;
DWORD type;
ULARGE_INTEGER cbSize;
FILETIME mtime;
FILETIME ctime;
FILETIME atime;
DWORD grfMode;
DWORD grfLocksSupported;
CLSID clsid;
DWORD grfStateBits;
DWORD reserved;
} STATSTG;
typedef enum tagSTGTY {
STGTY_STORAGE = 1,
STGTY_STREAM = 2,
STGTY_LOCKBYTES = 3,
STGTY_PROPERTY = 4
} STGTY;
typedef enum tagSTREAM_SEEK {
STREAM_SEEK_SET = 0,
STREAM_SEEK_CUR = 1,
STREAM_SEEK_END = 2
} STREAM_SEEK;
#undef LOCK_MAND
#undef LOCK_READ
#undef LOCK_WRITE
#undef LOCK_RW
typedef enum tagLOCKTYPE {
LOCK_WRITE = 1,
LOCK_EXCLUSIVE = 2,
LOCK_ONLYONCE = 4
} LOCKTYPE;
/*****************************************************************************
* IStream interface
*/
DEFINE_GUID(IID_IStream, 0x0000000c, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IStream: ISequentialStream {
virtual HRESULT CALLBACK Seek(
LARGE_INTEGER dlibMove,
DWORD dwOrigin,
ULARGE_INTEGER* plibNewPosition) = 0;
virtual HRESULT CALLBACK SetSize(
ULARGE_INTEGER libNewSize) = 0;
virtual HRESULT CALLBACK CopyTo(
IStream* pstm,
ULARGE_INTEGER cb,
ULARGE_INTEGER* pcbRead,
ULARGE_INTEGER* pcbWritten) = 0;
virtual HRESULT CALLBACK Commit(
DWORD grfCommitFlags) = 0;
virtual HRESULT CALLBACK Revert(
) = 0;
virtual HRESULT CALLBACK LockRegion(
ULARGE_INTEGER libOffset,
ULARGE_INTEGER cb,
DWORD dwLockType) = 0;
virtual HRESULT CALLBACK UnlockRegion(
ULARGE_INTEGER libOffset,
ULARGE_INTEGER cb,
DWORD dwLockType) = 0;
virtual HRESULT CALLBACK Stat(
STATSTG* pstatstg,
DWORD grfStatFlag) = 0;
virtual HRESULT CALLBACK Clone(
IStream** ppstm) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IStreamVtbl IStreamVtbl;
struct IStream {
const IStreamVtbl* lpVtbl;
};
struct IStreamVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IStream* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IStream* This);
ULONG (CALLBACK *Release)(
IStream* This);
/*** ISequentialStream methods ***/
HRESULT (CALLBACK *Read)(
IStream* This,
void* pv,
ULONG cb,
ULONG* pcbRead);
HRESULT (CALLBACK *Write)(
IStream* This,
const void* pv,
ULONG cb,
ULONG* pcbWritten);
/*** IStream methods ***/
HRESULT (CALLBACK *Seek)(
IStream* This,
LARGE_INTEGER dlibMove,
DWORD dwOrigin,
ULARGE_INTEGER* plibNewPosition);
HRESULT (CALLBACK *SetSize)(
IStream* This,
ULARGE_INTEGER libNewSize);
HRESULT (CALLBACK *CopyTo)(
IStream* This,
IStream* pstm,
ULARGE_INTEGER cb,
ULARGE_INTEGER* pcbRead,
ULARGE_INTEGER* pcbWritten);
HRESULT (CALLBACK *Commit)(
IStream* This,
DWORD grfCommitFlags);
HRESULT (CALLBACK *Revert)(
IStream* This);
HRESULT (CALLBACK *LockRegion)(
IStream* This,
ULARGE_INTEGER libOffset,
ULARGE_INTEGER cb,
DWORD dwLockType);
HRESULT (CALLBACK *UnlockRegion)(
IStream* This,
ULARGE_INTEGER libOffset,
ULARGE_INTEGER cb,
DWORD dwLockType);
HRESULT (CALLBACK *Stat)(
IStream* This,
STATSTG* pstatstg,
DWORD grfStatFlag);
HRESULT (CALLBACK *Clone)(
IStream* This,
IStream** ppstm);
};
#define IStream_IMETHODS \
ISequentialStream_IMETHODS \
ICOM_METHOD3 (HRESULT,Seek,LARGE_INTEGER,dlibMove,DWORD,dwOrigin,ULARGE_INTEGER*,plibNewPosition) \
ICOM_METHOD1 (HRESULT,SetSize,ULARGE_INTEGER,libNewSize) \
ICOM_METHOD4 (HRESULT,CopyTo,IStream*,pstm,ULARGE_INTEGER,cb,ULARGE_INTEGER*,pcbRead,ULARGE_INTEGER*,pcbWritten) \
ICOM_METHOD1 (HRESULT,Commit,DWORD,grfCommitFlags) \
ICOM_METHOD (HRESULT,Revert) \
ICOM_METHOD3 (HRESULT,LockRegion,ULARGE_INTEGER,libOffset,ULARGE_INTEGER,cb,DWORD,dwLockType) \
ICOM_METHOD3 (HRESULT,UnlockRegion,ULARGE_INTEGER,libOffset,ULARGE_INTEGER,cb,DWORD,dwLockType) \
ICOM_METHOD2 (HRESULT,Stat,STATSTG*,pstatstg,DWORD,grfStatFlag) \
ICOM_METHOD1 (HRESULT,Clone,IStream**,ppstm)
/*** IUnknown methods ***/
#define IStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IStream_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IStream_Release(p) (p)->lpVtbl->Release(p)
/*** ISequentialStream methods ***/
#define IStream_Read(p,a,b,c) (p)->lpVtbl->Read(p,a,b,c)
#define IStream_Write(p,a,b,c) (p)->lpVtbl->Write(p,a,b,c)
/*** IStream methods ***/
#define IStream_Seek(p,a,b,c) (p)->lpVtbl->Seek(p,a,b,c)
#define IStream_SetSize(p,a) (p)->lpVtbl->SetSize(p,a)
#define IStream_CopyTo(p,a,b,c,d) (p)->lpVtbl->CopyTo(p,a,b,c,d)
#define IStream_Commit(p,a) (p)->lpVtbl->Commit(p,a)
#define IStream_Revert(p) (p)->lpVtbl->Revert(p)
#define IStream_LockRegion(p,a,b,c) (p)->lpVtbl->LockRegion(p,a,b,c)
#define IStream_UnlockRegion(p,a,b,c) (p)->lpVtbl->UnlockRegion(p,a,b,c)
#define IStream_Stat(p,a,b) (p)->lpVtbl->Stat(p,a,b)
#define IStream_Clone(p,a) (p)->lpVtbl->Clone(p,a)
#endif
HRESULT CALLBACK IStream_RemoteSeek_Proxy(
IStream* This,
LARGE_INTEGER dlibMove,
DWORD dwOrigin,
ULARGE_INTEGER* plibNewPosition);
void __RPC_STUB IStream_RemoteSeek_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStream_Seek_Proxy(
IStream* This,
LARGE_INTEGER dlibMove,
DWORD dwOrigin,
ULARGE_INTEGER* plibNewPosition);
HRESULT __RPC_STUB IStream_Seek_Stub(
IStream* This,
LARGE_INTEGER dlibMove,
DWORD dwOrigin,
ULARGE_INTEGER* plibNewPosition);
HRESULT CALLBACK IStream_SetSize_Proxy(
IStream* This,
ULARGE_INTEGER libNewSize);
void __RPC_STUB IStream_SetSize_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStream_RemoteCopyTo_Proxy(
IStream* This,
IStream* pstm,
ULARGE_INTEGER cb,
ULARGE_INTEGER* pcbRead,
ULARGE_INTEGER* pcbWritten);
void __RPC_STUB IStream_RemoteCopyTo_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStream_CopyTo_Proxy(
IStream* This,
IStream* pstm,
ULARGE_INTEGER cb,
ULARGE_INTEGER* pcbRead,
ULARGE_INTEGER* pcbWritten);
HRESULT __RPC_STUB IStream_CopyTo_Stub(
IStream* This,
IStream* pstm,
ULARGE_INTEGER cb,
ULARGE_INTEGER* pcbRead,
ULARGE_INTEGER* pcbWritten);
HRESULT CALLBACK IStream_Commit_Proxy(
IStream* This,
DWORD grfCommitFlags);
void __RPC_STUB IStream_Commit_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStream_Revert_Proxy(
IStream* This);
void __RPC_STUB IStream_Revert_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStream_LockRegion_Proxy(
IStream* This,
ULARGE_INTEGER libOffset,
ULARGE_INTEGER cb,
DWORD dwLockType);
void __RPC_STUB IStream_LockRegion_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStream_UnlockRegion_Proxy(
IStream* This,
ULARGE_INTEGER libOffset,
ULARGE_INTEGER cb,
DWORD dwLockType);
void __RPC_STUB IStream_UnlockRegion_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStream_Stat_Proxy(
IStream* This,
STATSTG* pstatstg,
DWORD grfStatFlag);
void __RPC_STUB IStream_Stat_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStream_Clone_Proxy(
IStream* This,
IStream** ppstm);
void __RPC_STUB IStream_Clone_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef IStream16 *LPSTREAM16;
typedef struct tagSTATSTG16 {
LPOLESTR16 pwcsName;
DWORD type;
ULARGE_INTEGER cbSize;
FILETIME mtime;
FILETIME ctime;
FILETIME atime;
DWORD grfMode;
DWORD grfLocksSupported;
CLSID clsid;
DWORD grfStateBits;
DWORD reserved;
} STATSTG16;
/*****************************************************************************
* IStream16 interface
*/
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IStream16: ISequentialStream {
virtual HRESULT CALLBACK Seek(
LARGE_INTEGER dlibMove,
DWORD dwOrigin,
ULARGE_INTEGER* plibNewPosition) = 0;
virtual HRESULT CALLBACK SetSize(
ULARGE_INTEGER libNewSize) = 0;
virtual HRESULT CALLBACK CopyTo(
IStream16* pstm,
ULARGE_INTEGER cb,
ULARGE_INTEGER* pcbRead,
ULARGE_INTEGER* pcbWritten) = 0;
virtual HRESULT CALLBACK Commit(
DWORD grfCommitFlags) = 0;
virtual HRESULT CALLBACK Revert(
) = 0;
virtual HRESULT CALLBACK LockRegion(
ULARGE_INTEGER libOffset,
ULARGE_INTEGER cb,
DWORD dwLockType) = 0;
virtual HRESULT CALLBACK UnlockRegion(
ULARGE_INTEGER libOffset,
ULARGE_INTEGER cb,
DWORD dwLockType) = 0;
virtual HRESULT CALLBACK Stat(
STATSTG* pstatstg,
DWORD grfStatFlag) = 0;
virtual HRESULT CALLBACK Clone(
IStream16** ppstm) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IStream16Vtbl IStream16Vtbl;
struct IStream16 {
const IStream16Vtbl* lpVtbl;
};
struct IStream16Vtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IStream16* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IStream16* This);
ULONG (CALLBACK *Release)(
IStream16* This);
/*** ISequentialStream methods ***/
HRESULT (CALLBACK *Read)(
IStream16* This,
void* pv,
ULONG cb,
ULONG* pcbRead);
HRESULT (CALLBACK *Write)(
IStream16* This,
const void* pv,
ULONG cb,
ULONG* pcbWritten);
/*** IStream16 methods ***/
HRESULT (CALLBACK *Seek)(
IStream16* This,
LARGE_INTEGER dlibMove,
DWORD dwOrigin,
ULARGE_INTEGER* plibNewPosition);
HRESULT (CALLBACK *SetSize)(
IStream16* This,
ULARGE_INTEGER libNewSize);
HRESULT (CALLBACK *CopyTo)(
IStream16* This,
IStream16* pstm,
ULARGE_INTEGER cb,
ULARGE_INTEGER* pcbRead,
ULARGE_INTEGER* pcbWritten);
HRESULT (CALLBACK *Commit)(
IStream16* This,
DWORD grfCommitFlags);
HRESULT (CALLBACK *Revert)(
IStream16* This);
HRESULT (CALLBACK *LockRegion)(
IStream16* This,
ULARGE_INTEGER libOffset,
ULARGE_INTEGER cb,
DWORD dwLockType);
HRESULT (CALLBACK *UnlockRegion)(
IStream16* This,
ULARGE_INTEGER libOffset,
ULARGE_INTEGER cb,
DWORD dwLockType);
HRESULT (CALLBACK *Stat)(
IStream16* This,
STATSTG* pstatstg,
DWORD grfStatFlag);
HRESULT (CALLBACK *Clone)(
IStream16* This,
IStream16** ppstm);
};
#define IStream16_IMETHODS \
ISequentialStream_IMETHODS \
ICOM_METHOD3 (HRESULT,Seek,LARGE_INTEGER,dlibMove,DWORD,dwOrigin,ULARGE_INTEGER*,plibNewPosition) \
ICOM_METHOD1 (HRESULT,SetSize,ULARGE_INTEGER,libNewSize) \
ICOM_METHOD4 (HRESULT,CopyTo,IStream16*,pstm,ULARGE_INTEGER,cb,ULARGE_INTEGER*,pcbRead,ULARGE_INTEGER*,pcbWritten) \
ICOM_METHOD1 (HRESULT,Commit,DWORD,grfCommitFlags) \
ICOM_METHOD (HRESULT,Revert) \
ICOM_METHOD3 (HRESULT,LockRegion,ULARGE_INTEGER,libOffset,ULARGE_INTEGER,cb,DWORD,dwLockType) \
ICOM_METHOD3 (HRESULT,UnlockRegion,ULARGE_INTEGER,libOffset,ULARGE_INTEGER,cb,DWORD,dwLockType) \
ICOM_METHOD2 (HRESULT,Stat,STATSTG*,pstatstg,DWORD,grfStatFlag) \
ICOM_METHOD1 (HRESULT,Clone,IStream16**,ppstm)
/*** IUnknown methods ***/
#define IStream16_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IStream16_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IStream16_Release(p) (p)->lpVtbl->Release(p)
/*** ISequentialStream methods ***/
#define IStream16_Read(p,a,b,c) (p)->lpVtbl->Read(p,a,b,c)
#define IStream16_Write(p,a,b,c) (p)->lpVtbl->Write(p,a,b,c)
/*** IStream16 methods ***/
#define IStream16_Seek(p,a,b,c) (p)->lpVtbl->Seek(p,a,b,c)
#define IStream16_SetSize(p,a) (p)->lpVtbl->SetSize(p,a)
#define IStream16_CopyTo(p,a,b,c,d) (p)->lpVtbl->CopyTo(p,a,b,c,d)
#define IStream16_Commit(p,a) (p)->lpVtbl->Commit(p,a)
#define IStream16_Revert(p) (p)->lpVtbl->Revert(p)
#define IStream16_LockRegion(p,a,b,c) (p)->lpVtbl->LockRegion(p,a,b,c)
#define IStream16_UnlockRegion(p,a,b,c) (p)->lpVtbl->UnlockRegion(p,a,b,c)
#define IStream16_Stat(p,a,b) (p)->lpVtbl->Stat(p,a,b)
#define IStream16_Clone(p,a) (p)->lpVtbl->Clone(p,a)
#endif
HRESULT CALLBACK IStream16_RemoteSeek_Proxy(
IStream16* This,
LARGE_INTEGER dlibMove,
DWORD dwOrigin,
ULARGE_INTEGER* plibNewPosition);
void __RPC_STUB IStream16_RemoteSeek_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStream16_Seek_Proxy(
IStream16* This,
LARGE_INTEGER dlibMove,
DWORD dwOrigin,
ULARGE_INTEGER* plibNewPosition);
HRESULT __RPC_STUB IStream16_Seek_Stub(
IStream16* This,
LARGE_INTEGER dlibMove,
DWORD dwOrigin,
ULARGE_INTEGER* plibNewPosition);
HRESULT CALLBACK IStream16_SetSize_Proxy(
IStream16* This,
ULARGE_INTEGER libNewSize);
void __RPC_STUB IStream16_SetSize_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStream16_RemoteCopyTo_Proxy(
IStream16* This,
IStream16* pstm,
ULARGE_INTEGER cb,
ULARGE_INTEGER* pcbRead,
ULARGE_INTEGER* pcbWritten);
void __RPC_STUB IStream16_RemoteCopyTo_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStream16_CopyTo_Proxy(
IStream16* This,
IStream16* pstm,
ULARGE_INTEGER cb,
ULARGE_INTEGER* pcbRead,
ULARGE_INTEGER* pcbWritten);
HRESULT __RPC_STUB IStream16_CopyTo_Stub(
IStream16* This,
IStream16* pstm,
ULARGE_INTEGER cb,
ULARGE_INTEGER* pcbRead,
ULARGE_INTEGER* pcbWritten);
HRESULT CALLBACK IStream16_Commit_Proxy(
IStream16* This,
DWORD grfCommitFlags);
void __RPC_STUB IStream16_Commit_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStream16_Revert_Proxy(
IStream16* This);
void __RPC_STUB IStream16_Revert_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStream16_LockRegion_Proxy(
IStream16* This,
ULARGE_INTEGER libOffset,
ULARGE_INTEGER cb,
DWORD dwLockType);
void __RPC_STUB IStream16_LockRegion_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStream16_UnlockRegion_Proxy(
IStream16* This,
ULARGE_INTEGER libOffset,
ULARGE_INTEGER cb,
DWORD dwLockType);
void __RPC_STUB IStream16_UnlockRegion_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStream16_Stat_Proxy(
IStream16* This,
STATSTG* pstatstg,
DWORD grfStatFlag);
void __RPC_STUB IStream16_Stat_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStream16_Clone_Proxy(
IStream16* This,
IStream16** ppstm);
void __RPC_STUB IStream16_Clone_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IEnumSTATSTG IEnumSTATSTG;
typedef IEnumSTATSTG *LPENUMSTATSTG;
/*****************************************************************************
* IEnumSTATSTG interface
*/
DEFINE_GUID(IID_IEnumSTATSTG, 0x0000000d, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IEnumSTATSTG: IUnknown {
virtual HRESULT CALLBACK Next(
ULONG celt,
STATSTG* rgelt,
ULONG* pceltFetched) = 0;
virtual HRESULT CALLBACK Skip(
ULONG celt) = 0;
virtual HRESULT CALLBACK Reset(
) = 0;
virtual HRESULT CALLBACK Clone(
IEnumSTATSTG** ppenum) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IEnumSTATSTGVtbl IEnumSTATSTGVtbl;
struct IEnumSTATSTG {
const IEnumSTATSTGVtbl* lpVtbl;
};
struct IEnumSTATSTGVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IEnumSTATSTG* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IEnumSTATSTG* This);
ULONG (CALLBACK *Release)(
IEnumSTATSTG* This);
/*** IEnumSTATSTG methods ***/
HRESULT (CALLBACK *Next)(
IEnumSTATSTG* This,
ULONG celt,
STATSTG* rgelt,
ULONG* pceltFetched);
HRESULT (CALLBACK *Skip)(
IEnumSTATSTG* This,
ULONG celt);
HRESULT (CALLBACK *Reset)(
IEnumSTATSTG* This);
HRESULT (CALLBACK *Clone)(
IEnumSTATSTG* This,
IEnumSTATSTG** ppenum);
};
#define IEnumSTATSTG_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD3 (HRESULT,Next,ULONG,celt,STATSTG*,rgelt,ULONG*,pceltFetched) \
ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \
ICOM_METHOD (HRESULT,Reset) \
ICOM_METHOD1 (HRESULT,Clone,IEnumSTATSTG**,ppenum)
/*** IUnknown methods ***/
#define IEnumSTATSTG_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IEnumSTATSTG_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IEnumSTATSTG_Release(p) (p)->lpVtbl->Release(p)
/*** IEnumSTATSTG methods ***/
#define IEnumSTATSTG_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
#define IEnumSTATSTG_Skip(p,a) (p)->lpVtbl->Skip(p,a)
#define IEnumSTATSTG_Reset(p) (p)->lpVtbl->Reset(p)
#define IEnumSTATSTG_Clone(p,a) (p)->lpVtbl->Clone(p,a)
#endif
HRESULT CALLBACK IEnumSTATSTG_RemoteNext_Proxy(
IEnumSTATSTG* This,
ULONG celt,
STATSTG* rgelt,
ULONG* pceltFetched);
void __RPC_STUB IEnumSTATSTG_RemoteNext_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumSTATSTG_Next_Proxy(
IEnumSTATSTG* This,
ULONG celt,
STATSTG* rgelt,
ULONG* pceltFetched);
HRESULT __RPC_STUB IEnumSTATSTG_Next_Stub(
IEnumSTATSTG* This,
ULONG celt,
STATSTG* rgelt,
ULONG* pceltFetched);
HRESULT CALLBACK IEnumSTATSTG_Skip_Proxy(
IEnumSTATSTG* This,
ULONG celt);
void __RPC_STUB IEnumSTATSTG_Skip_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumSTATSTG_Reset_Proxy(
IEnumSTATSTG* This);
void __RPC_STUB IEnumSTATSTG_Reset_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumSTATSTG_Clone_Proxy(
IEnumSTATSTG* This,
IEnumSTATSTG** ppenum);
void __RPC_STUB IEnumSTATSTG_Clone_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IStorage IStorage;
typedef IStorage *LPSTORAGE;
typedef struct tagRemSNB {
unsigned long ulCntStr;
unsigned long ulCntChar;
OLECHAR rgString[1];
} RemSNB;
typedef RemSNB *wireSNB;
typedef OLECHAR **SNB;
unsigned long __RPC_USER SNB_UserSize (unsigned long *, unsigned long, SNB *);
unsigned char * __RPC_USER SNB_UserMarshal (unsigned long *, unsigned char *, SNB *);
unsigned char * __RPC_USER SNB_UserUnmarshal(unsigned long *, unsigned char *, SNB *);
void __RPC_USER SNB_UserFree (unsigned long *, SNB *);
/*****************************************************************************
* IStorage interface
*/
DEFINE_GUID(IID_IStorage, 0x0000000b, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IStorage: IUnknown {
virtual HRESULT CALLBACK CreateStream(
LPCOLESTR pwcsName,
DWORD grfMode,
DWORD reserved1,
DWORD reserved2,
IStream** ppstm) = 0;
virtual HRESULT CALLBACK OpenStream(
LPCOLESTR pwcsName,
void* reserved1,
DWORD grfMode,
DWORD reserved2,
IStream** ppstm) = 0;
virtual HRESULT CALLBACK CreateStorage(
LPCOLESTR pwcsName,
DWORD grfMode,
DWORD dwStgFmt,
DWORD reserved2,
IStorage** ppstg) = 0;
virtual HRESULT CALLBACK OpenStorage(
LPCOLESTR pwcsName,
IStorage* pstgPriority,
DWORD grfMode,
SNB snbExclude,
DWORD reserved,
IStorage** ppstg) = 0;
virtual HRESULT CALLBACK CopyTo(
DWORD ciidExclude,
const IID* rgiidExclude,
SNB snbExclude,
IStorage* pstgDest) = 0;
virtual HRESULT CALLBACK MoveElementTo(
LPCOLESTR pwcsName,
IStorage* pstgDest,
LPCOLESTR pwcsNewName,
DWORD grfFlags) = 0;
virtual HRESULT CALLBACK Commit(
DWORD grfCommitFlags) = 0;
virtual HRESULT CALLBACK Revert(
) = 0;
virtual HRESULT CALLBACK EnumElements(
DWORD reserved1,
void* reserved2,
DWORD reserved3,
IEnumSTATSTG** ppenum) = 0;
virtual HRESULT CALLBACK DestroyElement(
LPCOLESTR pwcsName) = 0;
virtual HRESULT CALLBACK RenameElement(
LPCOLESTR pwcsOldName,
LPCOLESTR pwcsNewName) = 0;
virtual HRESULT CALLBACK SetElementTimes(
LPCOLESTR pwcsName,
const FILETIME* pctime,
const FILETIME* patime,
const FILETIME* pmtime) = 0;
virtual HRESULT CALLBACK SetClass(
REFCLSID clsid) = 0;
virtual HRESULT CALLBACK SetStateBits(
DWORD grfStateBits,
DWORD grfMask) = 0;
virtual HRESULT CALLBACK Stat(
STATSTG* pstatstg,
DWORD grfStatFlag) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IStorageVtbl IStorageVtbl;
struct IStorage {
const IStorageVtbl* lpVtbl;
};
struct IStorageVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IStorage* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IStorage* This);
ULONG (CALLBACK *Release)(
IStorage* This);
/*** IStorage methods ***/
HRESULT (CALLBACK *CreateStream)(
IStorage* This,
LPCOLESTR pwcsName,
DWORD grfMode,
DWORD reserved1,
DWORD reserved2,
IStream** ppstm);
HRESULT (CALLBACK *OpenStream)(
IStorage* This,
LPCOLESTR pwcsName,
void* reserved1,
DWORD grfMode,
DWORD reserved2,
IStream** ppstm);
HRESULT (CALLBACK *CreateStorage)(
IStorage* This,
LPCOLESTR pwcsName,
DWORD grfMode,
DWORD dwStgFmt,
DWORD reserved2,
IStorage** ppstg);
HRESULT (CALLBACK *OpenStorage)(
IStorage* This,
LPCOLESTR pwcsName,
IStorage* pstgPriority,
DWORD grfMode,
SNB snbExclude,
DWORD reserved,
IStorage** ppstg);
HRESULT (CALLBACK *CopyTo)(
IStorage* This,
DWORD ciidExclude,
const IID* rgiidExclude,
SNB snbExclude,
IStorage* pstgDest);
HRESULT (CALLBACK *MoveElementTo)(
IStorage* This,
LPCOLESTR pwcsName,
IStorage* pstgDest,
LPCOLESTR pwcsNewName,
DWORD grfFlags);
HRESULT (CALLBACK *Commit)(
IStorage* This,
DWORD grfCommitFlags);
HRESULT (CALLBACK *Revert)(
IStorage* This);
HRESULT (CALLBACK *EnumElements)(
IStorage* This,
DWORD reserved1,
void* reserved2,
DWORD reserved3,
IEnumSTATSTG** ppenum);
HRESULT (CALLBACK *DestroyElement)(
IStorage* This,
LPCOLESTR pwcsName);
HRESULT (CALLBACK *RenameElement)(
IStorage* This,
LPCOLESTR pwcsOldName,
LPCOLESTR pwcsNewName);
HRESULT (CALLBACK *SetElementTimes)(
IStorage* This,
LPCOLESTR pwcsName,
const FILETIME* pctime,
const FILETIME* patime,
const FILETIME* pmtime);
HRESULT (CALLBACK *SetClass)(
IStorage* This,
REFCLSID clsid);
HRESULT (CALLBACK *SetStateBits)(
IStorage* This,
DWORD grfStateBits,
DWORD grfMask);
HRESULT (CALLBACK *Stat)(
IStorage* This,
STATSTG* pstatstg,
DWORD grfStatFlag);
};
#define IStorage_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD5 (HRESULT,CreateStream,LPCOLESTR,pwcsName,DWORD,grfMode,DWORD,reserved1,DWORD,reserved2,IStream**,ppstm) \
ICOM_METHOD5 (HRESULT,OpenStream,LPCOLESTR,pwcsName,void*,reserved1,DWORD,grfMode,DWORD,reserved2,IStream**,ppstm) \
ICOM_METHOD5 (HRESULT,CreateStorage,LPCOLESTR,pwcsName,DWORD,grfMode,DWORD,dwStgFmt,DWORD,reserved2,IStorage**,ppstg) \
ICOM_METHOD6 (HRESULT,OpenStorage,LPCOLESTR,pwcsName,IStorage*,pstgPriority,DWORD,grfMode,SNB,snbExclude,DWORD,reserved,IStorage**,ppstg) \
ICOM_METHOD4 (HRESULT,CopyTo,DWORD,ciidExclude,const IID*,rgiidExclude,SNB,snbExclude,IStorage*,pstgDest) \
ICOM_METHOD4 (HRESULT,MoveElementTo,LPCOLESTR,pwcsName,IStorage*,pstgDest,LPCOLESTR,pwcsNewName,DWORD,grfFlags) \
ICOM_METHOD1 (HRESULT,Commit,DWORD,grfCommitFlags) \
ICOM_METHOD (HRESULT,Revert) \
ICOM_METHOD4 (HRESULT,EnumElements,DWORD,reserved1,void*,reserved2,DWORD,reserved3,IEnumSTATSTG**,ppenum) \
ICOM_METHOD1 (HRESULT,DestroyElement,LPCOLESTR,pwcsName) \
ICOM_METHOD2 (HRESULT,RenameElement,LPCOLESTR,pwcsOldName,LPCOLESTR,pwcsNewName) \
ICOM_METHOD4 (HRESULT,SetElementTimes,LPCOLESTR,pwcsName,const FILETIME*,pctime,const FILETIME*,patime,const FILETIME*,pmtime) \
ICOM_METHOD1 (HRESULT,SetClass,REFCLSID,clsid) \
ICOM_METHOD2 (HRESULT,SetStateBits,DWORD,grfStateBits,DWORD,grfMask) \
ICOM_METHOD2 (HRESULT,Stat,STATSTG*,pstatstg,DWORD,grfStatFlag)
/*** IUnknown methods ***/
#define IStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IStorage_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IStorage_Release(p) (p)->lpVtbl->Release(p)
/*** IStorage methods ***/
#define IStorage_CreateStream(p,a,b,c,d,e) (p)->lpVtbl->CreateStream(p,a,b,c,d,e)
#define IStorage_OpenStream(p,a,b,c,d,e) (p)->lpVtbl->OpenStream(p,a,b,c,d,e)
#define IStorage_CreateStorage(p,a,b,c,d,e) (p)->lpVtbl->CreateStorage(p,a,b,c,d,e)
#define IStorage_OpenStorage(p,a,b,c,d,e,f) (p)->lpVtbl->OpenStorage(p,a,b,c,d,e,f)
#define IStorage_CopyTo(p,a,b,c,d) (p)->lpVtbl->CopyTo(p,a,b,c,d)
#define IStorage_MoveElementTo(p,a,b,c,d) (p)->lpVtbl->MoveElementTo(p,a,b,c,d)
#define IStorage_Commit(p,a) (p)->lpVtbl->Commit(p,a)
#define IStorage_Revert(p) (p)->lpVtbl->Revert(p)
#define IStorage_EnumElements(p,a,b,c,d) (p)->lpVtbl->EnumElements(p,a,b,c,d)
#define IStorage_DestroyElement(p,a) (p)->lpVtbl->DestroyElement(p,a)
#define IStorage_RenameElement(p,a,b) (p)->lpVtbl->RenameElement(p,a,b)
#define IStorage_SetElementTimes(p,a,b,c,d) (p)->lpVtbl->SetElementTimes(p,a,b,c,d)
#define IStorage_SetClass(p,a) (p)->lpVtbl->SetClass(p,a)
#define IStorage_SetStateBits(p,a,b) (p)->lpVtbl->SetStateBits(p,a,b)
#define IStorage_Stat(p,a,b) (p)->lpVtbl->Stat(p,a,b)
#endif
HRESULT CALLBACK IStorage_CreateStream_Proxy(
IStorage* This,
LPCOLESTR pwcsName,
DWORD grfMode,
DWORD reserved1,
DWORD reserved2,
IStream** ppstm);
void __RPC_STUB IStorage_CreateStream_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_RemoteOpenStream_Proxy(
IStorage* This,
LPCOLESTR pwcsName,
unsigned long cbReserved1,
byte* reserved1,
DWORD grfMode,
DWORD reserved2,
IStream** ppstm);
void __RPC_STUB IStorage_RemoteOpenStream_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_OpenStream_Proxy(
IStorage* This,
LPCOLESTR pwcsName,
void* reserved1,
DWORD grfMode,
DWORD reserved2,
IStream** ppstm);
HRESULT __RPC_STUB IStorage_OpenStream_Stub(
IStorage* This,
LPCOLESTR pwcsName,
unsigned long cbReserved1,
byte* reserved1,
DWORD grfMode,
DWORD reserved2,
IStream** ppstm);
HRESULT CALLBACK IStorage_CreateStorage_Proxy(
IStorage* This,
LPCOLESTR pwcsName,
DWORD grfMode,
DWORD dwStgFmt,
DWORD reserved2,
IStorage** ppstg);
void __RPC_STUB IStorage_CreateStorage_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_OpenStorage_Proxy(
IStorage* This,
LPCOLESTR pwcsName,
IStorage* pstgPriority,
DWORD grfMode,
SNB snbExclude,
DWORD reserved,
IStorage** ppstg);
void __RPC_STUB IStorage_OpenStorage_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_CopyTo_Proxy(
IStorage* This,
DWORD ciidExclude,
const IID* rgiidExclude,
SNB snbExclude,
IStorage* pstgDest);
void __RPC_STUB IStorage_CopyTo_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_MoveElementTo_Proxy(
IStorage* This,
LPCOLESTR pwcsName,
IStorage* pstgDest,
LPCOLESTR pwcsNewName,
DWORD grfFlags);
void __RPC_STUB IStorage_MoveElementTo_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_Commit_Proxy(
IStorage* This,
DWORD grfCommitFlags);
void __RPC_STUB IStorage_Commit_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_Revert_Proxy(
IStorage* This);
void __RPC_STUB IStorage_Revert_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_RemoteEnumElements_Proxy(
IStorage* This,
DWORD reserved1,
unsigned long cbReserved2,
byte* reserved2,
DWORD reserved3,
IEnumSTATSTG** ppenum);
void __RPC_STUB IStorage_RemoteEnumElements_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_EnumElements_Proxy(
IStorage* This,
DWORD reserved1,
void* reserved2,
DWORD reserved3,
IEnumSTATSTG** ppenum);
HRESULT __RPC_STUB IStorage_EnumElements_Stub(
IStorage* This,
DWORD reserved1,
unsigned long cbReserved2,
byte* reserved2,
DWORD reserved3,
IEnumSTATSTG** ppenum);
HRESULT CALLBACK IStorage_DestroyElement_Proxy(
IStorage* This,
LPCOLESTR pwcsName);
void __RPC_STUB IStorage_DestroyElement_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_RenameElement_Proxy(
IStorage* This,
LPCOLESTR pwcsOldName,
LPCOLESTR pwcsNewName);
void __RPC_STUB IStorage_RenameElement_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_SetElementTimes_Proxy(
IStorage* This,
LPCOLESTR pwcsName,
const FILETIME* pctime,
const FILETIME* patime,
const FILETIME* pmtime);
void __RPC_STUB IStorage_SetElementTimes_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_SetClass_Proxy(
IStorage* This,
REFCLSID clsid);
void __RPC_STUB IStorage_SetClass_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_SetStateBits_Proxy(
IStorage* This,
DWORD grfStateBits,
DWORD grfMask);
void __RPC_STUB IStorage_SetStateBits_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage_Stat_Proxy(
IStorage* This,
STATSTG* pstatstg,
DWORD grfStatFlag);
void __RPC_STUB IStorage_Stat_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IStorage16 IStorage16;
typedef IStorage16 *LPSTORAGE16;
typedef struct tagRemSNB16 {
unsigned long ulCntStr;
unsigned long ulCntChar;
OLECHAR16 rgString[1];
} RemSNB16;
typedef RemSNB16 *wireSNB16;
typedef OLECHAR16 **SNB16;
unsigned long __RPC_USER SNB16_UserSize (unsigned long *, unsigned long, SNB16 *);
unsigned char * __RPC_USER SNB16_UserMarshal (unsigned long *, unsigned char *, SNB16 *);
unsigned char * __RPC_USER SNB16_UserUnmarshal(unsigned long *, unsigned char *, SNB16 *);
void __RPC_USER SNB16_UserFree (unsigned long *, SNB16 *);
/*****************************************************************************
* IStorage16 interface
*/
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IStorage16: IUnknown {
virtual HRESULT CALLBACK CreateStream(
LPCOLESTR16 pwcsName,
DWORD grfMode,
DWORD reserved1,
DWORD reserved2,
IStream16** ppstm) = 0;
virtual HRESULT CALLBACK OpenStream(
LPCOLESTR16 pwcsName,
void* reserved1,
DWORD grfMode,
DWORD reserved2,
IStream16** ppstm) = 0;
virtual HRESULT CALLBACK CreateStorage(
LPCOLESTR16 pwcsName,
DWORD grfMode,
DWORD dwStgFmt,
DWORD reserved2,
IStorage16** ppstg) = 0;
virtual HRESULT CALLBACK OpenStorage(
LPCOLESTR16 pwcsName,
IStorage16* pstgPriority,
DWORD grfMode,
SNB16 snbExclude,
DWORD reserved,
IStorage16** ppstg) = 0;
virtual HRESULT CALLBACK CopyTo(
DWORD ciidExclude,
const IID* rgiidExclude,
SNB16 snbExclude,
IStorage16* pstgDest) = 0;
virtual HRESULT CALLBACK MoveElementTo(
LPCOLESTR16 pwcsName,
IStorage16* pstgDest,
LPCOLESTR16 pwcsNewName,
DWORD grfFlags) = 0;
virtual HRESULT CALLBACK Commit(
DWORD grfCommitFlags) = 0;
virtual HRESULT CALLBACK Revert(
) = 0;
virtual HRESULT CALLBACK EnumElements(
DWORD reserved1,
void* reserved2,
DWORD reserved3,
IEnumSTATSTG** ppenum) = 0;
virtual HRESULT CALLBACK DestroyElement(
LPCOLESTR16 pwcsName) = 0;
virtual HRESULT CALLBACK RenameElement(
LPCOLESTR16 pwcsOldName,
LPCOLESTR16 pwcsNewName) = 0;
virtual HRESULT CALLBACK SetElementTimes(
LPCOLESTR16 pwcsName,
const FILETIME* pctime,
const FILETIME* patime,
const FILETIME* pmtime) = 0;
virtual HRESULT CALLBACK SetClass(
REFCLSID clsid) = 0;
virtual HRESULT CALLBACK SetStateBits(
DWORD grfStateBits,
DWORD grfMask) = 0;
virtual HRESULT CALLBACK Stat(
STATSTG* pstatstg,
DWORD grfStatFlag) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IStorage16Vtbl IStorage16Vtbl;
struct IStorage16 {
const IStorage16Vtbl* lpVtbl;
};
struct IStorage16Vtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IStorage16* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IStorage16* This);
ULONG (CALLBACK *Release)(
IStorage16* This);
/*** IStorage16 methods ***/
HRESULT (CALLBACK *CreateStream)(
IStorage16* This,
LPCOLESTR16 pwcsName,
DWORD grfMode,
DWORD reserved1,
DWORD reserved2,
IStream16** ppstm);
HRESULT (CALLBACK *OpenStream)(
IStorage16* This,
LPCOLESTR16 pwcsName,
void* reserved1,
DWORD grfMode,
DWORD reserved2,
IStream16** ppstm);
HRESULT (CALLBACK *CreateStorage)(
IStorage16* This,
LPCOLESTR16 pwcsName,
DWORD grfMode,
DWORD dwStgFmt,
DWORD reserved2,
IStorage16** ppstg);
HRESULT (CALLBACK *OpenStorage)(
IStorage16* This,
LPCOLESTR16 pwcsName,
IStorage16* pstgPriority,
DWORD grfMode,
SNB16 snbExclude,
DWORD reserved,
IStorage16** ppstg);
HRESULT (CALLBACK *CopyTo)(
IStorage16* This,
DWORD ciidExclude,
const IID* rgiidExclude,
SNB16 snbExclude,
IStorage16* pstgDest);
HRESULT (CALLBACK *MoveElementTo)(
IStorage16* This,
LPCOLESTR16 pwcsName,
IStorage16* pstgDest,
LPCOLESTR16 pwcsNewName,
DWORD grfFlags);
HRESULT (CALLBACK *Commit)(
IStorage16* This,
DWORD grfCommitFlags);
HRESULT (CALLBACK *Revert)(
IStorage16* This);
HRESULT (CALLBACK *EnumElements)(
IStorage16* This,
DWORD reserved1,
void* reserved2,
DWORD reserved3,
IEnumSTATSTG** ppenum);
HRESULT (CALLBACK *DestroyElement)(
IStorage16* This,
LPCOLESTR16 pwcsName);
HRESULT (CALLBACK *RenameElement)(
IStorage16* This,
LPCOLESTR16 pwcsOldName,
LPCOLESTR16 pwcsNewName);
HRESULT (CALLBACK *SetElementTimes)(
IStorage16* This,
LPCOLESTR16 pwcsName,
const FILETIME* pctime,
const FILETIME* patime,
const FILETIME* pmtime);
HRESULT (CALLBACK *SetClass)(
IStorage16* This,
REFCLSID clsid);
HRESULT (CALLBACK *SetStateBits)(
IStorage16* This,
DWORD grfStateBits,
DWORD grfMask);
HRESULT (CALLBACK *Stat)(
IStorage16* This,
STATSTG* pstatstg,
DWORD grfStatFlag);
};
#define IStorage16_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD5 (HRESULT,CreateStream,LPCOLESTR16,pwcsName,DWORD,grfMode,DWORD,reserved1,DWORD,reserved2,IStream16**,ppstm) \
ICOM_METHOD5 (HRESULT,OpenStream,LPCOLESTR16,pwcsName,void*,reserved1,DWORD,grfMode,DWORD,reserved2,IStream16**,ppstm) \
ICOM_METHOD5 (HRESULT,CreateStorage,LPCOLESTR16,pwcsName,DWORD,grfMode,DWORD,dwStgFmt,DWORD,reserved2,IStorage16**,ppstg) \
ICOM_METHOD6 (HRESULT,OpenStorage,LPCOLESTR16,pwcsName,IStorage16*,pstgPriority,DWORD,grfMode,SNB16,snbExclude,DWORD,reserved,IStorage16**,ppstg) \
ICOM_METHOD4 (HRESULT,CopyTo,DWORD,ciidExclude,const IID*,rgiidExclude,SNB16,snbExclude,IStorage16*,pstgDest) \
ICOM_METHOD4 (HRESULT,MoveElementTo,LPCOLESTR16,pwcsName,IStorage16*,pstgDest,LPCOLESTR16,pwcsNewName,DWORD,grfFlags) \
ICOM_METHOD1 (HRESULT,Commit,DWORD,grfCommitFlags) \
ICOM_METHOD (HRESULT,Revert) \
ICOM_METHOD4 (HRESULT,EnumElements,DWORD,reserved1,void*,reserved2,DWORD,reserved3,IEnumSTATSTG**,ppenum) \
ICOM_METHOD1 (HRESULT,DestroyElement,LPCOLESTR16,pwcsName) \
ICOM_METHOD2 (HRESULT,RenameElement,LPCOLESTR16,pwcsOldName,LPCOLESTR16,pwcsNewName) \
ICOM_METHOD4 (HRESULT,SetElementTimes,LPCOLESTR16,pwcsName,const FILETIME*,pctime,const FILETIME*,patime,const FILETIME*,pmtime) \
ICOM_METHOD1 (HRESULT,SetClass,REFCLSID,clsid) \
ICOM_METHOD2 (HRESULT,SetStateBits,DWORD,grfStateBits,DWORD,grfMask) \
ICOM_METHOD2 (HRESULT,Stat,STATSTG*,pstatstg,DWORD,grfStatFlag)
/*** IUnknown methods ***/
#define IStorage16_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IStorage16_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IStorage16_Release(p) (p)->lpVtbl->Release(p)
/*** IStorage16 methods ***/
#define IStorage16_CreateStream(p,a,b,c,d,e) (p)->lpVtbl->CreateStream(p,a,b,c,d,e)
#define IStorage16_OpenStream(p,a,b,c,d,e) (p)->lpVtbl->OpenStream(p,a,b,c,d,e)
#define IStorage16_CreateStorage(p,a,b,c,d,e) (p)->lpVtbl->CreateStorage(p,a,b,c,d,e)
#define IStorage16_OpenStorage(p,a,b,c,d,e,f) (p)->lpVtbl->OpenStorage(p,a,b,c,d,e,f)
#define IStorage16_CopyTo(p,a,b,c,d) (p)->lpVtbl->CopyTo(p,a,b,c,d)
#define IStorage16_MoveElementTo(p,a,b,c,d) (p)->lpVtbl->MoveElementTo(p,a,b,c,d)
#define IStorage16_Commit(p,a) (p)->lpVtbl->Commit(p,a)
#define IStorage16_Revert(p) (p)->lpVtbl->Revert(p)
#define IStorage16_EnumElements(p,a,b,c,d) (p)->lpVtbl->EnumElements(p,a,b,c,d)
#define IStorage16_DestroyElement(p,a) (p)->lpVtbl->DestroyElement(p,a)
#define IStorage16_RenameElement(p,a,b) (p)->lpVtbl->RenameElement(p,a,b)
#define IStorage16_SetElementTimes(p,a,b,c,d) (p)->lpVtbl->SetElementTimes(p,a,b,c,d)
#define IStorage16_SetClass(p,a) (p)->lpVtbl->SetClass(p,a)
#define IStorage16_SetStateBits(p,a,b) (p)->lpVtbl->SetStateBits(p,a,b)
#define IStorage16_Stat(p,a,b) (p)->lpVtbl->Stat(p,a,b)
#endif
HRESULT CALLBACK IStorage16_CreateStream_Proxy(
IStorage16* This,
LPCOLESTR16 pwcsName,
DWORD grfMode,
DWORD reserved1,
DWORD reserved2,
IStream16** ppstm);
void __RPC_STUB IStorage16_CreateStream_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage16_RemoteOpenStream_Proxy(
IStorage16* This,
LPCOLESTR16 pwcsName,
unsigned long cbReserved1,
byte* reserved1,
DWORD grfMode,
DWORD reserved2,
IStream16** ppstm);
void __RPC_STUB IStorage16_RemoteOpenStream_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage16_OpenStream_Proxy(
IStorage16* This,
LPCOLESTR16 pwcsName,
void* reserved1,
DWORD grfMode,
DWORD reserved2,
IStream16** ppstm);
HRESULT __RPC_STUB IStorage16_OpenStream_Stub(
IStorage16* This,
LPCOLESTR16 pwcsName,
unsigned long cbReserved1,
byte* reserved1,
DWORD grfMode,
DWORD reserved2,
IStream16** ppstm);
HRESULT CALLBACK IStorage16_CreateStorage_Proxy(
IStorage16* This,
LPCOLESTR16 pwcsName,
DWORD grfMode,
DWORD dwStgFmt,
DWORD reserved2,
IStorage16** ppstg);
void __RPC_STUB IStorage16_CreateStorage_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage16_OpenStorage_Proxy(
IStorage16* This,
LPCOLESTR16 pwcsName,
IStorage16* pstgPriority,
DWORD grfMode,
SNB16 snbExclude,
DWORD reserved,
IStorage16** ppstg);
void __RPC_STUB IStorage16_OpenStorage_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage16_CopyTo_Proxy(
IStorage16* This,
DWORD ciidExclude,
const IID* rgiidExclude,
SNB16 snbExclude,
IStorage16* pstgDest);
void __RPC_STUB IStorage16_CopyTo_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage16_MoveElementTo_Proxy(
IStorage16* This,
LPCOLESTR16 pwcsName,
IStorage16* pstgDest,
LPCOLESTR16 pwcsNewName,
DWORD grfFlags);
void __RPC_STUB IStorage16_MoveElementTo_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage16_Commit_Proxy(
IStorage16* This,
DWORD grfCommitFlags);
void __RPC_STUB IStorage16_Commit_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage16_Revert_Proxy(
IStorage16* This);
void __RPC_STUB IStorage16_Revert_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage16_RemoteEnumElements_Proxy(
IStorage16* This,
DWORD reserved1,
unsigned long cbReserved2,
byte* reserved2,
DWORD reserved3,
IEnumSTATSTG** ppenum);
void __RPC_STUB IStorage16_RemoteEnumElements_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage16_EnumElements_Proxy(
IStorage16* This,
DWORD reserved1,
void* reserved2,
DWORD reserved3,
IEnumSTATSTG** ppenum);
HRESULT __RPC_STUB IStorage16_EnumElements_Stub(
IStorage16* This,
DWORD reserved1,
unsigned long cbReserved2,
byte* reserved2,
DWORD reserved3,
IEnumSTATSTG** ppenum);
HRESULT CALLBACK IStorage16_DestroyElement_Proxy(
IStorage16* This,
LPCOLESTR16 pwcsName);
void __RPC_STUB IStorage16_DestroyElement_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage16_RenameElement_Proxy(
IStorage16* This,
LPCOLESTR16 pwcsOldName,
LPCOLESTR16 pwcsNewName);
void __RPC_STUB IStorage16_RenameElement_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage16_SetElementTimes_Proxy(
IStorage16* This,
LPCOLESTR16 pwcsName,
const FILETIME* pctime,
const FILETIME* patime,
const FILETIME* pmtime);
void __RPC_STUB IStorage16_SetElementTimes_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage16_SetClass_Proxy(
IStorage16* This,
REFCLSID clsid);
void __RPC_STUB IStorage16_SetClass_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage16_SetStateBits_Proxy(
IStorage16* This,
DWORD grfStateBits,
DWORD grfMask);
void __RPC_STUB IStorage16_SetStateBits_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IStorage16_Stat_Proxy(
IStorage16* This,
STATSTG* pstatstg,
DWORD grfStatFlag);
void __RPC_STUB IStorage16_Stat_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IPersistFile IPersistFile;
typedef IPersistFile *LPPERSISTFILE;
/*****************************************************************************
* IPersistFile interface
*/
DEFINE_GUID(IID_IPersistFile, 0x0000010b, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IPersistFile: IPersist {
virtual HRESULT CALLBACK IsDirty(
) = 0;
virtual HRESULT CALLBACK Load(
LPCOLESTR pszFileName,
DWORD dwMode) = 0;
virtual HRESULT CALLBACK Save(
LPCOLESTR pszFileName,
BOOL fRemember) = 0;
virtual HRESULT CALLBACK SaveCompleted(
LPCOLESTR pszFileName) = 0;
virtual HRESULT CALLBACK GetCurFile(
LPOLESTR* ppszFileName) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IPersistFileVtbl IPersistFileVtbl;
struct IPersistFile {
const IPersistFileVtbl* lpVtbl;
};
struct IPersistFileVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IPersistFile* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IPersistFile* This);
ULONG (CALLBACK *Release)(
IPersistFile* This);
/*** IPersist methods ***/
HRESULT (CALLBACK *GetClassID)(
IPersistFile* This,
CLSID* pClassID);
/*** IPersistFile methods ***/
HRESULT (CALLBACK *IsDirty)(
IPersistFile* This);
HRESULT (CALLBACK *Load)(
IPersistFile* This,
LPCOLESTR pszFileName,
DWORD dwMode);
HRESULT (CALLBACK *Save)(
IPersistFile* This,
LPCOLESTR pszFileName,
BOOL fRemember);
HRESULT (CALLBACK *SaveCompleted)(
IPersistFile* This,
LPCOLESTR pszFileName);
HRESULT (CALLBACK *GetCurFile)(
IPersistFile* This,
LPOLESTR* ppszFileName);
};
#define IPersistFile_IMETHODS \
IPersist_IMETHODS \
ICOM_METHOD (HRESULT,IsDirty) \
ICOM_METHOD2 (HRESULT,Load,LPCOLESTR,pszFileName,DWORD,dwMode) \
ICOM_METHOD2 (HRESULT,Save,LPCOLESTR,pszFileName,BOOL,fRemember) \
ICOM_METHOD1 (HRESULT,SaveCompleted,LPCOLESTR,pszFileName) \
ICOM_METHOD1 (HRESULT,GetCurFile,LPOLESTR*,ppszFileName)
/*** IUnknown methods ***/
#define IPersistFile_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IPersistFile_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IPersistFile_Release(p) (p)->lpVtbl->Release(p)
/*** IPersist methods ***/
#define IPersistFile_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a)
/*** IPersistFile methods ***/
#define IPersistFile_IsDirty(p) (p)->lpVtbl->IsDirty(p)
#define IPersistFile_Load(p,a,b) (p)->lpVtbl->Load(p,a,b)
#define IPersistFile_Save(p,a,b) (p)->lpVtbl->Save(p,a,b)
#define IPersistFile_SaveCompleted(p,a) (p)->lpVtbl->SaveCompleted(p,a)
#define IPersistFile_GetCurFile(p,a) (p)->lpVtbl->GetCurFile(p,a)
#endif
HRESULT CALLBACK IPersistFile_IsDirty_Proxy(
IPersistFile* This);
void __RPC_STUB IPersistFile_IsDirty_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistFile_Load_Proxy(
IPersistFile* This,
LPCOLESTR pszFileName,
DWORD dwMode);
void __RPC_STUB IPersistFile_Load_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistFile_Save_Proxy(
IPersistFile* This,
LPCOLESTR pszFileName,
BOOL fRemember);
void __RPC_STUB IPersistFile_Save_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistFile_SaveCompleted_Proxy(
IPersistFile* This,
LPCOLESTR pszFileName);
void __RPC_STUB IPersistFile_SaveCompleted_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistFile_GetCurFile_Proxy(
IPersistFile* This,
LPOLESTR* ppszFileName);
void __RPC_STUB IPersistFile_GetCurFile_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IPersistStorage IPersistStorage;
typedef IPersistStorage *LPPERSISTSTORAGE;
/*****************************************************************************
* IPersistStorage interface
*/
DEFINE_GUID(IID_IPersistStorage, 0x0000010a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IPersistStorage: IPersist {
virtual HRESULT CALLBACK IsDirty(
) = 0;
virtual HRESULT CALLBACK InitNew(
IStorage* pStg) = 0;
virtual HRESULT CALLBACK Load(
IStorage* pStg) = 0;
virtual HRESULT CALLBACK Save(
IStorage* pStgSave,
BOOL fSameAsLoad) = 0;
virtual HRESULT CALLBACK SaveCompleted(
IStorage* pStgNew) = 0;
virtual HRESULT CALLBACK HandsOffStorage(
) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IPersistStorageVtbl IPersistStorageVtbl;
struct IPersistStorage {
const IPersistStorageVtbl* lpVtbl;
};
struct IPersistStorageVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IPersistStorage* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IPersistStorage* This);
ULONG (CALLBACK *Release)(
IPersistStorage* This);
/*** IPersist methods ***/
HRESULT (CALLBACK *GetClassID)(
IPersistStorage* This,
CLSID* pClassID);
/*** IPersistStorage methods ***/
HRESULT (CALLBACK *IsDirty)(
IPersistStorage* This);
HRESULT (CALLBACK *InitNew)(
IPersistStorage* This,
IStorage* pStg);
HRESULT (CALLBACK *Load)(
IPersistStorage* This,
IStorage* pStg);
HRESULT (CALLBACK *Save)(
IPersistStorage* This,
IStorage* pStgSave,
BOOL fSameAsLoad);
HRESULT (CALLBACK *SaveCompleted)(
IPersistStorage* This,
IStorage* pStgNew);
HRESULT (CALLBACK *HandsOffStorage)(
IPersistStorage* This);
};
#define IPersistStorage_IMETHODS \
IPersist_IMETHODS \
ICOM_METHOD (HRESULT,IsDirty) \
ICOM_METHOD1 (HRESULT,InitNew,IStorage*,pStg) \
ICOM_METHOD1 (HRESULT,Load,IStorage*,pStg) \
ICOM_METHOD2 (HRESULT,Save,IStorage*,pStgSave,BOOL,fSameAsLoad) \
ICOM_METHOD1 (HRESULT,SaveCompleted,IStorage*,pStgNew) \
ICOM_METHOD (HRESULT,HandsOffStorage)
/*** IUnknown methods ***/
#define IPersistStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IPersistStorage_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IPersistStorage_Release(p) (p)->lpVtbl->Release(p)
/*** IPersist methods ***/
#define IPersistStorage_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a)
/*** IPersistStorage methods ***/
#define IPersistStorage_IsDirty(p) (p)->lpVtbl->IsDirty(p)
#define IPersistStorage_InitNew(p,a) (p)->lpVtbl->InitNew(p,a)
#define IPersistStorage_Load(p,a) (p)->lpVtbl->Load(p,a)
#define IPersistStorage_Save(p,a,b) (p)->lpVtbl->Save(p,a,b)
#define IPersistStorage_SaveCompleted(p,a) (p)->lpVtbl->SaveCompleted(p,a)
#define IPersistStorage_HandsOffStorage(p) (p)->lpVtbl->HandsOffStorage(p)
#endif
HRESULT CALLBACK IPersistStorage_IsDirty_Proxy(
IPersistStorage* This);
void __RPC_STUB IPersistStorage_IsDirty_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistStorage_InitNew_Proxy(
IPersistStorage* This,
IStorage* pStg);
void __RPC_STUB IPersistStorage_InitNew_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistStorage_Load_Proxy(
IPersistStorage* This,
IStorage* pStg);
void __RPC_STUB IPersistStorage_Load_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistStorage_Save_Proxy(
IPersistStorage* This,
IStorage* pStgSave,
BOOL fSameAsLoad);
void __RPC_STUB IPersistStorage_Save_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistStorage_SaveCompleted_Proxy(
IPersistStorage* This,
IStorage* pStgNew);
void __RPC_STUB IPersistStorage_SaveCompleted_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPersistStorage_HandsOffStorage_Proxy(
IPersistStorage* This);
void __RPC_STUB IPersistStorage_HandsOffStorage_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IRootStorage IRootStorage;
typedef IRootStorage *LPROOTSTORAGE;
/*****************************************************************************
* IRootStorage interface
*/
DEFINE_GUID(IID_IRootStorage, 0x00000012, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IRootStorage: IUnknown {
virtual HRESULT CALLBACK SwitchToFile(
LPOLESTR pszFile) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IRootStorageVtbl IRootStorageVtbl;
struct IRootStorage {
const IRootStorageVtbl* lpVtbl;
};
struct IRootStorageVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IRootStorage* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IRootStorage* This);
ULONG (CALLBACK *Release)(
IRootStorage* This);
/*** IRootStorage methods ***/
HRESULT (CALLBACK *SwitchToFile)(
IRootStorage* This,
LPOLESTR pszFile);
};
#define IRootStorage_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD1 (HRESULT,SwitchToFile,LPOLESTR,pszFile)
/*** IUnknown methods ***/
#define IRootStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IRootStorage_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IRootStorage_Release(p) (p)->lpVtbl->Release(p)
/*** IRootStorage methods ***/
#define IRootStorage_SwitchToFile(p,a) (p)->lpVtbl->SwitchToFile(p,a)
#endif
HRESULT CALLBACK IRootStorage_SwitchToFile_Proxy(
IRootStorage* This,
LPOLESTR pszFile);
void __RPC_STUB IRootStorage_SwitchToFile_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct ILockBytes ILockBytes;
typedef ILockBytes *LPLOCKBYTES;
/*****************************************************************************
* ILockBytes interface
*/
DEFINE_GUID(IID_ILockBytes, 0x0000000a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct ILockBytes: IUnknown {
virtual HRESULT CALLBACK ReadAt(
ULARGE_INTEGER ulOffset,
void* pv,
ULONG cb,
ULONG* pcbRead) = 0;
virtual HRESULT CALLBACK WriteAt(
ULARGE_INTEGER ulOffset,
const void* pv,
ULONG cb,
ULONG* pcbWritten) = 0;
virtual HRESULT CALLBACK Flush(
) = 0;
virtual HRESULT CALLBACK SetSize(
ULARGE_INTEGER cb) = 0;
virtual HRESULT CALLBACK LockRegion(
ULARGE_INTEGER libOffset,
ULARGE_INTEGER cb,
DWORD dwLockType) = 0;
virtual HRESULT CALLBACK UnlockRegion(
ULARGE_INTEGER libOffset,
ULARGE_INTEGER cb,
DWORD dwLockType) = 0;
virtual HRESULT CALLBACK Stat(
STATSTG* pstatstg,
DWORD grfStatFlag) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct ILockBytesVtbl ILockBytesVtbl;
struct ILockBytes {
const ILockBytesVtbl* lpVtbl;
};
struct ILockBytesVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
ILockBytes* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
ILockBytes* This);
ULONG (CALLBACK *Release)(
ILockBytes* This);
/*** ILockBytes methods ***/
HRESULT (CALLBACK *ReadAt)(
ILockBytes* This,
ULARGE_INTEGER ulOffset,
void* pv,
ULONG cb,
ULONG* pcbRead);
HRESULT (CALLBACK *WriteAt)(
ILockBytes* This,
ULARGE_INTEGER ulOffset,
const void* pv,
ULONG cb,
ULONG* pcbWritten);
HRESULT (CALLBACK *Flush)(
ILockBytes* This);
HRESULT (CALLBACK *SetSize)(
ILockBytes* This,
ULARGE_INTEGER cb);
HRESULT (CALLBACK *LockRegion)(
ILockBytes* This,
ULARGE_INTEGER libOffset,
ULARGE_INTEGER cb,
DWORD dwLockType);
HRESULT (CALLBACK *UnlockRegion)(
ILockBytes* This,
ULARGE_INTEGER libOffset,
ULARGE_INTEGER cb,
DWORD dwLockType);
HRESULT (CALLBACK *Stat)(
ILockBytes* This,
STATSTG* pstatstg,
DWORD grfStatFlag);
};
#define ILockBytes_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD4 (HRESULT,ReadAt,ULARGE_INTEGER,ulOffset,void*,pv,ULONG,cb,ULONG*,pcbRead) \
ICOM_METHOD4 (HRESULT,WriteAt,ULARGE_INTEGER,ulOffset,const void*,pv,ULONG,cb,ULONG*,pcbWritten) \
ICOM_METHOD (HRESULT,Flush) \
ICOM_METHOD1 (HRESULT,SetSize,ULARGE_INTEGER,cb) \
ICOM_METHOD3 (HRESULT,LockRegion,ULARGE_INTEGER,libOffset,ULARGE_INTEGER,cb,DWORD,dwLockType) \
ICOM_METHOD3 (HRESULT,UnlockRegion,ULARGE_INTEGER,libOffset,ULARGE_INTEGER,cb,DWORD,dwLockType) \
ICOM_METHOD2 (HRESULT,Stat,STATSTG*,pstatstg,DWORD,grfStatFlag)
/*** IUnknown methods ***/
#define ILockBytes_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define ILockBytes_AddRef(p) (p)->lpVtbl->AddRef(p)
#define ILockBytes_Release(p) (p)->lpVtbl->Release(p)
/*** ILockBytes methods ***/
#define ILockBytes_ReadAt(p,a,b,c,d) (p)->lpVtbl->ReadAt(p,a,b,c,d)
#define ILockBytes_WriteAt(p,a,b,c,d) (p)->lpVtbl->WriteAt(p,a,b,c,d)
#define ILockBytes_Flush(p) (p)->lpVtbl->Flush(p)
#define ILockBytes_SetSize(p,a) (p)->lpVtbl->SetSize(p,a)
#define ILockBytes_LockRegion(p,a,b,c) (p)->lpVtbl->LockRegion(p,a,b,c)
#define ILockBytes_UnlockRegion(p,a,b,c) (p)->lpVtbl->UnlockRegion(p,a,b,c)
#define ILockBytes_Stat(p,a,b) (p)->lpVtbl->Stat(p,a,b)
#endif
HRESULT CALLBACK ILockBytes_RemoteReadAt_Proxy(
ILockBytes* This,
ULARGE_INTEGER ulOffset,
byte* pv,
ULONG cb,
ULONG* pcbRead);
void __RPC_STUB ILockBytes_RemoteReadAt_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK ILockBytes_ReadAt_Proxy(
ILockBytes* This,
ULARGE_INTEGER ulOffset,
void* pv,
ULONG cb,
ULONG* pcbRead);
HRESULT __RPC_STUB ILockBytes_ReadAt_Stub(
ILockBytes* This,
ULARGE_INTEGER ulOffset,
byte* pv,
ULONG cb,
ULONG* pcbRead);
HRESULT CALLBACK ILockBytes_RemoteWriteAt_Proxy(
ILockBytes* This,
ULARGE_INTEGER ulOffset,
const byte* pv,
ULONG cb,
ULONG* pcbWritten);
void __RPC_STUB ILockBytes_RemoteWriteAt_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK ILockBytes_WriteAt_Proxy(
ILockBytes* This,
ULARGE_INTEGER ulOffset,
const void* pv,
ULONG cb,
ULONG* pcbWritten);
HRESULT __RPC_STUB ILockBytes_WriteAt_Stub(
ILockBytes* This,
ULARGE_INTEGER ulOffset,
const byte* pv,
ULONG cb,
ULONG* pcbWritten);
HRESULT CALLBACK ILockBytes_Flush_Proxy(
ILockBytes* This);
void __RPC_STUB ILockBytes_Flush_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK ILockBytes_SetSize_Proxy(
ILockBytes* This,
ULARGE_INTEGER cb);
void __RPC_STUB ILockBytes_SetSize_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK ILockBytes_LockRegion_Proxy(
ILockBytes* This,
ULARGE_INTEGER libOffset,
ULARGE_INTEGER cb,
DWORD dwLockType);
void __RPC_STUB ILockBytes_LockRegion_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK ILockBytes_UnlockRegion_Proxy(
ILockBytes* This,
ULARGE_INTEGER libOffset,
ULARGE_INTEGER cb,
DWORD dwLockType);
void __RPC_STUB ILockBytes_UnlockRegion_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK ILockBytes_Stat_Proxy(
ILockBytes* This,
STATSTG* pstatstg,
DWORD grfStatFlag);
void __RPC_STUB ILockBytes_Stat_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IFillLockBytes IFillLockBytes;
/*****************************************************************************
* IFillLockBytes interface
*/
DEFINE_GUID(IID_IFillLockBytes, 0x99caf010, 0x415e, 0x11cf, 0x88,0x14, 0x00,0xaa,0x00,0xb5,0x69,0xf5);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IFillLockBytes: IUnknown {
virtual HRESULT CALLBACK FillAppend(
const void* pv,
ULONG cb,
ULONG* pcbWritten) = 0;
virtual HRESULT CALLBACK FillAt(
ULARGE_INTEGER ulOffset,
const void* pv,
ULONG cb,
ULONG* pcbWritten) = 0;
virtual HRESULT CALLBACK SetFillSize(
ULARGE_INTEGER ulSize) = 0;
virtual HRESULT CALLBACK Terminate(
BOOL bCanceled) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IFillLockBytesVtbl IFillLockBytesVtbl;
struct IFillLockBytes {
const IFillLockBytesVtbl* lpVtbl;
};
struct IFillLockBytesVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IFillLockBytes* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IFillLockBytes* This);
ULONG (CALLBACK *Release)(
IFillLockBytes* This);
/*** IFillLockBytes methods ***/
HRESULT (CALLBACK *FillAppend)(
IFillLockBytes* This,
const void* pv,
ULONG cb,
ULONG* pcbWritten);
HRESULT (CALLBACK *FillAt)(
IFillLockBytes* This,
ULARGE_INTEGER ulOffset,
const void* pv,
ULONG cb,
ULONG* pcbWritten);
HRESULT (CALLBACK *SetFillSize)(
IFillLockBytes* This,
ULARGE_INTEGER ulSize);
HRESULT (CALLBACK *Terminate)(
IFillLockBytes* This,
BOOL bCanceled);
};
#define IFillLockBytes_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD3 (HRESULT,FillAppend,const void*,pv,ULONG,cb,ULONG*,pcbWritten) \
ICOM_METHOD4 (HRESULT,FillAt,ULARGE_INTEGER,ulOffset,const void*,pv,ULONG,cb,ULONG*,pcbWritten) \
ICOM_METHOD1 (HRESULT,SetFillSize,ULARGE_INTEGER,ulSize) \
ICOM_METHOD1 (HRESULT,Terminate,BOOL,bCanceled)
/*** IUnknown methods ***/
#define IFillLockBytes_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IFillLockBytes_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IFillLockBytes_Release(p) (p)->lpVtbl->Release(p)
/*** IFillLockBytes methods ***/
#define IFillLockBytes_FillAppend(p,a,b,c) (p)->lpVtbl->FillAppend(p,a,b,c)
#define IFillLockBytes_FillAt(p,a,b,c,d) (p)->lpVtbl->FillAt(p,a,b,c,d)
#define IFillLockBytes_SetFillSize(p,a) (p)->lpVtbl->SetFillSize(p,a)
#define IFillLockBytes_Terminate(p,a) (p)->lpVtbl->Terminate(p,a)
#endif
HRESULT CALLBACK IFillLockBytes_RemoteFillAppend_Proxy(
IFillLockBytes* This,
const byte* pv,
ULONG cb,
ULONG* pcbWritten);
void __RPC_STUB IFillLockBytes_RemoteFillAppend_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IFillLockBytes_FillAppend_Proxy(
IFillLockBytes* This,
const void* pv,
ULONG cb,
ULONG* pcbWritten);
HRESULT __RPC_STUB IFillLockBytes_FillAppend_Stub(
IFillLockBytes* This,
const byte* pv,
ULONG cb,
ULONG* pcbWritten);
HRESULT CALLBACK IFillLockBytes_RemoteFillAt_Proxy(
IFillLockBytes* This,
ULARGE_INTEGER ulOffset,
const byte* pv,
ULONG cb,
ULONG* pcbWritten);
void __RPC_STUB IFillLockBytes_RemoteFillAt_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IFillLockBytes_FillAt_Proxy(
IFillLockBytes* This,
ULARGE_INTEGER ulOffset,
const void* pv,
ULONG cb,
ULONG* pcbWritten);
HRESULT __RPC_STUB IFillLockBytes_FillAt_Stub(
IFillLockBytes* This,
ULARGE_INTEGER ulOffset,
const byte* pv,
ULONG cb,
ULONG* pcbWritten);
HRESULT CALLBACK IFillLockBytes_SetFillSize_Proxy(
IFillLockBytes* This,
ULARGE_INTEGER ulSize);
void __RPC_STUB IFillLockBytes_SetFillSize_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IFillLockBytes_Terminate_Proxy(
IFillLockBytes* This,
BOOL bCanceled);
void __RPC_STUB IFillLockBytes_Terminate_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IProgressNotify IProgressNotify;
/*****************************************************************************
* IProgressNotify interface
*/
DEFINE_GUID(IID_IProgressNotify, 0xa9d758a0, 0x4617, 0x11cf, 0x95,0xfc, 0x00,0xaa,0x00,0x68,0x0d,0xb4);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IProgressNotify: IUnknown {
virtual HRESULT CALLBACK OnProgress(
DWORD dwProgressCurrent,
DWORD dwProgressMaximum,
BOOL fAccurate,
BOOL fOwner) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IProgressNotifyVtbl IProgressNotifyVtbl;
struct IProgressNotify {
const IProgressNotifyVtbl* lpVtbl;
};
struct IProgressNotifyVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IProgressNotify* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IProgressNotify* This);
ULONG (CALLBACK *Release)(
IProgressNotify* This);
/*** IProgressNotify methods ***/
HRESULT (CALLBACK *OnProgress)(
IProgressNotify* This,
DWORD dwProgressCurrent,
DWORD dwProgressMaximum,
BOOL fAccurate,
BOOL fOwner);
};
#define IProgressNotify_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD4 (HRESULT,OnProgress,DWORD,dwProgressCurrent,DWORD,dwProgressMaximum,BOOL,fAccurate,BOOL,fOwner)
/*** IUnknown methods ***/
#define IProgressNotify_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IProgressNotify_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IProgressNotify_Release(p) (p)->lpVtbl->Release(p)
/*** IProgressNotify methods ***/
#define IProgressNotify_OnProgress(p,a,b,c,d) (p)->lpVtbl->OnProgress(p,a,b,c,d)
#endif
HRESULT CALLBACK IProgressNotify_OnProgress_Proxy(
IProgressNotify* This,
DWORD dwProgressCurrent,
DWORD dwProgressMaximum,
BOOL fAccurate,
BOOL fOwner);
void __RPC_STUB IProgressNotify_OnProgress_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct ILayoutStorage ILayoutStorage;
typedef struct tagStorageLayout {
DWORD LayoutType;
OLECHAR *pwcsElementName;
LARGE_INTEGER cOffset;
LARGE_INTEGER cBytes;
} StorageLayout;
/*****************************************************************************
* ILayoutStorage interface
*/
DEFINE_GUID(IID_ILayoutStorage, 0x0e6d4d90, 0x6738, 0x11cf, 0x96,0x08, 0x00,0xaa,0x00,0x68,0x0d,0xb4);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct ILayoutStorage: IUnknown {
virtual HRESULT CALLBACK LayoutScript(
StorageLayout* pStorageLayout,
DWORD nEntries,
DWORD glfInterleavedFlag) = 0;
virtual HRESULT CALLBACK BeginMonitor(
) = 0;
virtual HRESULT CALLBACK EndMonitor(
) = 0;
virtual HRESULT CALLBACK ReLayoutDocfile(
OLECHAR* pwcsNewDfName) = 0;
virtual HRESULT CALLBACK ReLayoutDocfileOnILockBytes(
ILockBytes* pILockBytes) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct ILayoutStorageVtbl ILayoutStorageVtbl;
struct ILayoutStorage {
const ILayoutStorageVtbl* lpVtbl;
};
struct ILayoutStorageVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
ILayoutStorage* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
ILayoutStorage* This);
ULONG (CALLBACK *Release)(
ILayoutStorage* This);
/*** ILayoutStorage methods ***/
HRESULT (CALLBACK *LayoutScript)(
ILayoutStorage* This,
StorageLayout* pStorageLayout,
DWORD nEntries,
DWORD glfInterleavedFlag);
HRESULT (CALLBACK *BeginMonitor)(
ILayoutStorage* This);
HRESULT (CALLBACK *EndMonitor)(
ILayoutStorage* This);
HRESULT (CALLBACK *ReLayoutDocfile)(
ILayoutStorage* This,
OLECHAR* pwcsNewDfName);
HRESULT (CALLBACK *ReLayoutDocfileOnILockBytes)(
ILayoutStorage* This,
ILockBytes* pILockBytes);
};
#define ILayoutStorage_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD3 (HRESULT,LayoutScript,StorageLayout*,pStorageLayout,DWORD,nEntries,DWORD,glfInterleavedFlag) \
ICOM_METHOD (HRESULT,BeginMonitor) \
ICOM_METHOD (HRESULT,EndMonitor) \
ICOM_METHOD1 (HRESULT,ReLayoutDocfile,OLECHAR*,pwcsNewDfName) \
ICOM_METHOD1 (HRESULT,ReLayoutDocfileOnILockBytes,ILockBytes*,pILockBytes)
/*** IUnknown methods ***/
#define ILayoutStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define ILayoutStorage_AddRef(p) (p)->lpVtbl->AddRef(p)
#define ILayoutStorage_Release(p) (p)->lpVtbl->Release(p)
/*** ILayoutStorage methods ***/
#define ILayoutStorage_LayoutScript(p,a,b,c) (p)->lpVtbl->LayoutScript(p,a,b,c)
#define ILayoutStorage_BeginMonitor(p) (p)->lpVtbl->BeginMonitor(p)
#define ILayoutStorage_EndMonitor(p) (p)->lpVtbl->EndMonitor(p)
#define ILayoutStorage_ReLayoutDocfile(p,a) (p)->lpVtbl->ReLayoutDocfile(p,a)
#define ILayoutStorage_ReLayoutDocfileOnILockBytes(p,a) (p)->lpVtbl->ReLayoutDocfileOnILockBytes(p,a)
#endif
HRESULT CALLBACK ILayoutStorage_LayoutScript_Proxy(
ILayoutStorage* This,
StorageLayout* pStorageLayout,
DWORD nEntries,
DWORD glfInterleavedFlag);
void __RPC_STUB ILayoutStorage_LayoutScript_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK ILayoutStorage_BeginMonitor_Proxy(
ILayoutStorage* This);
void __RPC_STUB ILayoutStorage_BeginMonitor_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK ILayoutStorage_EndMonitor_Proxy(
ILayoutStorage* This);
void __RPC_STUB ILayoutStorage_EndMonitor_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK ILayoutStorage_ReLayoutDocfile_Proxy(
ILayoutStorage* This,
OLECHAR* pwcsNewDfName);
void __RPC_STUB ILayoutStorage_ReLayoutDocfile_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK ILayoutStorage_ReLayoutDocfileOnILockBytes_Proxy(
ILayoutStorage* This,
ILockBytes* pILockBytes);
void __RPC_STUB ILayoutStorage_ReLayoutDocfileOnILockBytes_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IEnumFORMATETC IEnumFORMATETC;
typedef IEnumFORMATETC *LPENUMFORMATETC;
typedef struct tagDVTARGETDEVICE {
DWORD tdSize;
WORD tdDriverNameOffset;
WORD tdDeviceNameOffset;
WORD tdPortNameOffset;
WORD tdExtDevmodeOffset;
BYTE tdData[1];
} DVTARGETDEVICE;
typedef CLIPFORMAT *LPCLIPFORMAT;
typedef struct tagFORMATETC {
CLIPFORMAT cfFormat;
DVTARGETDEVICE *ptd;
DWORD dwAspect;
LONG lindex;
DWORD tymed;
} FORMATETC, *LPFORMATETC;
/*****************************************************************************
* IEnumFORMATETC interface
*/
DEFINE_GUID(IID_IEnumFORMATETC, 0x00000103, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IEnumFORMATETC: IUnknown {
virtual HRESULT CALLBACK Next(
ULONG celt,
FORMATETC* rgelt,
ULONG* pceltFetched) = 0;
virtual HRESULT CALLBACK Skip(
ULONG celt) = 0;
virtual HRESULT CALLBACK Reset(
) = 0;
virtual HRESULT CALLBACK Clone(
IEnumFORMATETC** ppenum) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IEnumFORMATETCVtbl IEnumFORMATETCVtbl;
struct IEnumFORMATETC {
const IEnumFORMATETCVtbl* lpVtbl;
};
struct IEnumFORMATETCVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IEnumFORMATETC* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IEnumFORMATETC* This);
ULONG (CALLBACK *Release)(
IEnumFORMATETC* This);
/*** IEnumFORMATETC methods ***/
HRESULT (CALLBACK *Next)(
IEnumFORMATETC* This,
ULONG celt,
FORMATETC* rgelt,
ULONG* pceltFetched);
HRESULT (CALLBACK *Skip)(
IEnumFORMATETC* This,
ULONG celt);
HRESULT (CALLBACK *Reset)(
IEnumFORMATETC* This);
HRESULT (CALLBACK *Clone)(
IEnumFORMATETC* This,
IEnumFORMATETC** ppenum);
};
#define IEnumFORMATETC_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD3 (HRESULT,Next,ULONG,celt,FORMATETC*,rgelt,ULONG*,pceltFetched) \
ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \
ICOM_METHOD (HRESULT,Reset) \
ICOM_METHOD1 (HRESULT,Clone,IEnumFORMATETC**,ppenum)
/*** IUnknown methods ***/
#define IEnumFORMATETC_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IEnumFORMATETC_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IEnumFORMATETC_Release(p) (p)->lpVtbl->Release(p)
/*** IEnumFORMATETC methods ***/
#define IEnumFORMATETC_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
#define IEnumFORMATETC_Skip(p,a) (p)->lpVtbl->Skip(p,a)
#define IEnumFORMATETC_Reset(p) (p)->lpVtbl->Reset(p)
#define IEnumFORMATETC_Clone(p,a) (p)->lpVtbl->Clone(p,a)
#endif
HRESULT CALLBACK IEnumFORMATETC_RemoteNext_Proxy(
IEnumFORMATETC* This,
ULONG celt,
FORMATETC* rgelt,
ULONG* pceltFetched);
void __RPC_STUB IEnumFORMATETC_RemoteNext_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumFORMATETC_Next_Proxy(
IEnumFORMATETC* This,
ULONG celt,
FORMATETC* rgelt,
ULONG* pceltFetched);
HRESULT __RPC_STUB IEnumFORMATETC_Next_Stub(
IEnumFORMATETC* This,
ULONG celt,
FORMATETC* rgelt,
ULONG* pceltFetched);
HRESULT CALLBACK IEnumFORMATETC_Skip_Proxy(
IEnumFORMATETC* This,
ULONG celt);
void __RPC_STUB IEnumFORMATETC_Skip_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumFORMATETC_Reset_Proxy(
IEnumFORMATETC* This);
void __RPC_STUB IEnumFORMATETC_Reset_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumFORMATETC_Clone_Proxy(
IEnumFORMATETC* This,
IEnumFORMATETC** ppenum);
void __RPC_STUB IEnumFORMATETC_Clone_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IEnumSTATDATA IEnumSTATDATA;
typedef IEnumSTATDATA *LPENUMSTATDATA;
typedef enum tagADVF {
ADVF_NODATA = 1,
ADVF_PRIMEFIRST = 2,
ADVF_ONLYONCE = 4,
ADVF_DATAONSTOP = 64,
ADVFCACHE_NOHANDLER = 8,
ADVFCACHE_FORCEBUILTIN = 16,
ADVFCACHE_ONSAVE = 32
} ADVF;
typedef struct tagSTATDATA {
FORMATETC formatetc;
DWORD advf;
IAdviseSink *pAdvSink;
DWORD dwConnection;
} STATDATA, *LPSTATDATA;
/*****************************************************************************
* IEnumSTATDATA interface
*/
DEFINE_GUID(IID_IEnumSTATDATA, 0x00000105, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IEnumSTATDATA: IUnknown {
virtual HRESULT CALLBACK Next(
ULONG celt,
STATDATA* rgelt,
ULONG* pceltFetched) = 0;
virtual HRESULT CALLBACK Skip(
ULONG celt) = 0;
virtual HRESULT CALLBACK Reset(
) = 0;
virtual HRESULT CALLBACK Clone(
IEnumSTATDATA** ppenum) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IEnumSTATDATAVtbl IEnumSTATDATAVtbl;
struct IEnumSTATDATA {
const IEnumSTATDATAVtbl* lpVtbl;
};
struct IEnumSTATDATAVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IEnumSTATDATA* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IEnumSTATDATA* This);
ULONG (CALLBACK *Release)(
IEnumSTATDATA* This);
/*** IEnumSTATDATA methods ***/
HRESULT (CALLBACK *Next)(
IEnumSTATDATA* This,
ULONG celt,
STATDATA* rgelt,
ULONG* pceltFetched);
HRESULT (CALLBACK *Skip)(
IEnumSTATDATA* This,
ULONG celt);
HRESULT (CALLBACK *Reset)(
IEnumSTATDATA* This);
HRESULT (CALLBACK *Clone)(
IEnumSTATDATA* This,
IEnumSTATDATA** ppenum);
};
#define IEnumSTATDATA_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD3 (HRESULT,Next,ULONG,celt,STATDATA*,rgelt,ULONG*,pceltFetched) \
ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \
ICOM_METHOD (HRESULT,Reset) \
ICOM_METHOD1 (HRESULT,Clone,IEnumSTATDATA**,ppenum)
/*** IUnknown methods ***/
#define IEnumSTATDATA_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IEnumSTATDATA_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IEnumSTATDATA_Release(p) (p)->lpVtbl->Release(p)
/*** IEnumSTATDATA methods ***/
#define IEnumSTATDATA_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
#define IEnumSTATDATA_Skip(p,a) (p)->lpVtbl->Skip(p,a)
#define IEnumSTATDATA_Reset(p) (p)->lpVtbl->Reset(p)
#define IEnumSTATDATA_Clone(p,a) (p)->lpVtbl->Clone(p,a)
#endif
HRESULT CALLBACK IEnumSTATDATA_RemoteNext_Proxy(
IEnumSTATDATA* This,
ULONG celt,
STATDATA* rgelt,
ULONG* pceltFetched);
void __RPC_STUB IEnumSTATDATA_RemoteNext_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumSTATDATA_Next_Proxy(
IEnumSTATDATA* This,
ULONG celt,
STATDATA* rgelt,
ULONG* pceltFetched);
HRESULT __RPC_STUB IEnumSTATDATA_Next_Stub(
IEnumSTATDATA* This,
ULONG celt,
STATDATA* rgelt,
ULONG* pceltFetched);
HRESULT CALLBACK IEnumSTATDATA_Skip_Proxy(
IEnumSTATDATA* This,
ULONG celt);
void __RPC_STUB IEnumSTATDATA_Skip_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumSTATDATA_Reset_Proxy(
IEnumSTATDATA* This);
void __RPC_STUB IEnumSTATDATA_Reset_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumSTATDATA_Clone_Proxy(
IEnumSTATDATA* This,
IEnumSTATDATA** ppenum);
void __RPC_STUB IEnumSTATDATA_Clone_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef IAdviseSink *LPADVISESINK;
typedef enum tagTYMED {
TYMED_HGLOBAL = 1,
TYMED_FILE = 2,
TYMED_ISTREAM = 4,
TYMED_ISTORAGE = 8,
TYMED_GDI = 16,
TYMED_MFPICT = 32,
TYMED_ENHMF = 64,
TYMED_NULL = 0
} TYMED;
typedef struct tagRemSTGMEDIUM {
DWORD tymed;
DWORD dwHandleType;
unsigned long pData;
unsigned long pUnkForRelease;
unsigned long cbData;
byte data[1];
} RemSTGMEDIUM;
typedef struct tagSTGMEDIUM {
DWORD tymed;
union {
HBITMAP hBitmap;
HMETAFILEPICT hMetaFilePict;
HENHMETAFILE hEnhMetaFile;
HGLOBAL hGlobal;
LPOLESTR lpszFileName;
IStream *pstm;
IStorage *pstg;
} DUMMYUNIONNAME;
IUnknown *pUnkForRelease;
} uSTGMEDIUM;
typedef struct _GDI_OBJECT {
DWORD ObjectType;
union {
wireHBITMAP hBitmap;
wireHPALETTE hPalette;
wireHGLOBAL hGeneric;
} u;
} GDI_OBJECT;
typedef struct _userSTGMEDIUM {
struct _STGMEDIUM_UNION {
DWORD tymed;
union {
wireHMETAFILEPICT hMetaFilePict;
wireHENHMETAFILE hHEnhMetaFile;
GDI_OBJECT *hGdiHandle;
wireHGLOBAL hGlobal;
LPOLESTR lpszFileName;
BYTE_BLOB *pstm;
BYTE_BLOB *pstg;
} u;
} DUMMYSTRUCTNAME;
IUnknown *pUnkForRelease;
} userSTGMEDIUM;
typedef userSTGMEDIUM *wireSTGMEDIUM;
typedef uSTGMEDIUM STGMEDIUM;
unsigned long __RPC_USER STGMEDIUM_UserSize (unsigned long *, unsigned long, STGMEDIUM *);
unsigned char * __RPC_USER STGMEDIUM_UserMarshal (unsigned long *, unsigned char *, STGMEDIUM *);
unsigned char * __RPC_USER STGMEDIUM_UserUnmarshal(unsigned long *, unsigned char *, STGMEDIUM *);
void __RPC_USER STGMEDIUM_UserFree (unsigned long *, STGMEDIUM *);
typedef userSTGMEDIUM *wireASYNC_STGMEDIUM;
typedef STGMEDIUM ASYNC_STGMEDIUM;
unsigned long __RPC_USER ASYNC_STGMEDIUM_UserSize (unsigned long *, unsigned long, ASYNC_STGMEDIUM *);
unsigned char * __RPC_USER ASYNC_STGMEDIUM_UserMarshal (unsigned long *, unsigned char *, ASYNC_STGMEDIUM *);
unsigned char * __RPC_USER ASYNC_STGMEDIUM_UserUnmarshal(unsigned long *, unsigned char *, ASYNC_STGMEDIUM *);
void __RPC_USER ASYNC_STGMEDIUM_UserFree (unsigned long *, ASYNC_STGMEDIUM *);
typedef STGMEDIUM *LPSTGMEDIUM;
typedef struct _userFLAG_STGMEDIUM {
long ContextFlags;
long fPassOwnership;
userSTGMEDIUM Stgmed;
} userFLAG_STGMEDIUM;
typedef userFLAG_STGMEDIUM *wireFLAG_STGMEDIUM;
typedef struct _FLAG_STGMEDIUM {
long ContextFlags;
long fPassOwnership;
STGMEDIUM Stgmed;
} FLAG_STGMEDIUM;
unsigned long __RPC_USER FLAG_STGMEDIUM_UserSize (unsigned long *, unsigned long, FLAG_STGMEDIUM *);
unsigned char * __RPC_USER FLAG_STGMEDIUM_UserMarshal (unsigned long *, unsigned char *, FLAG_STGMEDIUM *);
unsigned char * __RPC_USER FLAG_STGMEDIUM_UserUnmarshal(unsigned long *, unsigned char *, FLAG_STGMEDIUM *);
void __RPC_USER FLAG_STGMEDIUM_UserFree (unsigned long *, FLAG_STGMEDIUM *);
/*****************************************************************************
* IAdviseSink interface
*/
DEFINE_GUID(IID_IAdviseSink, 0x0000010f, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IAdviseSink: IUnknown {
virtual void CALLBACK OnDataChange(
FORMATETC* pFormatetc,
STGMEDIUM* pStgmed) = 0;
virtual void CALLBACK OnViewChange(
DWORD dwAspect,
LONG lindex) = 0;
virtual void CALLBACK OnRename(
IMoniker* pmk) = 0;
virtual void CALLBACK OnSave(
) = 0;
virtual void CALLBACK OnClose(
) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IAdviseSinkVtbl IAdviseSinkVtbl;
struct IAdviseSink {
const IAdviseSinkVtbl* lpVtbl;
};
struct IAdviseSinkVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IAdviseSink* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IAdviseSink* This);
ULONG (CALLBACK *Release)(
IAdviseSink* This);
/*** IAdviseSink methods ***/
void (CALLBACK *OnDataChange)(
IAdviseSink* This,
FORMATETC* pFormatetc,
STGMEDIUM* pStgmed);
void (CALLBACK *OnViewChange)(
IAdviseSink* This,
DWORD dwAspect,
LONG lindex);
void (CALLBACK *OnRename)(
IAdviseSink* This,
IMoniker* pmk);
void (CALLBACK *OnSave)(
IAdviseSink* This);
void (CALLBACK *OnClose)(
IAdviseSink* This);
};
#define IAdviseSink_IMETHODS \
IUnknown_IMETHODS \
ICOM_VMETHOD2(OnDataChange,FORMATETC*,pFormatetc,STGMEDIUM*,pStgmed) \
ICOM_VMETHOD2(OnViewChange,DWORD,dwAspect,LONG,lindex) \
ICOM_VMETHOD1(OnRename,IMoniker*,pmk) \
ICOM_VMETHOD (OnSave) \
ICOM_VMETHOD (OnClose)
/*** IUnknown methods ***/
#define IAdviseSink_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IAdviseSink_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IAdviseSink_Release(p) (p)->lpVtbl->Release(p)
/*** IAdviseSink methods ***/
#define IAdviseSink_OnDataChange(p,a,b) (p)->lpVtbl->OnDataChange(p,a,b)
#define IAdviseSink_OnViewChange(p,a,b) (p)->lpVtbl->OnViewChange(p,a,b)
#define IAdviseSink_OnRename(p,a) (p)->lpVtbl->OnRename(p,a)
#define IAdviseSink_OnSave(p) (p)->lpVtbl->OnSave(p)
#define IAdviseSink_OnClose(p) (p)->lpVtbl->OnClose(p)
#endif
HRESULT CALLBACK IAdviseSink_RemoteOnDataChange_Proxy(
IAdviseSink* This,
IAsyncManager** ppIAM,
FORMATETC* pFormatetc,
ASYNC_STGMEDIUM* pStgmed);
void __RPC_STUB IAdviseSink_RemoteOnDataChange_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IAdviseSink_OnDataChange_Proxy(
IAdviseSink* This,
FORMATETC* pFormatetc,
STGMEDIUM* pStgmed);
HRESULT __RPC_STUB IAdviseSink_OnDataChange_Stub(
IAdviseSink* This,
IAsyncManager** ppIAM,
FORMATETC* pFormatetc,
ASYNC_STGMEDIUM* pStgmed);
HRESULT CALLBACK IAdviseSink_RemoteOnViewChange_Proxy(
IAdviseSink* This,
IAsyncManager** ppIAM,
DWORD dwAspect,
LONG lindex);
void __RPC_STUB IAdviseSink_RemoteOnViewChange_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IAdviseSink_OnViewChange_Proxy(
IAdviseSink* This,
DWORD dwAspect,
LONG lindex);
HRESULT __RPC_STUB IAdviseSink_OnViewChange_Stub(
IAdviseSink* This,
IAsyncManager** ppIAM,
DWORD dwAspect,
LONG lindex);
HRESULT CALLBACK IAdviseSink_RemoteOnRename_Proxy(
IAdviseSink* This,
IAsyncManager** ppIAM,
IMoniker* pmk);
void __RPC_STUB IAdviseSink_RemoteOnRename_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IAdviseSink_OnRename_Proxy(
IAdviseSink* This,
IMoniker* pmk);
HRESULT __RPC_STUB IAdviseSink_OnRename_Stub(
IAdviseSink* This,
IAsyncManager** ppIAM,
IMoniker* pmk);
HRESULT CALLBACK IAdviseSink_RemoteOnSave_Proxy(
IAdviseSink* This,
IAsyncManager** ppIAM);
void __RPC_STUB IAdviseSink_RemoteOnSave_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IAdviseSink_OnSave_Proxy(
IAdviseSink* This);
HRESULT __RPC_STUB IAdviseSink_OnSave_Stub(
IAdviseSink* This,
IAsyncManager** ppIAM);
HRESULT CALLBACK IAdviseSink_RemoteOnClose_Proxy(
IAdviseSink* This);
void __RPC_STUB IAdviseSink_RemoteOnClose_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IAdviseSink_OnClose_Proxy(
IAdviseSink* This);
HRESULT __RPC_STUB IAdviseSink_OnClose_Stub(
IAdviseSink* This);
typedef struct IAdviseSink2 IAdviseSink2;
typedef IAdviseSink2 *LPADVISESINK2;
/*****************************************************************************
* IAdviseSink2 interface
*/
DEFINE_GUID(IID_IAdviseSink2, 0x00000125, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IAdviseSink2: IAdviseSink {
virtual void CALLBACK OnLinkSrcChange(
IMoniker* pmk) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IAdviseSink2Vtbl IAdviseSink2Vtbl;
struct IAdviseSink2 {
const IAdviseSink2Vtbl* lpVtbl;
};
struct IAdviseSink2Vtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IAdviseSink2* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IAdviseSink2* This);
ULONG (CALLBACK *Release)(
IAdviseSink2* This);
/*** IAdviseSink methods ***/
void (CALLBACK *OnDataChange)(
IAdviseSink2* This,
FORMATETC* pFormatetc,
STGMEDIUM* pStgmed);
void (CALLBACK *OnViewChange)(
IAdviseSink2* This,
DWORD dwAspect,
LONG lindex);
void (CALLBACK *OnRename)(
IAdviseSink2* This,
IMoniker* pmk);
void (CALLBACK *OnSave)(
IAdviseSink2* This);
void (CALLBACK *OnClose)(
IAdviseSink2* This);
/*** IAdviseSink2 methods ***/
void (CALLBACK *OnLinkSrcChange)(
IAdviseSink2* This,
IMoniker* pmk);
};
#define IAdviseSink2_IMETHODS \
IAdviseSink_IMETHODS \
ICOM_VMETHOD1(OnLinkSrcChange,IMoniker*,pmk)
/*** IUnknown methods ***/
#define IAdviseSink2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IAdviseSink2_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IAdviseSink2_Release(p) (p)->lpVtbl->Release(p)
/*** IAdviseSink methods ***/
#define IAdviseSink2_OnDataChange(p,a,b) (p)->lpVtbl->OnDataChange(p,a,b)
#define IAdviseSink2_OnViewChange(p,a,b) (p)->lpVtbl->OnViewChange(p,a,b)
#define IAdviseSink2_OnRename(p,a) (p)->lpVtbl->OnRename(p,a)
#define IAdviseSink2_OnSave(p) (p)->lpVtbl->OnSave(p)
#define IAdviseSink2_OnClose(p) (p)->lpVtbl->OnClose(p)
/*** IAdviseSink2 methods ***/
#define IAdviseSink2_OnLinkSrcChange(p,a) (p)->lpVtbl->OnLinkSrcChange(p,a)
#endif
HRESULT CALLBACK IAdviseSink2_RemoteOnLinkSrcChange_Proxy(
IAdviseSink2* This,
IAsyncManager** ppIAM,
IMoniker* pmk);
void __RPC_STUB IAdviseSink2_RemoteOnLinkSrcChange_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IAdviseSink2_OnLinkSrcChange_Proxy(
IAdviseSink2* This,
IMoniker* pmk);
HRESULT __RPC_STUB IAdviseSink2_OnLinkSrcChange_Stub(
IAdviseSink2* This,
IAsyncManager** ppIAM,
IMoniker* pmk);
typedef struct IDataObject IDataObject;
typedef IDataObject *LPDATAOBJECT;
typedef enum tagDATADIR {
DATADIR_GET = 1,
DATADIR_SET = 2
} DATADIR;
/*****************************************************************************
* IDataObject interface
*/
DEFINE_GUID(IID_IDataObject, 0x0000010e, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IDataObject: IUnknown {
virtual HRESULT CALLBACK GetData(
FORMATETC* pformatetcIn,
STGMEDIUM* pmedium) = 0;
virtual HRESULT CALLBACK GetDataHere(
FORMATETC* pformatetc,
STGMEDIUM* pmedium) = 0;
virtual HRESULT CALLBACK QueryGetData(
FORMATETC* pformatetc) = 0;
virtual HRESULT CALLBACK GetCanonicalFormatEtc(
FORMATETC* pformatectIn,
FORMATETC* pformatetcOut) = 0;
virtual HRESULT CALLBACK SetData(
FORMATETC* pformatetc,
STGMEDIUM* pmedium,
BOOL fRelease) = 0;
virtual HRESULT CALLBACK EnumFormatEtc(
DWORD dwDirection,
IEnumFORMATETC** ppenumFormatEtc) = 0;
virtual HRESULT CALLBACK DAdvise(
FORMATETC* pformatetc,
DWORD advf,
IAdviseSink* pAdvSink,
DWORD* pdwConnection) = 0;
virtual HRESULT CALLBACK DUnadvise(
DWORD dwConnection) = 0;
virtual HRESULT CALLBACK EnumDAdvise(
IEnumSTATDATA** ppenumAdvise) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IDataObjectVtbl IDataObjectVtbl;
struct IDataObject {
const IDataObjectVtbl* lpVtbl;
};
struct IDataObjectVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IDataObject* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IDataObject* This);
ULONG (CALLBACK *Release)(
IDataObject* This);
/*** IDataObject methods ***/
HRESULT (CALLBACK *GetData)(
IDataObject* This,
FORMATETC* pformatetcIn,
STGMEDIUM* pmedium);
HRESULT (CALLBACK *GetDataHere)(
IDataObject* This,
FORMATETC* pformatetc,
STGMEDIUM* pmedium);
HRESULT (CALLBACK *QueryGetData)(
IDataObject* This,
FORMATETC* pformatetc);
HRESULT (CALLBACK *GetCanonicalFormatEtc)(
IDataObject* This,
FORMATETC* pformatectIn,
FORMATETC* pformatetcOut);
HRESULT (CALLBACK *SetData)(
IDataObject* This,
FORMATETC* pformatetc,
STGMEDIUM* pmedium,
BOOL fRelease);
HRESULT (CALLBACK *EnumFormatEtc)(
IDataObject* This,
DWORD dwDirection,
IEnumFORMATETC** ppenumFormatEtc);
HRESULT (CALLBACK *DAdvise)(
IDataObject* This,
FORMATETC* pformatetc,
DWORD advf,
IAdviseSink* pAdvSink,
DWORD* pdwConnection);
HRESULT (CALLBACK *DUnadvise)(
IDataObject* This,
DWORD dwConnection);
HRESULT (CALLBACK *EnumDAdvise)(
IDataObject* This,
IEnumSTATDATA** ppenumAdvise);
};
#define IDataObject_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD2 (HRESULT,GetData,FORMATETC*,pformatetcIn,STGMEDIUM*,pmedium) \
ICOM_METHOD2 (HRESULT,GetDataHere,FORMATETC*,pformatetc,STGMEDIUM*,pmedium) \
ICOM_METHOD1 (HRESULT,QueryGetData,FORMATETC*,pformatetc) \
ICOM_METHOD2 (HRESULT,GetCanonicalFormatEtc,FORMATETC*,pformatectIn,FORMATETC*,pformatetcOut) \
ICOM_METHOD3 (HRESULT,SetData,FORMATETC*,pformatetc,STGMEDIUM*,pmedium,BOOL,fRelease) \
ICOM_METHOD2 (HRESULT,EnumFormatEtc,DWORD,dwDirection,IEnumFORMATETC**,ppenumFormatEtc) \
ICOM_METHOD4 (HRESULT,DAdvise,FORMATETC*,pformatetc,DWORD,advf,IAdviseSink*,pAdvSink,DWORD*,pdwConnection) \
ICOM_METHOD1 (HRESULT,DUnadvise,DWORD,dwConnection) \
ICOM_METHOD1 (HRESULT,EnumDAdvise,IEnumSTATDATA**,ppenumAdvise)
/*** IUnknown methods ***/
#define IDataObject_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IDataObject_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IDataObject_Release(p) (p)->lpVtbl->Release(p)
/*** IDataObject methods ***/
#define IDataObject_GetData(p,a,b) (p)->lpVtbl->GetData(p,a,b)
#define IDataObject_GetDataHere(p,a,b) (p)->lpVtbl->GetDataHere(p,a,b)
#define IDataObject_QueryGetData(p,a) (p)->lpVtbl->QueryGetData(p,a)
#define IDataObject_GetCanonicalFormatEtc(p,a,b) (p)->lpVtbl->GetCanonicalFormatEtc(p,a,b)
#define IDataObject_SetData(p,a,b,c) (p)->lpVtbl->SetData(p,a,b,c)
#define IDataObject_EnumFormatEtc(p,a,b) (p)->lpVtbl->EnumFormatEtc(p,a,b)
#define IDataObject_DAdvise(p,a,b,c,d) (p)->lpVtbl->DAdvise(p,a,b,c,d)
#define IDataObject_DUnadvise(p,a) (p)->lpVtbl->DUnadvise(p,a)
#define IDataObject_EnumDAdvise(p,a) (p)->lpVtbl->EnumDAdvise(p,a)
#endif
HRESULT CALLBACK IDataObject_RemoteGetData_Proxy(
IDataObject* This,
FORMATETC* pformatetcIn,
STGMEDIUM* pRemoteMedium);
void __RPC_STUB IDataObject_RemoteGetData_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IDataObject_GetData_Proxy(
IDataObject* This,
FORMATETC* pformatetcIn,
STGMEDIUM* pmedium);
HRESULT __RPC_STUB IDataObject_GetData_Stub(
IDataObject* This,
FORMATETC* pformatetcIn,
STGMEDIUM* pRemoteMedium);
HRESULT CALLBACK IDataObject_RemoteGetDataHere_Proxy(
IDataObject* This,
FORMATETC* pformatetc,
STGMEDIUM* pRemoteMedium);
void __RPC_STUB IDataObject_RemoteGetDataHere_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IDataObject_GetDataHere_Proxy(
IDataObject* This,
FORMATETC* pformatetc,
STGMEDIUM* pmedium);
HRESULT __RPC_STUB IDataObject_GetDataHere_Stub(
IDataObject* This,
FORMATETC* pformatetc,
STGMEDIUM* pRemoteMedium);
HRESULT CALLBACK IDataObject_QueryGetData_Proxy(
IDataObject* This,
FORMATETC* pformatetc);
void __RPC_STUB IDataObject_QueryGetData_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IDataObject_GetCanonicalFormatEtc_Proxy(
IDataObject* This,
FORMATETC* pformatectIn,
FORMATETC* pformatetcOut);
void __RPC_STUB IDataObject_GetCanonicalFormatEtc_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IDataObject_RemoteSetData_Proxy(
IDataObject* This,
FORMATETC* pformatetc,
FLAG_STGMEDIUM* pmedium,
BOOL fRelease);
void __RPC_STUB IDataObject_RemoteSetData_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IDataObject_SetData_Proxy(
IDataObject* This,
FORMATETC* pformatetc,
STGMEDIUM* pmedium,
BOOL fRelease);
HRESULT __RPC_STUB IDataObject_SetData_Stub(
IDataObject* This,
FORMATETC* pformatetc,
FLAG_STGMEDIUM* pmedium,
BOOL fRelease);
HRESULT CALLBACK IDataObject_EnumFormatEtc_Proxy(
IDataObject* This,
DWORD dwDirection,
IEnumFORMATETC** ppenumFormatEtc);
void __RPC_STUB IDataObject_EnumFormatEtc_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IDataObject_DAdvise_Proxy(
IDataObject* This,
FORMATETC* pformatetc,
DWORD advf,
IAdviseSink* pAdvSink,
DWORD* pdwConnection);
void __RPC_STUB IDataObject_DAdvise_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IDataObject_DUnadvise_Proxy(
IDataObject* This,
DWORD dwConnection);
void __RPC_STUB IDataObject_DUnadvise_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IDataObject_EnumDAdvise_Proxy(
IDataObject* This,
IEnumSTATDATA** ppenumAdvise);
void __RPC_STUB IDataObject_EnumDAdvise_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IDataAdviseHolder IDataAdviseHolder;
typedef IDataAdviseHolder *LPDATAADVISEHOLDER;
/*****************************************************************************
* IDataAdviseHolder interface
*/
DEFINE_GUID(IID_IDataAdviseHolder, 0x00000110, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IDataAdviseHolder: IUnknown {
virtual HRESULT CALLBACK Advise(
IDataObject* pDataObject,
FORMATETC* pFetc,
DWORD advf,
IAdviseSink* pAdvise,
DWORD* pdwConnection) = 0;
virtual HRESULT CALLBACK Unadvise(
DWORD dwConnection) = 0;
virtual HRESULT CALLBACK EnumAdvise(
IEnumSTATDATA** ppenumAdvise) = 0;
virtual HRESULT CALLBACK SendOnDataChange(
IDataObject* pDataObject,
DWORD dwReserved,
DWORD advf) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IDataAdviseHolderVtbl IDataAdviseHolderVtbl;
struct IDataAdviseHolder {
const IDataAdviseHolderVtbl* lpVtbl;
};
struct IDataAdviseHolderVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IDataAdviseHolder* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IDataAdviseHolder* This);
ULONG (CALLBACK *Release)(
IDataAdviseHolder* This);
/*** IDataAdviseHolder methods ***/
HRESULT (CALLBACK *Advise)(
IDataAdviseHolder* This,
IDataObject* pDataObject,
FORMATETC* pFetc,
DWORD advf,
IAdviseSink* pAdvise,
DWORD* pdwConnection);
HRESULT (CALLBACK *Unadvise)(
IDataAdviseHolder* This,
DWORD dwConnection);
HRESULT (CALLBACK *EnumAdvise)(
IDataAdviseHolder* This,
IEnumSTATDATA** ppenumAdvise);
HRESULT (CALLBACK *SendOnDataChange)(
IDataAdviseHolder* This,
IDataObject* pDataObject,
DWORD dwReserved,
DWORD advf);
};
#define IDataAdviseHolder_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD5 (HRESULT,Advise,IDataObject*,pDataObject,FORMATETC*,pFetc,DWORD,advf,IAdviseSink*,pAdvise,DWORD*,pdwConnection) \
ICOM_METHOD1 (HRESULT,Unadvise,DWORD,dwConnection) \
ICOM_METHOD1 (HRESULT,EnumAdvise,IEnumSTATDATA**,ppenumAdvise) \
ICOM_METHOD3 (HRESULT,SendOnDataChange,IDataObject*,pDataObject,DWORD,dwReserved,DWORD,advf)
/*** IUnknown methods ***/
#define IDataAdviseHolder_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IDataAdviseHolder_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IDataAdviseHolder_Release(p) (p)->lpVtbl->Release(p)
/*** IDataAdviseHolder methods ***/
#define IDataAdviseHolder_Advise(p,a,b,c,d,e) (p)->lpVtbl->Advise(p,a,b,c,d,e)
#define IDataAdviseHolder_Unadvise(p,a) (p)->lpVtbl->Unadvise(p,a)
#define IDataAdviseHolder_EnumAdvise(p,a) (p)->lpVtbl->EnumAdvise(p,a)
#define IDataAdviseHolder_SendOnDataChange(p,a,b,c) (p)->lpVtbl->SendOnDataChange(p,a,b,c)
#endif
HRESULT CALLBACK IDataAdviseHolder_Advise_Proxy(
IDataAdviseHolder* This,
IDataObject* pDataObject,
FORMATETC* pFetc,
DWORD advf,
IAdviseSink* pAdvise,
DWORD* pdwConnection);
void __RPC_STUB IDataAdviseHolder_Advise_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IDataAdviseHolder_Unadvise_Proxy(
IDataAdviseHolder* This,
DWORD dwConnection);
void __RPC_STUB IDataAdviseHolder_Unadvise_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IDataAdviseHolder_EnumAdvise_Proxy(
IDataAdviseHolder* This,
IEnumSTATDATA** ppenumAdvise);
void __RPC_STUB IDataAdviseHolder_EnumAdvise_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IDataAdviseHolder_SendOnDataChange_Proxy(
IDataAdviseHolder* This,
IDataObject* pDataObject,
DWORD dwReserved,
DWORD advf);
void __RPC_STUB IDataAdviseHolder_SendOnDataChange_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IMessageFilter IMessageFilter;
typedef IMessageFilter *LPMESSAGEFILTER;
typedef enum tagCALLTYPE {
CALLTYPE_TOPLEVEL = 1,
CALLTYPE_NESTED = 2,
CALLTYPE_ASYNC = 3,
CALLTYPE_TOPLEVEL_CALLPENDING = 4,
CALLTYPE_ASYNC_CALLPENDING = 5
} CALLTYPE;
typedef enum tagSERVERCALL {
SERVERCALL_ISHANDLED = 0,
SERVERCALL_REJECTED = 1,
SERVERCALL_RETRYLATER = 2
} SERVERCALL;
typedef enum tagPENDINGTYPE {
PENDINGTYPE_TOPLEVEL = 1,
PENDINGTYPE_NESTED = 2
} PENDINGTYPE;
typedef enum tagPENDINGMSG {
PENDINGMSG_CANCELCALL = 0,
PENDINGMSG_WAITNOPROCESS = 1,
PENDINGMSG_WAITDEFPROCESS = 2
} PENDINGMSG;
typedef struct tagINTERFACEINFO {
IUnknown *pUnk;
IID iid;
WORD wMethod;
} INTERFACEINFO, *LPINTERFACEINFO;
/*****************************************************************************
* IMessageFilter interface
*/
DEFINE_GUID(IID_IMessageFilter, 0x00000016, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IMessageFilter: IUnknown {
virtual DWORD CALLBACK HandleInComingCall(
DWORD dwCallType,
HTASK htaskCaller,
DWORD dwTickCount,
LPINTERFACEINFO lpInterfaceInfo) = 0;
virtual DWORD CALLBACK RetryRejectedCall(
HTASK htaskCallee,
DWORD dwTickCount,
DWORD dwRejectType) = 0;
virtual DWORD CALLBACK MessagePending(
HTASK htaskCallee,
DWORD dwTickCount,
DWORD dwPendingType) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IMessageFilterVtbl IMessageFilterVtbl;
struct IMessageFilter {
const IMessageFilterVtbl* lpVtbl;
};
struct IMessageFilterVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IMessageFilter* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IMessageFilter* This);
ULONG (CALLBACK *Release)(
IMessageFilter* This);
/*** IMessageFilter methods ***/
DWORD (CALLBACK *HandleInComingCall)(
IMessageFilter* This,
DWORD dwCallType,
HTASK htaskCaller,
DWORD dwTickCount,
LPINTERFACEINFO lpInterfaceInfo);
DWORD (CALLBACK *RetryRejectedCall)(
IMessageFilter* This,
HTASK htaskCallee,
DWORD dwTickCount,
DWORD dwRejectType);
DWORD (CALLBACK *MessagePending)(
IMessageFilter* This,
HTASK htaskCallee,
DWORD dwTickCount,
DWORD dwPendingType);
};
#define IMessageFilter_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD4 (DWORD,HandleInComingCall,DWORD,dwCallType,HTASK,htaskCaller,DWORD,dwTickCount,LPINTERFACEINFO,lpInterfaceInfo) \
ICOM_METHOD3 (DWORD,RetryRejectedCall,HTASK,htaskCallee,DWORD,dwTickCount,DWORD,dwRejectType) \
ICOM_METHOD3 (DWORD,MessagePending,HTASK,htaskCallee,DWORD,dwTickCount,DWORD,dwPendingType)
/*** IUnknown methods ***/
#define IMessageFilter_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMessageFilter_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMessageFilter_Release(p) (p)->lpVtbl->Release(p)
/*** IMessageFilter methods ***/
#define IMessageFilter_HandleInComingCall(p,a,b,c,d) (p)->lpVtbl->HandleInComingCall(p,a,b,c,d)
#define IMessageFilter_RetryRejectedCall(p,a,b,c) (p)->lpVtbl->RetryRejectedCall(p,a,b,c)
#define IMessageFilter_MessagePending(p,a,b,c) (p)->lpVtbl->MessagePending(p,a,b,c)
#endif
DWORD CALLBACK IMessageFilter_HandleInComingCall_Proxy(
IMessageFilter* This,
DWORD dwCallType,
HTASK htaskCaller,
DWORD dwTickCount,
LPINTERFACEINFO lpInterfaceInfo);
void __RPC_STUB IMessageFilter_HandleInComingCall_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
DWORD CALLBACK IMessageFilter_RetryRejectedCall_Proxy(
IMessageFilter* This,
HTASK htaskCallee,
DWORD dwTickCount,
DWORD dwRejectType);
void __RPC_STUB IMessageFilter_RetryRejectedCall_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
DWORD CALLBACK IMessageFilter_MessagePending_Proxy(
IMessageFilter* This,
HTASK htaskCallee,
DWORD dwTickCount,
DWORD dwPendingType);
void __RPC_STUB IMessageFilter_MessagePending_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IRpcChannelBuffer IRpcChannelBuffer;
typedef IRpcChannelBuffer *LPRPCCHANNELBUFFER;
typedef unsigned long RPCOLEDATAREP;
typedef struct tagRPCOLEMESSAGE {
void *reserved1;
RPCOLEDATAREP dataRepresentation;
void *Buffer;
ULONG cbBuffer;
ULONG iMethod;
void *reserved2[5];
ULONG rpcFlags;
} RPCOLEMESSAGE;
typedef RPCOLEMESSAGE *PRPCOLEMESSAGE;
/*****************************************************************************
* IRpcChannelBuffer interface
*/
DEFINE_GUID(IID_IRpcChannelBuffer, 0xd5f56b60, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IRpcChannelBuffer: IUnknown {
virtual HRESULT CALLBACK GetBuffer(
RPCOLEMESSAGE* pMessage,
REFIID riid) = 0;
virtual HRESULT CALLBACK SendReceive(
RPCOLEMESSAGE* pMessage,
ULONG* pStatus) = 0;
virtual HRESULT CALLBACK FreeBuffer(
RPCOLEMESSAGE* pMessage) = 0;
virtual HRESULT CALLBACK GetDestCtx(
DWORD* pdwDestContext,
void** ppvDestContext) = 0;
virtual HRESULT CALLBACK IsConnected(
) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IRpcChannelBufferVtbl IRpcChannelBufferVtbl;
struct IRpcChannelBuffer {
const IRpcChannelBufferVtbl* lpVtbl;
};
struct IRpcChannelBufferVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IRpcChannelBuffer* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IRpcChannelBuffer* This);
ULONG (CALLBACK *Release)(
IRpcChannelBuffer* This);
/*** IRpcChannelBuffer methods ***/
HRESULT (CALLBACK *GetBuffer)(
IRpcChannelBuffer* This,
RPCOLEMESSAGE* pMessage,
REFIID riid);
HRESULT (CALLBACK *SendReceive)(
IRpcChannelBuffer* This,
RPCOLEMESSAGE* pMessage,
ULONG* pStatus);
HRESULT (CALLBACK *FreeBuffer)(
IRpcChannelBuffer* This,
RPCOLEMESSAGE* pMessage);
HRESULT (CALLBACK *GetDestCtx)(
IRpcChannelBuffer* This,
DWORD* pdwDestContext,
void** ppvDestContext);
HRESULT (CALLBACK *IsConnected)(
IRpcChannelBuffer* This);
};
#define IRpcChannelBuffer_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD2 (HRESULT,GetBuffer,RPCOLEMESSAGE*,pMessage,REFIID,riid) \
ICOM_METHOD2 (HRESULT,SendReceive,RPCOLEMESSAGE*,pMessage,ULONG*,pStatus) \
ICOM_METHOD1 (HRESULT,FreeBuffer,RPCOLEMESSAGE*,pMessage) \
ICOM_METHOD2 (HRESULT,GetDestCtx,DWORD*,pdwDestContext,void**,ppvDestContext) \
ICOM_METHOD (HRESULT,IsConnected)
/*** IUnknown methods ***/
#define IRpcChannelBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IRpcChannelBuffer_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IRpcChannelBuffer_Release(p) (p)->lpVtbl->Release(p)
/*** IRpcChannelBuffer methods ***/
#define IRpcChannelBuffer_GetBuffer(p,a,b) (p)->lpVtbl->GetBuffer(p,a,b)
#define IRpcChannelBuffer_SendReceive(p,a,b) (p)->lpVtbl->SendReceive(p,a,b)
#define IRpcChannelBuffer_FreeBuffer(p,a) (p)->lpVtbl->FreeBuffer(p,a)
#define IRpcChannelBuffer_GetDestCtx(p,a,b) (p)->lpVtbl->GetDestCtx(p,a,b)
#define IRpcChannelBuffer_IsConnected(p) (p)->lpVtbl->IsConnected(p)
#endif
HRESULT CALLBACK IRpcChannelBuffer_GetBuffer_Proxy(
IRpcChannelBuffer* This,
RPCOLEMESSAGE* pMessage,
REFIID riid);
void __RPC_STUB IRpcChannelBuffer_GetBuffer_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcChannelBuffer_SendReceive_Proxy(
IRpcChannelBuffer* This,
RPCOLEMESSAGE* pMessage,
ULONG* pStatus);
void __RPC_STUB IRpcChannelBuffer_SendReceive_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcChannelBuffer_FreeBuffer_Proxy(
IRpcChannelBuffer* This,
RPCOLEMESSAGE* pMessage);
void __RPC_STUB IRpcChannelBuffer_FreeBuffer_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcChannelBuffer_GetDestCtx_Proxy(
IRpcChannelBuffer* This,
DWORD* pdwDestContext,
void** ppvDestContext);
void __RPC_STUB IRpcChannelBuffer_GetDestCtx_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcChannelBuffer_IsConnected_Proxy(
IRpcChannelBuffer* This);
void __RPC_STUB IRpcChannelBuffer_IsConnected_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IRpcChannelBuffer2 IRpcChannelBuffer2;
typedef IRpcChannelBuffer2 *LPRPCCHANNELBUFFER2;
/*****************************************************************************
* IRpcChannelBuffer2 interface
*/
DEFINE_GUID(IID_IRpcChannelBuffer2, 0x594f31d0, 0x7f19, 0x11d0, 0xb1,0x94, 0x00,0xa0,0xc9,0x0d,0xc8,0xbf);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IRpcChannelBuffer2: IRpcChannelBuffer {
virtual HRESULT CALLBACK GetProtocolVersion(
DWORD* pdwVersion) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IRpcChannelBuffer2Vtbl IRpcChannelBuffer2Vtbl;
struct IRpcChannelBuffer2 {
const IRpcChannelBuffer2Vtbl* lpVtbl;
};
struct IRpcChannelBuffer2Vtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IRpcChannelBuffer2* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IRpcChannelBuffer2* This);
ULONG (CALLBACK *Release)(
IRpcChannelBuffer2* This);
/*** IRpcChannelBuffer methods ***/
HRESULT (CALLBACK *GetBuffer)(
IRpcChannelBuffer2* This,
RPCOLEMESSAGE* pMessage,
REFIID riid);
HRESULT (CALLBACK *SendReceive)(
IRpcChannelBuffer2* This,
RPCOLEMESSAGE* pMessage,
ULONG* pStatus);
HRESULT (CALLBACK *FreeBuffer)(
IRpcChannelBuffer2* This,
RPCOLEMESSAGE* pMessage);
HRESULT (CALLBACK *GetDestCtx)(
IRpcChannelBuffer2* This,
DWORD* pdwDestContext,
void** ppvDestContext);
HRESULT (CALLBACK *IsConnected)(
IRpcChannelBuffer2* This);
/*** IRpcChannelBuffer2 methods ***/
HRESULT (CALLBACK *GetProtocolVersion)(
IRpcChannelBuffer2* This,
DWORD* pdwVersion);
};
#define IRpcChannelBuffer2_IMETHODS \
IRpcChannelBuffer_IMETHODS \
ICOM_METHOD1 (HRESULT,GetProtocolVersion,DWORD*,pdwVersion)
/*** IUnknown methods ***/
#define IRpcChannelBuffer2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IRpcChannelBuffer2_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IRpcChannelBuffer2_Release(p) (p)->lpVtbl->Release(p)
/*** IRpcChannelBuffer methods ***/
#define IRpcChannelBuffer2_GetBuffer(p,a,b) (p)->lpVtbl->GetBuffer(p,a,b)
#define IRpcChannelBuffer2_SendReceive(p,a,b) (p)->lpVtbl->SendReceive(p,a,b)
#define IRpcChannelBuffer2_FreeBuffer(p,a) (p)->lpVtbl->FreeBuffer(p,a)
#define IRpcChannelBuffer2_GetDestCtx(p,a,b) (p)->lpVtbl->GetDestCtx(p,a,b)
#define IRpcChannelBuffer2_IsConnected(p) (p)->lpVtbl->IsConnected(p)
/*** IRpcChannelBuffer2 methods ***/
#define IRpcChannelBuffer2_GetProtocolVersion(p,a) (p)->lpVtbl->GetProtocolVersion(p,a)
#endif
HRESULT CALLBACK IRpcChannelBuffer2_GetProtocolVersion_Proxy(
IRpcChannelBuffer2* This,
DWORD* pdwVersion);
void __RPC_STUB IRpcChannelBuffer2_GetProtocolVersion_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IRpcChannelBuffer3 IRpcChannelBuffer3;
typedef IRpcChannelBuffer3 *LPRPCCHANNELBUFFER3;
/*****************************************************************************
* IRpcChannelBuffer3 interface
*/
DEFINE_GUID(IID_IRpcChannelBuffer3, 0x25b15600, 0x0115, 0x11d0, 0xbf,0x0d, 0x00,0xaa,0x00,0xb8,0xdf,0xd2);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IRpcChannelBuffer3: IRpcChannelBuffer2 {
virtual HRESULT CALLBACK Send(
RPCOLEMESSAGE* pMsg,
ULONG* pulStatus) = 0;
virtual HRESULT CALLBACK Receive(
RPCOLEMESSAGE* pMsg,
ULONG ulSize,
ULONG* pulStatus) = 0;
virtual HRESULT CALLBACK Cancel(
RPCOLEMESSAGE* pMsg) = 0;
virtual HRESULT CALLBACK GetCallContext(
RPCOLEMESSAGE* pMsg,
REFIID riid,
void** pInterface) = 0;
virtual HRESULT CALLBACK GetDestCtxEx(
RPCOLEMESSAGE* pMsg,
DWORD* pdwDestContext,
void** ppvDestContext) = 0;
virtual HRESULT CALLBACK GetState(
RPCOLEMESSAGE* pMsg,
DWORD* pState) = 0;
virtual HRESULT CALLBACK RegisterAsync(
RPCOLEMESSAGE* pMsg,
IAsyncManager* pAsyncMgr) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IRpcChannelBuffer3Vtbl IRpcChannelBuffer3Vtbl;
struct IRpcChannelBuffer3 {
const IRpcChannelBuffer3Vtbl* lpVtbl;
};
struct IRpcChannelBuffer3Vtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IRpcChannelBuffer3* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IRpcChannelBuffer3* This);
ULONG (CALLBACK *Release)(
IRpcChannelBuffer3* This);
/*** IRpcChannelBuffer methods ***/
HRESULT (CALLBACK *GetBuffer)(
IRpcChannelBuffer3* This,
RPCOLEMESSAGE* pMessage,
REFIID riid);
HRESULT (CALLBACK *SendReceive)(
IRpcChannelBuffer3* This,
RPCOLEMESSAGE* pMessage,
ULONG* pStatus);
HRESULT (CALLBACK *FreeBuffer)(
IRpcChannelBuffer3* This,
RPCOLEMESSAGE* pMessage);
HRESULT (CALLBACK *GetDestCtx)(
IRpcChannelBuffer3* This,
DWORD* pdwDestContext,
void** ppvDestContext);
HRESULT (CALLBACK *IsConnected)(
IRpcChannelBuffer3* This);
/*** IRpcChannelBuffer2 methods ***/
HRESULT (CALLBACK *GetProtocolVersion)(
IRpcChannelBuffer3* This,
DWORD* pdwVersion);
/*** IRpcChannelBuffer3 methods ***/
HRESULT (CALLBACK *Send)(
IRpcChannelBuffer3* This,
RPCOLEMESSAGE* pMsg,
ULONG* pulStatus);
HRESULT (CALLBACK *Receive)(
IRpcChannelBuffer3* This,
RPCOLEMESSAGE* pMsg,
ULONG ulSize,
ULONG* pulStatus);
HRESULT (CALLBACK *Cancel)(
IRpcChannelBuffer3* This,
RPCOLEMESSAGE* pMsg);
HRESULT (CALLBACK *GetCallContext)(
IRpcChannelBuffer3* This,
RPCOLEMESSAGE* pMsg,
REFIID riid,
void** pInterface);
HRESULT (CALLBACK *GetDestCtxEx)(
IRpcChannelBuffer3* This,
RPCOLEMESSAGE* pMsg,
DWORD* pdwDestContext,
void** ppvDestContext);
HRESULT (CALLBACK *GetState)(
IRpcChannelBuffer3* This,
RPCOLEMESSAGE* pMsg,
DWORD* pState);
HRESULT (CALLBACK *RegisterAsync)(
IRpcChannelBuffer3* This,
RPCOLEMESSAGE* pMsg,
IAsyncManager* pAsyncMgr);
};
#define IRpcChannelBuffer3_IMETHODS \
IRpcChannelBuffer2_IMETHODS \
ICOM_METHOD2 (HRESULT,Send,RPCOLEMESSAGE*,pMsg,ULONG*,pulStatus) \
ICOM_METHOD3 (HRESULT,Receive,RPCOLEMESSAGE*,pMsg,ULONG,ulSize,ULONG*,pulStatus) \
ICOM_METHOD1 (HRESULT,Cancel,RPCOLEMESSAGE*,pMsg) \
ICOM_METHOD3 (HRESULT,GetCallContext,RPCOLEMESSAGE*,pMsg,REFIID,riid,void**,pInterface) \
ICOM_METHOD3 (HRESULT,GetDestCtxEx,RPCOLEMESSAGE*,pMsg,DWORD*,pdwDestContext,void**,ppvDestContext) \
ICOM_METHOD2 (HRESULT,GetState,RPCOLEMESSAGE*,pMsg,DWORD*,pState) \
ICOM_METHOD2 (HRESULT,RegisterAsync,RPCOLEMESSAGE*,pMsg,IAsyncManager*,pAsyncMgr)
/*** IUnknown methods ***/
#define IRpcChannelBuffer3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IRpcChannelBuffer3_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IRpcChannelBuffer3_Release(p) (p)->lpVtbl->Release(p)
/*** IRpcChannelBuffer methods ***/
#define IRpcChannelBuffer3_GetBuffer(p,a,b) (p)->lpVtbl->GetBuffer(p,a,b)
#define IRpcChannelBuffer3_SendReceive(p,a,b) (p)->lpVtbl->SendReceive(p,a,b)
#define IRpcChannelBuffer3_FreeBuffer(p,a) (p)->lpVtbl->FreeBuffer(p,a)
#define IRpcChannelBuffer3_GetDestCtx(p,a,b) (p)->lpVtbl->GetDestCtx(p,a,b)
#define IRpcChannelBuffer3_IsConnected(p) (p)->lpVtbl->IsConnected(p)
/*** IRpcChannelBuffer2 methods ***/
#define IRpcChannelBuffer3_GetProtocolVersion(p,a) (p)->lpVtbl->GetProtocolVersion(p,a)
/*** IRpcChannelBuffer3 methods ***/
#define IRpcChannelBuffer3_Send(p,a,b) (p)->lpVtbl->Send(p,a,b)
#define IRpcChannelBuffer3_Receive(p,a,b,c) (p)->lpVtbl->Receive(p,a,b,c)
#define IRpcChannelBuffer3_Cancel(p,a) (p)->lpVtbl->Cancel(p,a)
#define IRpcChannelBuffer3_GetCallContext(p,a,b,c) (p)->lpVtbl->GetCallContext(p,a,b,c)
#define IRpcChannelBuffer3_GetDestCtxEx(p,a,b,c) (p)->lpVtbl->GetDestCtxEx(p,a,b,c)
#define IRpcChannelBuffer3_GetState(p,a,b) (p)->lpVtbl->GetState(p,a,b)
#define IRpcChannelBuffer3_RegisterAsync(p,a,b) (p)->lpVtbl->RegisterAsync(p,a,b)
#endif
HRESULT CALLBACK IRpcChannelBuffer3_Send_Proxy(
IRpcChannelBuffer3* This,
RPCOLEMESSAGE* pMsg,
ULONG* pulStatus);
void __RPC_STUB IRpcChannelBuffer3_Send_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcChannelBuffer3_Receive_Proxy(
IRpcChannelBuffer3* This,
RPCOLEMESSAGE* pMsg,
ULONG ulSize,
ULONG* pulStatus);
void __RPC_STUB IRpcChannelBuffer3_Receive_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcChannelBuffer3_Cancel_Proxy(
IRpcChannelBuffer3* This,
RPCOLEMESSAGE* pMsg);
void __RPC_STUB IRpcChannelBuffer3_Cancel_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcChannelBuffer3_GetCallContext_Proxy(
IRpcChannelBuffer3* This,
RPCOLEMESSAGE* pMsg,
REFIID riid,
void** pInterface);
void __RPC_STUB IRpcChannelBuffer3_GetCallContext_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcChannelBuffer3_GetDestCtxEx_Proxy(
IRpcChannelBuffer3* This,
RPCOLEMESSAGE* pMsg,
DWORD* pdwDestContext,
void** ppvDestContext);
void __RPC_STUB IRpcChannelBuffer3_GetDestCtxEx_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcChannelBuffer3_GetState_Proxy(
IRpcChannelBuffer3* This,
RPCOLEMESSAGE* pMsg,
DWORD* pState);
void __RPC_STUB IRpcChannelBuffer3_GetState_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcChannelBuffer3_RegisterAsync_Proxy(
IRpcChannelBuffer3* This,
RPCOLEMESSAGE* pMsg,
IAsyncManager* pAsyncMgr);
void __RPC_STUB IRpcChannelBuffer3_RegisterAsync_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IRpcProxyBuffer IRpcProxyBuffer;
typedef IRpcProxyBuffer *LPRPCPROXYBUFFER;
/*****************************************************************************
* IRpcProxyBuffer interface
*/
DEFINE_GUID(IID_IRpcProxyBuffer, 0xd5f56a34, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IRpcProxyBuffer: IUnknown {
virtual HRESULT CALLBACK Connect(
IRpcChannelBuffer* pRpcChannelBuffer) = 0;
virtual void CALLBACK Disconnect(
) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IRpcProxyBufferVtbl IRpcProxyBufferVtbl;
struct IRpcProxyBuffer {
const IRpcProxyBufferVtbl* lpVtbl;
};
struct IRpcProxyBufferVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IRpcProxyBuffer* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IRpcProxyBuffer* This);
ULONG (CALLBACK *Release)(
IRpcProxyBuffer* This);
/*** IRpcProxyBuffer methods ***/
HRESULT (CALLBACK *Connect)(
IRpcProxyBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer);
void (CALLBACK *Disconnect)(
IRpcProxyBuffer* This);
};
#define IRpcProxyBuffer_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD1 (HRESULT,Connect,IRpcChannelBuffer*,pRpcChannelBuffer) \
ICOM_VMETHOD (Disconnect)
/*** IUnknown methods ***/
#define IRpcProxyBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IRpcProxyBuffer_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IRpcProxyBuffer_Release(p) (p)->lpVtbl->Release(p)
/*** IRpcProxyBuffer methods ***/
#define IRpcProxyBuffer_Connect(p,a) (p)->lpVtbl->Connect(p,a)
#define IRpcProxyBuffer_Disconnect(p) (p)->lpVtbl->Disconnect(p)
#endif
HRESULT CALLBACK IRpcProxyBuffer_Connect_Proxy(
IRpcProxyBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer);
void __RPC_STUB IRpcProxyBuffer_Connect_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IRpcProxyBuffer_Disconnect_Proxy(
IRpcProxyBuffer* This);
void __RPC_STUB IRpcProxyBuffer_Disconnect_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IRpcStubBuffer IRpcStubBuffer;
typedef IRpcStubBuffer *LPRPCSTUBBUFFER;
/*****************************************************************************
* IRpcStubBuffer interface
*/
DEFINE_GUID(IID_IRpcStubBuffer, 0xd5f56afc, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IRpcStubBuffer: IUnknown {
virtual HRESULT CALLBACK Connect(
IUnknown* pUnkServer) = 0;
virtual void CALLBACK Disconnect(
) = 0;
virtual HRESULT CALLBACK Invoke(
RPCOLEMESSAGE* _prpcmsg,
IRpcChannelBuffer* _pRpcChannelBuffer) = 0;
virtual IRpcStubBuffer* CALLBACK IsIIDSupported(
REFIID riid) = 0;
virtual ULONG CALLBACK CountRefs(
) = 0;
virtual HRESULT CALLBACK DebugServerQueryInterface(
void** ppv) = 0;
virtual void CALLBACK DebugServerRelease(
void* pv) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IRpcStubBufferVtbl IRpcStubBufferVtbl;
struct IRpcStubBuffer {
const IRpcStubBufferVtbl* lpVtbl;
};
struct IRpcStubBufferVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IRpcStubBuffer* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IRpcStubBuffer* This);
ULONG (CALLBACK *Release)(
IRpcStubBuffer* This);
/*** IRpcStubBuffer methods ***/
HRESULT (CALLBACK *Connect)(
IRpcStubBuffer* This,
IUnknown* pUnkServer);
void (CALLBACK *Disconnect)(
IRpcStubBuffer* This);
HRESULT (CALLBACK *Invoke)(
IRpcStubBuffer* This,
RPCOLEMESSAGE* _prpcmsg,
IRpcChannelBuffer* _pRpcChannelBuffer);
IRpcStubBuffer* (CALLBACK *IsIIDSupported)(
IRpcStubBuffer* This,
REFIID riid);
ULONG (CALLBACK *CountRefs)(
IRpcStubBuffer* This);
HRESULT (CALLBACK *DebugServerQueryInterface)(
IRpcStubBuffer* This,
void** ppv);
void (CALLBACK *DebugServerRelease)(
IRpcStubBuffer* This,
void* pv);
};
#define IRpcStubBuffer_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD1 (HRESULT,Connect,IUnknown*,pUnkServer) \
ICOM_VMETHOD (Disconnect) \
ICOM_METHOD2 (HRESULT,Invoke,RPCOLEMESSAGE*,_prpcmsg,IRpcChannelBuffer*,_pRpcChannelBuffer) \
ICOM_METHOD1 (IRpcStubBuffer*,IsIIDSupported,REFIID,riid) \
ICOM_METHOD (ULONG,CountRefs) \
ICOM_METHOD1 (HRESULT,DebugServerQueryInterface,void**,ppv) \
ICOM_VMETHOD1(DebugServerRelease,void*,pv)
/*** IUnknown methods ***/
#define IRpcStubBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IRpcStubBuffer_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IRpcStubBuffer_Release(p) (p)->lpVtbl->Release(p)
/*** IRpcStubBuffer methods ***/
#define IRpcStubBuffer_Connect(p,a) (p)->lpVtbl->Connect(p,a)
#define IRpcStubBuffer_Disconnect(p) (p)->lpVtbl->Disconnect(p)
#define IRpcStubBuffer_Invoke(p,a,b) (p)->lpVtbl->Invoke(p,a,b)
#define IRpcStubBuffer_IsIIDSupported(p,a) (p)->lpVtbl->IsIIDSupported(p,a)
#define IRpcStubBuffer_CountRefs(p) (p)->lpVtbl->CountRefs(p)
#define IRpcStubBuffer_DebugServerQueryInterface(p,a) (p)->lpVtbl->DebugServerQueryInterface(p,a)
#define IRpcStubBuffer_DebugServerRelease(p,a) (p)->lpVtbl->DebugServerRelease(p,a)
#endif
HRESULT CALLBACK IRpcStubBuffer_Connect_Proxy(
IRpcStubBuffer* This,
IUnknown* pUnkServer);
void __RPC_STUB IRpcStubBuffer_Connect_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IRpcStubBuffer_Disconnect_Proxy(
IRpcStubBuffer* This);
void __RPC_STUB IRpcStubBuffer_Disconnect_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcStubBuffer_Invoke_Proxy(
IRpcStubBuffer* This,
RPCOLEMESSAGE* _prpcmsg,
IRpcChannelBuffer* _pRpcChannelBuffer);
void __RPC_STUB IRpcStubBuffer_Invoke_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
IRpcStubBuffer* CALLBACK IRpcStubBuffer_IsIIDSupported_Proxy(
IRpcStubBuffer* This,
REFIID riid);
void __RPC_STUB IRpcStubBuffer_IsIIDSupported_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
ULONG CALLBACK IRpcStubBuffer_CountRefs_Proxy(
IRpcStubBuffer* This);
void __RPC_STUB IRpcStubBuffer_CountRefs_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IRpcStubBuffer_DebugServerQueryInterface_Proxy(
IRpcStubBuffer* This,
void** ppv);
void __RPC_STUB IRpcStubBuffer_DebugServerQueryInterface_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IRpcStubBuffer_DebugServerRelease_Proxy(
IRpcStubBuffer* This,
void* pv);
void __RPC_STUB IRpcStubBuffer_DebugServerRelease_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IPSFactoryBuffer IPSFactoryBuffer;
typedef IPSFactoryBuffer *LPPSFACTORYBUFFER;
/*****************************************************************************
* IPSFactoryBuffer interface
*/
DEFINE_GUID(IID_IPSFactoryBuffer, 0xd5f569d0, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IPSFactoryBuffer: IUnknown {
virtual HRESULT CALLBACK CreateProxy(
IUnknown* pUnkOuter,
REFIID riid,
IRpcProxyBuffer** ppProxy,
void** ppv) = 0;
virtual HRESULT CALLBACK CreateStub(
REFIID riid,
IUnknown* pUnkServer,
IRpcStubBuffer** ppStub) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IPSFactoryBufferVtbl IPSFactoryBufferVtbl;
struct IPSFactoryBuffer {
const IPSFactoryBufferVtbl* lpVtbl;
};
struct IPSFactoryBufferVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IPSFactoryBuffer* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IPSFactoryBuffer* This);
ULONG (CALLBACK *Release)(
IPSFactoryBuffer* This);
/*** IPSFactoryBuffer methods ***/
HRESULT (CALLBACK *CreateProxy)(
IPSFactoryBuffer* This,
IUnknown* pUnkOuter,
REFIID riid,
IRpcProxyBuffer** ppProxy,
void** ppv);
HRESULT (CALLBACK *CreateStub)(
IPSFactoryBuffer* This,
REFIID riid,
IUnknown* pUnkServer,
IRpcStubBuffer** ppStub);
};
#define IPSFactoryBuffer_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD4 (HRESULT,CreateProxy,IUnknown*,pUnkOuter,REFIID,riid,IRpcProxyBuffer**,ppProxy,void**,ppv) \
ICOM_METHOD3 (HRESULT,CreateStub,REFIID,riid,IUnknown*,pUnkServer,IRpcStubBuffer**,ppStub)
/*** IUnknown methods ***/
#define IPSFactoryBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IPSFactoryBuffer_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IPSFactoryBuffer_Release(p) (p)->lpVtbl->Release(p)
/*** IPSFactoryBuffer methods ***/
#define IPSFactoryBuffer_CreateProxy(p,a,b,c,d) (p)->lpVtbl->CreateProxy(p,a,b,c,d)
#define IPSFactoryBuffer_CreateStub(p,a,b,c) (p)->lpVtbl->CreateStub(p,a,b,c)
#endif
HRESULT CALLBACK IPSFactoryBuffer_CreateProxy_Proxy(
IPSFactoryBuffer* This,
IUnknown* pUnkOuter,
REFIID riid,
IRpcProxyBuffer** ppProxy,
void** ppv);
void __RPC_STUB IPSFactoryBuffer_CreateProxy_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPSFactoryBuffer_CreateStub_Proxy(
IPSFactoryBuffer* This,
REFIID riid,
IUnknown* pUnkServer,
IRpcStubBuffer** ppStub);
void __RPC_STUB IPSFactoryBuffer_CreateStub_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IChannelHook IChannelHook;
typedef IChannelHook *LPCHANNELHOOK;
typedef struct SChannelHookCallInfo {
IID iid;
DWORD cbSize;
GUID uCausality;
DWORD dwServerPid;
DWORD iMethod;
void *pObject;
} SChannelHookCallInfo;
/*****************************************************************************
* IChannelHook interface
*/
DEFINE_GUID(IID_IChannelHook, 0x1008c4a0, 0x7613, 0x11cf, 0x9a,0xf1, 0x00,0x20,0xaf,0x6e,0x72,0xf4);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IChannelHook: IUnknown {
virtual void CALLBACK ClientGetSize(
REFGUID uExtent,
REFIID riid,
ULONG* pDataSize) = 0;
virtual void CALLBACK ClientFillBuffer(
REFGUID uExtent,
REFIID riid,
ULONG* pDataSize,
void* pDataBuffer) = 0;
virtual void CALLBACK ClientNotify(
REFGUID uExtent,
REFIID riid,
ULONG cbDataSize,
void* pDataBuffer,
DWORD lDataRep,
HRESULT hrFault) = 0;
virtual void CALLBACK ServerNotify(
REFGUID uExtent,
REFIID riid,
ULONG cbDataSize,
void* pDataBuffer,
DWORD lDataRep) = 0;
virtual void CALLBACK ServerGetSize(
REFGUID uExtent,
REFIID riid,
HRESULT hrFault,
ULONG* pDataSize) = 0;
virtual void CALLBACK ServerFillBuffer(
REFGUID uExtent,
REFIID riid,
ULONG* pDataSize,
void* pDataBuffer,
HRESULT hrFault) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IChannelHookVtbl IChannelHookVtbl;
struct IChannelHook {
const IChannelHookVtbl* lpVtbl;
};
struct IChannelHookVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IChannelHook* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IChannelHook* This);
ULONG (CALLBACK *Release)(
IChannelHook* This);
/*** IChannelHook methods ***/
void (CALLBACK *ClientGetSize)(
IChannelHook* This,
REFGUID uExtent,
REFIID riid,
ULONG* pDataSize);
void (CALLBACK *ClientFillBuffer)(
IChannelHook* This,
REFGUID uExtent,
REFIID riid,
ULONG* pDataSize,
void* pDataBuffer);
void (CALLBACK *ClientNotify)(
IChannelHook* This,
REFGUID uExtent,
REFIID riid,
ULONG cbDataSize,
void* pDataBuffer,
DWORD lDataRep,
HRESULT hrFault);
void (CALLBACK *ServerNotify)(
IChannelHook* This,
REFGUID uExtent,
REFIID riid,
ULONG cbDataSize,
void* pDataBuffer,
DWORD lDataRep);
void (CALLBACK *ServerGetSize)(
IChannelHook* This,
REFGUID uExtent,
REFIID riid,
HRESULT hrFault,
ULONG* pDataSize);
void (CALLBACK *ServerFillBuffer)(
IChannelHook* This,
REFGUID uExtent,
REFIID riid,
ULONG* pDataSize,
void* pDataBuffer,
HRESULT hrFault);
};
#define IChannelHook_IMETHODS \
IUnknown_IMETHODS \
ICOM_VMETHOD3(ClientGetSize,REFGUID,uExtent,REFIID,riid,ULONG*,pDataSize) \
ICOM_VMETHOD4(ClientFillBuffer,REFGUID,uExtent,REFIID,riid,ULONG*,pDataSize,void*,pDataBuffer) \
ICOM_VMETHOD6(ClientNotify,REFGUID,uExtent,REFIID,riid,ULONG,cbDataSize,void*,pDataBuffer,DWORD,lDataRep,HRESULT,hrFault) \
ICOM_VMETHOD5(ServerNotify,REFGUID,uExtent,REFIID,riid,ULONG,cbDataSize,void*,pDataBuffer,DWORD,lDataRep) \
ICOM_VMETHOD4(ServerGetSize,REFGUID,uExtent,REFIID,riid,HRESULT,hrFault,ULONG*,pDataSize) \
ICOM_VMETHOD5(ServerFillBuffer,REFGUID,uExtent,REFIID,riid,ULONG*,pDataSize,void*,pDataBuffer,HRESULT,hrFault)
/*** IUnknown methods ***/
#define IChannelHook_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IChannelHook_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IChannelHook_Release(p) (p)->lpVtbl->Release(p)
/*** IChannelHook methods ***/
#define IChannelHook_ClientGetSize(p,a,b,c) (p)->lpVtbl->ClientGetSize(p,a,b,c)
#define IChannelHook_ClientFillBuffer(p,a,b,c,d) (p)->lpVtbl->ClientFillBuffer(p,a,b,c,d)
#define IChannelHook_ClientNotify(p,a,b,c,d,e,f) (p)->lpVtbl->ClientNotify(p,a,b,c,d,e,f)
#define IChannelHook_ServerNotify(p,a,b,c,d,e) (p)->lpVtbl->ServerNotify(p,a,b,c,d,e)
#define IChannelHook_ServerGetSize(p,a,b,c,d) (p)->lpVtbl->ServerGetSize(p,a,b,c,d)
#define IChannelHook_ServerFillBuffer(p,a,b,c,d,e) (p)->lpVtbl->ServerFillBuffer(p,a,b,c,d,e)
#endif
void CALLBACK IChannelHook_ClientGetSize_Proxy(
IChannelHook* This,
REFGUID uExtent,
REFIID riid,
ULONG* pDataSize);
void __RPC_STUB IChannelHook_ClientGetSize_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IChannelHook_ClientFillBuffer_Proxy(
IChannelHook* This,
REFGUID uExtent,
REFIID riid,
ULONG* pDataSize,
void* pDataBuffer);
void __RPC_STUB IChannelHook_ClientFillBuffer_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IChannelHook_ClientNotify_Proxy(
IChannelHook* This,
REFGUID uExtent,
REFIID riid,
ULONG cbDataSize,
void* pDataBuffer,
DWORD lDataRep,
HRESULT hrFault);
void __RPC_STUB IChannelHook_ClientNotify_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IChannelHook_ServerNotify_Proxy(
IChannelHook* This,
REFGUID uExtent,
REFIID riid,
ULONG cbDataSize,
void* pDataBuffer,
DWORD lDataRep);
void __RPC_STUB IChannelHook_ServerNotify_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IChannelHook_ServerGetSize_Proxy(
IChannelHook* This,
REFGUID uExtent,
REFIID riid,
HRESULT hrFault,
ULONG* pDataSize);
void __RPC_STUB IChannelHook_ServerGetSize_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
void CALLBACK IChannelHook_ServerFillBuffer_Proxy(
IChannelHook* This,
REFGUID uExtent,
REFIID riid,
ULONG* pDataSize,
void* pDataBuffer,
HRESULT hrFault);
void __RPC_STUB IChannelHook_ServerFillBuffer_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IEnumSTATPROPSTG IEnumSTATPROPSTG;
typedef struct IEnumSTATPROPSETSTG IEnumSTATPROPSETSTG;
typedef struct IPropertyStorage IPropertyStorage;
typedef IPropertyStorage *LPPROPERTYSTORAGE;
extern const FMTID FMTID_SummaryInformation;
extern const FMTID FMTID_DocSummaryInformation;
extern const FMTID FMTID_UserDefinedProperties;
#define PROPSETFLAG_DEFAULT (0)
#define PROPSETFLAG_NONSIMPLE (1)
#define PROPSETFLAG_ANSI (2)
#define PROPSETFLAG_UNBUFFERED (4)
typedef struct tagPROPVARIANT PROPVARIANT;
typedef struct tagCAUB {
ULONG cElems;
unsigned char *pElems;
} CAUB;
typedef struct tagCAI {
ULONG cElems;
short *pElems;
} CAI;
typedef struct tagCAUI {
ULONG cElems;
USHORT *pElems;
} CAUI;
typedef struct tagCAL {
ULONG cElems;
long *pElems;
} CAL;
typedef struct tagCAUL {
ULONG cElems;
ULONG *pElems;
} CAUL;
typedef struct tagCAFLT {
ULONG cElems;
float *pElems;
} CAFLT;
typedef struct tagCADBL {
ULONG cElems;
double *pElems;
} CADBL;
typedef struct tagCACY {
ULONG cElems;
CY *pElems;
} CACY;
typedef struct tagCADATE {
ULONG cElems;
DATE *pElems;
} CADATE;
typedef struct tagCABSTR {
ULONG cElems;
BSTR *pElems;
} CABSTR;
typedef struct tagCABSTRBLOB {
ULONG cElems;
BSTRBLOB *pElems;
} CABSTRBLOB;
typedef struct tagCABOOL {
ULONG cElems;
VARIANT_BOOL *pElems;
} CABOOL;
typedef struct tagCASCODE {
ULONG cElems;
SCODE *pElems;
} CASCODE;
typedef struct tagCAPROPVARIANT {
ULONG cElems;
PROPVARIANT *pElems;
} CAPROPVARIANT;
typedef struct tagCAH {
ULONG cElems;
LARGE_INTEGER *pElems;
} CAH;
typedef struct tagCAUH {
ULONG cElems;
ULARGE_INTEGER *pElems;
} CAUH;
typedef struct tagCALPSTR {
ULONG cElems;
LPSTR *pElems;
} CALPSTR;
typedef struct tagCALPWSTR {
ULONG cElems;
LPWSTR *pElems;
} CALPWSTR;
typedef struct tagCAFILETIME {
ULONG cElems;
FILETIME *pElems;
} CAFILETIME;
typedef struct tagCACLIPDATA {
ULONG cElems;
CLIPDATA *pElems;
} CACLIPDATA;
typedef struct tagCACLSID {
ULONG cElems;
CLSID *pElems;
} CACLSID;
struct tagPROPVARIANT {
VARTYPE vt;
WORD wReserved1;
WORD wReserved2;
WORD wReserved3;
union {
UCHAR bVal;
short iVal;
USHORT uiVal;
VARIANT_BOOL boolVal;
long lVal;
ULONG ulVal;
float fltVal;
SCODE scode;
LARGE_INTEGER hVal;
ULARGE_INTEGER uhVal;
double dblVal;
CY cyVal;
DATE date;
FILETIME filetime;
CLSID *puuid;
BLOB blob;
CLIPDATA *pclipdata;
IStream *pStream;
IStorage *pStorage;
BSTR bstrVal;
BSTRBLOB bstrblobVal;
LPSTR pszVal;
LPWSTR pwszVal;
CAUB caub;
CAI cai;
CAUI caui;
CABOOL cabool;
CAL cal;
CAUL caul;
CAFLT caflt;
CASCODE cascode;
CAH cah;
CAUH cauh;
CADBL cadbl;
CACY cacy;
CADATE cadate;
CAFILETIME cafiletime;
CACLSID cauuid;
CACLIPDATA caclipdata;
CABSTR cabstr;
CABSTRBLOB cabstrblob;
CALPSTR calpstr;
CALPWSTR calpwstr;
CAPROPVARIANT capropvar;
} DUMMYUNIONNAME;
};
typedef struct tagPROPVARIANT *LPPROPVARIANT;
#define PRSPEC_INVALID (0x7fffffff)
#define PRSPEC_LPWSTR (0)
#define PRSPEC_PROPID (1)
typedef struct tagPROPSPEC {
ULONG ulKind;
union {
PROPID propid;
LPOLESTR lpwstr;
} DUMMYUNIONNAME;
} PROPSPEC;
typedef struct tagSTATPROPSTG {
LPOLESTR lpwstrName;
PROPID propid;
VARTYPE vt;
} STATPROPSTG;
typedef struct tagSTATPROPSETSTG {
FMTID fmtid;
CLSID clsid;
DWORD grfFlags;
FILETIME mtime;
FILETIME ctime;
FILETIME atime;
DWORD dwOSVersion;
} STATPROPSETSTG;
/*****************************************************************************
* IPropertyStorage interface
*/
DEFINE_GUID(IID_IPropertyStorage, 0x00000138, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IPropertyStorage: IUnknown {
virtual HRESULT CALLBACK ReadMultiple(
ULONG cpspec,
const PROPSPEC rgpspec[],
PROPVARIANT rgpropvar[]) = 0;
virtual HRESULT CALLBACK WriteMultiple(
ULONG cpspec,
const PROPSPEC rgpspec[],
const PROPVARIANT rgpropvar[],
PROPID propidNameFirst) = 0;
virtual HRESULT CALLBACK DeleteMultiple(
ULONG cpspec,
const PROPSPEC rgpspec[]) = 0;
virtual HRESULT CALLBACK ReadPropertyNames(
ULONG cpropid,
const PROPID rgpropid[],
LPOLESTR rglpwstrName[]) = 0;
virtual HRESULT CALLBACK WritePropertyNames(
ULONG cpropid,
const PROPID rgpropid[],
const LPOLESTR rglpwstrName[]) = 0;
virtual HRESULT CALLBACK DeletePropertyNames(
ULONG cpropid,
const PROPID rgpropid[]) = 0;
virtual HRESULT CALLBACK Commit(
DWORD grfCommitFlags) = 0;
virtual HRESULT CALLBACK Revert(
) = 0;
virtual HRESULT CALLBACK Enum(
IEnumSTATPROPSTG** ppenum) = 0;
virtual HRESULT CALLBACK SetTimes(
const FILETIME* pctime,
const FILETIME* patime,
const FILETIME* pmtime) = 0;
virtual HRESULT CALLBACK SetClass(
REFCLSID clsid) = 0;
virtual HRESULT CALLBACK Stat(
STATPROPSETSTG* statpsstg) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IPropertyStorageVtbl IPropertyStorageVtbl;
struct IPropertyStorage {
const IPropertyStorageVtbl* lpVtbl;
};
struct IPropertyStorageVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IPropertyStorage* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IPropertyStorage* This);
ULONG (CALLBACK *Release)(
IPropertyStorage* This);
/*** IPropertyStorage methods ***/
HRESULT (CALLBACK *ReadMultiple)(
IPropertyStorage* This,
ULONG cpspec,
const PROPSPEC rgpspec[],
PROPVARIANT rgpropvar[]);
HRESULT (CALLBACK *WriteMultiple)(
IPropertyStorage* This,
ULONG cpspec,
const PROPSPEC rgpspec[],
const PROPVARIANT rgpropvar[],
PROPID propidNameFirst);
HRESULT (CALLBACK *DeleteMultiple)(
IPropertyStorage* This,
ULONG cpspec,
const PROPSPEC rgpspec[]);
HRESULT (CALLBACK *ReadPropertyNames)(
IPropertyStorage* This,
ULONG cpropid,
const PROPID rgpropid[],
LPOLESTR rglpwstrName[]);
HRESULT (CALLBACK *WritePropertyNames)(
IPropertyStorage* This,
ULONG cpropid,
const PROPID rgpropid[],
const LPOLESTR rglpwstrName[]);
HRESULT (CALLBACK *DeletePropertyNames)(
IPropertyStorage* This,
ULONG cpropid,
const PROPID rgpropid[]);
HRESULT (CALLBACK *Commit)(
IPropertyStorage* This,
DWORD grfCommitFlags);
HRESULT (CALLBACK *Revert)(
IPropertyStorage* This);
HRESULT (CALLBACK *Enum)(
IPropertyStorage* This,
IEnumSTATPROPSTG** ppenum);
HRESULT (CALLBACK *SetTimes)(
IPropertyStorage* This,
const FILETIME* pctime,
const FILETIME* patime,
const FILETIME* pmtime);
HRESULT (CALLBACK *SetClass)(
IPropertyStorage* This,
REFCLSID clsid);
HRESULT (CALLBACK *Stat)(
IPropertyStorage* This,
STATPROPSETSTG* statpsstg);
};
#define IPropertyStorage_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD3 (HRESULT,ReadMultiple,ULONG,cpspec,const PROPSPEC*,rgpspec,PROPVARIANT*,rgpropvar) \
ICOM_METHOD4 (HRESULT,WriteMultiple,ULONG,cpspec,const PROPSPEC*,rgpspec,const PROPVARIANT*,rgpropvar,PROPID,propidNameFirst) \
ICOM_METHOD2 (HRESULT,DeleteMultiple,ULONG,cpspec,const PROPSPEC*,rgpspec) \
ICOM_METHOD3 (HRESULT,ReadPropertyNames,ULONG,cpropid,const PROPID*,rgpropid,LPOLESTR*,rglpwstrName) \
ICOM_METHOD3 (HRESULT,WritePropertyNames,ULONG,cpropid,const PROPID*,rgpropid,const LPOLESTR*,rglpwstrName) \
ICOM_METHOD2 (HRESULT,DeletePropertyNames,ULONG,cpropid,const PROPID*,rgpropid) \
ICOM_METHOD1 (HRESULT,Commit,DWORD,grfCommitFlags) \
ICOM_METHOD (HRESULT,Revert) \
ICOM_METHOD1 (HRESULT,Enum,IEnumSTATPROPSTG**,ppenum) \
ICOM_METHOD3 (HRESULT,SetTimes,const FILETIME*,pctime,const FILETIME*,patime,const FILETIME*,pmtime) \
ICOM_METHOD1 (HRESULT,SetClass,REFCLSID,clsid) \
ICOM_METHOD1 (HRESULT,Stat,STATPROPSETSTG*,statpsstg)
/*** IUnknown methods ***/
#define IPropertyStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IPropertyStorage_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IPropertyStorage_Release(p) (p)->lpVtbl->Release(p)
/*** IPropertyStorage methods ***/
#define IPropertyStorage_ReadMultiple(p,a,b,c) (p)->lpVtbl->ReadMultiple(p,a,b,c)
#define IPropertyStorage_WriteMultiple(p,a,b,c,d) (p)->lpVtbl->WriteMultiple(p,a,b,c,d)
#define IPropertyStorage_DeleteMultiple(p,a,b) (p)->lpVtbl->DeleteMultiple(p,a,b)
#define IPropertyStorage_ReadPropertyNames(p,a,b,c) (p)->lpVtbl->ReadPropertyNames(p,a,b,c)
#define IPropertyStorage_WritePropertyNames(p,a,b,c) (p)->lpVtbl->WritePropertyNames(p,a,b,c)
#define IPropertyStorage_DeletePropertyNames(p,a,b) (p)->lpVtbl->DeletePropertyNames(p,a,b)
#define IPropertyStorage_Commit(p,a) (p)->lpVtbl->Commit(p,a)
#define IPropertyStorage_Revert(p) (p)->lpVtbl->Revert(p)
#define IPropertyStorage_Enum(p,a) (p)->lpVtbl->Enum(p,a)
#define IPropertyStorage_SetTimes(p,a,b,c) (p)->lpVtbl->SetTimes(p,a,b,c)
#define IPropertyStorage_SetClass(p,a) (p)->lpVtbl->SetClass(p,a)
#define IPropertyStorage_Stat(p,a) (p)->lpVtbl->Stat(p,a)
#endif
HRESULT CALLBACK IPropertyStorage_ReadMultiple_Proxy(
IPropertyStorage* This,
ULONG cpspec,
const PROPSPEC rgpspec[],
PROPVARIANT rgpropvar[]);
void __RPC_STUB IPropertyStorage_ReadMultiple_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPropertyStorage_WriteMultiple_Proxy(
IPropertyStorage* This,
ULONG cpspec,
const PROPSPEC rgpspec[],
const PROPVARIANT rgpropvar[],
PROPID propidNameFirst);
void __RPC_STUB IPropertyStorage_WriteMultiple_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPropertyStorage_DeleteMultiple_Proxy(
IPropertyStorage* This,
ULONG cpspec,
const PROPSPEC rgpspec[]);
void __RPC_STUB IPropertyStorage_DeleteMultiple_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPropertyStorage_ReadPropertyNames_Proxy(
IPropertyStorage* This,
ULONG cpropid,
const PROPID rgpropid[],
LPOLESTR rglpwstrName[]);
void __RPC_STUB IPropertyStorage_ReadPropertyNames_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPropertyStorage_WritePropertyNames_Proxy(
IPropertyStorage* This,
ULONG cpropid,
const PROPID rgpropid[],
const LPOLESTR rglpwstrName[]);
void __RPC_STUB IPropertyStorage_WritePropertyNames_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPropertyStorage_DeletePropertyNames_Proxy(
IPropertyStorage* This,
ULONG cpropid,
const PROPID rgpropid[]);
void __RPC_STUB IPropertyStorage_DeletePropertyNames_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPropertyStorage_Commit_Proxy(
IPropertyStorage* This,
DWORD grfCommitFlags);
void __RPC_STUB IPropertyStorage_Commit_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPropertyStorage_Revert_Proxy(
IPropertyStorage* This);
void __RPC_STUB IPropertyStorage_Revert_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPropertyStorage_Enum_Proxy(
IPropertyStorage* This,
IEnumSTATPROPSTG** ppenum);
void __RPC_STUB IPropertyStorage_Enum_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPropertyStorage_SetTimes_Proxy(
IPropertyStorage* This,
const FILETIME* pctime,
const FILETIME* patime,
const FILETIME* pmtime);
void __RPC_STUB IPropertyStorage_SetTimes_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPropertyStorage_SetClass_Proxy(
IPropertyStorage* This,
REFCLSID clsid);
void __RPC_STUB IPropertyStorage_SetClass_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPropertyStorage_Stat_Proxy(
IPropertyStorage* This,
STATPROPSETSTG* statpsstg);
void __RPC_STUB IPropertyStorage_Stat_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IPropertySetStorage IPropertySetStorage;
typedef IPropertySetStorage *LPPROPERTYSETSTORAGE;
/*****************************************************************************
* IPropertySetStorage interface
*/
DEFINE_GUID(IID_IPropertySetStorage, 0x0000013a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IPropertySetStorage: IUnknown {
virtual HRESULT CALLBACK Create(
REFFMTID rfmtid,
const CLSID* pclsid,
DWORD grfFlags,
DWORD grfMode,
IPropertyStorage** ppprstg) = 0;
virtual HRESULT CALLBACK Open(
REFFMTID rfmtid,
DWORD grfMode,
IPropertyStorage** ppprstg) = 0;
virtual HRESULT CALLBACK Delete(
REFFMTID rfmtid) = 0;
virtual HRESULT CALLBACK Enum(
IEnumSTATPROPSETSTG** ppenum) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IPropertySetStorageVtbl IPropertySetStorageVtbl;
struct IPropertySetStorage {
const IPropertySetStorageVtbl* lpVtbl;
};
struct IPropertySetStorageVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IPropertySetStorage* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IPropertySetStorage* This);
ULONG (CALLBACK *Release)(
IPropertySetStorage* This);
/*** IPropertySetStorage methods ***/
HRESULT (CALLBACK *Create)(
IPropertySetStorage* This,
REFFMTID rfmtid,
const CLSID* pclsid,
DWORD grfFlags,
DWORD grfMode,
IPropertyStorage** ppprstg);
HRESULT (CALLBACK *Open)(
IPropertySetStorage* This,
REFFMTID rfmtid,
DWORD grfMode,
IPropertyStorage** ppprstg);
HRESULT (CALLBACK *Delete)(
IPropertySetStorage* This,
REFFMTID rfmtid);
HRESULT (CALLBACK *Enum)(
IPropertySetStorage* This,
IEnumSTATPROPSETSTG** ppenum);
};
#define IPropertySetStorage_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD5 (HRESULT,Create,REFFMTID,rfmtid,const CLSID*,pclsid,DWORD,grfFlags,DWORD,grfMode,IPropertyStorage**,ppprstg) \
ICOM_METHOD3 (HRESULT,Open,REFFMTID,rfmtid,DWORD,grfMode,IPropertyStorage**,ppprstg) \
ICOM_METHOD1 (HRESULT,Delete,REFFMTID,rfmtid) \
ICOM_METHOD1 (HRESULT,Enum,IEnumSTATPROPSETSTG**,ppenum)
/*** IUnknown methods ***/
#define IPropertySetStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IPropertySetStorage_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IPropertySetStorage_Release(p) (p)->lpVtbl->Release(p)
/*** IPropertySetStorage methods ***/
#define IPropertySetStorage_Create(p,a,b,c,d,e) (p)->lpVtbl->Create(p,a,b,c,d,e)
#define IPropertySetStorage_Open(p,a,b,c) (p)->lpVtbl->Open(p,a,b,c)
#define IPropertySetStorage_Delete(p,a) (p)->lpVtbl->Delete(p,a)
#define IPropertySetStorage_Enum(p,a) (p)->lpVtbl->Enum(p,a)
#endif
HRESULT CALLBACK IPropertySetStorage_Create_Proxy(
IPropertySetStorage* This,
REFFMTID rfmtid,
const CLSID* pclsid,
DWORD grfFlags,
DWORD grfMode,
IPropertyStorage** ppprstg);
void __RPC_STUB IPropertySetStorage_Create_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPropertySetStorage_Open_Proxy(
IPropertySetStorage* This,
REFFMTID rfmtid,
DWORD grfMode,
IPropertyStorage** ppprstg);
void __RPC_STUB IPropertySetStorage_Open_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPropertySetStorage_Delete_Proxy(
IPropertySetStorage* This,
REFFMTID rfmtid);
void __RPC_STUB IPropertySetStorage_Delete_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IPropertySetStorage_Enum_Proxy(
IPropertySetStorage* This,
IEnumSTATPROPSETSTG** ppenum);
void __RPC_STUB IPropertySetStorage_Enum_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef IEnumSTATPROPSTG *LPENUMSTATPROPSTG;
/*****************************************************************************
* IEnumSTATPROPSTG interface
*/
DEFINE_GUID(IID_IEnumSTATPROPSTG, 0x00000139, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IEnumSTATPROPSTG: IUnknown {
virtual HRESULT CALLBACK Next(
ULONG celt,
STATPROPSTG* rgelt,
ULONG* pceltFetched) = 0;
virtual HRESULT CALLBACK Skip(
ULONG celt) = 0;
virtual HRESULT CALLBACK Reset(
) = 0;
virtual HRESULT CALLBACK Clone(
IEnumSTATPROPSTG** ppenum) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IEnumSTATPROPSTGVtbl IEnumSTATPROPSTGVtbl;
struct IEnumSTATPROPSTG {
const IEnumSTATPROPSTGVtbl* lpVtbl;
};
struct IEnumSTATPROPSTGVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IEnumSTATPROPSTG* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IEnumSTATPROPSTG* This);
ULONG (CALLBACK *Release)(
IEnumSTATPROPSTG* This);
/*** IEnumSTATPROPSTG methods ***/
HRESULT (CALLBACK *Next)(
IEnumSTATPROPSTG* This,
ULONG celt,
STATPROPSTG* rgelt,
ULONG* pceltFetched);
HRESULT (CALLBACK *Skip)(
IEnumSTATPROPSTG* This,
ULONG celt);
HRESULT (CALLBACK *Reset)(
IEnumSTATPROPSTG* This);
HRESULT (CALLBACK *Clone)(
IEnumSTATPROPSTG* This,
IEnumSTATPROPSTG** ppenum);
};
#define IEnumSTATPROPSTG_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD3 (HRESULT,Next,ULONG,celt,STATPROPSTG*,rgelt,ULONG*,pceltFetched) \
ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \
ICOM_METHOD (HRESULT,Reset) \
ICOM_METHOD1 (HRESULT,Clone,IEnumSTATPROPSTG**,ppenum)
/*** IUnknown methods ***/
#define IEnumSTATPROPSTG_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IEnumSTATPROPSTG_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IEnumSTATPROPSTG_Release(p) (p)->lpVtbl->Release(p)
/*** IEnumSTATPROPSTG methods ***/
#define IEnumSTATPROPSTG_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
#define IEnumSTATPROPSTG_Skip(p,a) (p)->lpVtbl->Skip(p,a)
#define IEnumSTATPROPSTG_Reset(p) (p)->lpVtbl->Reset(p)
#define IEnumSTATPROPSTG_Clone(p,a) (p)->lpVtbl->Clone(p,a)
#endif
HRESULT CALLBACK IEnumSTATPROPSTG_RemoteNext_Proxy(
IEnumSTATPROPSTG* This,
ULONG celt,
STATPROPSTG* rgelt,
ULONG* pceltFetched);
void __RPC_STUB IEnumSTATPROPSTG_RemoteNext_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumSTATPROPSTG_Next_Proxy(
IEnumSTATPROPSTG* This,
ULONG celt,
STATPROPSTG* rgelt,
ULONG* pceltFetched);
HRESULT __RPC_STUB IEnumSTATPROPSTG_Next_Stub(
IEnumSTATPROPSTG* This,
ULONG celt,
STATPROPSTG* rgelt,
ULONG* pceltFetched);
HRESULT CALLBACK IEnumSTATPROPSTG_Skip_Proxy(
IEnumSTATPROPSTG* This,
ULONG celt);
void __RPC_STUB IEnumSTATPROPSTG_Skip_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumSTATPROPSTG_Reset_Proxy(
IEnumSTATPROPSTG* This);
void __RPC_STUB IEnumSTATPROPSTG_Reset_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumSTATPROPSTG_Clone_Proxy(
IEnumSTATPROPSTG* This,
IEnumSTATPROPSTG** ppenum);
void __RPC_STUB IEnumSTATPROPSTG_Clone_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef IEnumSTATPROPSETSTG *LPENUMSTATPROPSETSTG;
/*****************************************************************************
* IEnumSTATPROPSETSTG interface
*/
DEFINE_GUID(IID_IEnumSTATPROPSETSTG, 0x0000013b, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IEnumSTATPROPSETSTG: IUnknown {
virtual HRESULT CALLBACK Next(
ULONG celt,
STATPROPSETSTG* rgelt,
ULONG* pceltFetched) = 0;
virtual HRESULT CALLBACK Skip(
ULONG celt) = 0;
virtual HRESULT CALLBACK Reset(
) = 0;
virtual HRESULT CALLBACK Clone(
IEnumSTATPROPSETSTG** ppenum) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IEnumSTATPROPSETSTGVtbl IEnumSTATPROPSETSTGVtbl;
struct IEnumSTATPROPSETSTG {
const IEnumSTATPROPSETSTGVtbl* lpVtbl;
};
struct IEnumSTATPROPSETSTGVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IEnumSTATPROPSETSTG* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IEnumSTATPROPSETSTG* This);
ULONG (CALLBACK *Release)(
IEnumSTATPROPSETSTG* This);
/*** IEnumSTATPROPSETSTG methods ***/
HRESULT (CALLBACK *Next)(
IEnumSTATPROPSETSTG* This,
ULONG celt,
STATPROPSETSTG* rgelt,
ULONG* pceltFetched);
HRESULT (CALLBACK *Skip)(
IEnumSTATPROPSETSTG* This,
ULONG celt);
HRESULT (CALLBACK *Reset)(
IEnumSTATPROPSETSTG* This);
HRESULT (CALLBACK *Clone)(
IEnumSTATPROPSETSTG* This,
IEnumSTATPROPSETSTG** ppenum);
};
#define IEnumSTATPROPSETSTG_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD3 (HRESULT,Next,ULONG,celt,STATPROPSETSTG*,rgelt,ULONG*,pceltFetched) \
ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \
ICOM_METHOD (HRESULT,Reset) \
ICOM_METHOD1 (HRESULT,Clone,IEnumSTATPROPSETSTG**,ppenum)
/*** IUnknown methods ***/
#define IEnumSTATPROPSETSTG_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IEnumSTATPROPSETSTG_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IEnumSTATPROPSETSTG_Release(p) (p)->lpVtbl->Release(p)
/*** IEnumSTATPROPSETSTG methods ***/
#define IEnumSTATPROPSETSTG_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
#define IEnumSTATPROPSETSTG_Skip(p,a) (p)->lpVtbl->Skip(p,a)
#define IEnumSTATPROPSETSTG_Reset(p) (p)->lpVtbl->Reset(p)
#define IEnumSTATPROPSETSTG_Clone(p,a) (p)->lpVtbl->Clone(p,a)
#endif
HRESULT CALLBACK IEnumSTATPROPSETSTG_RemoteNext_Proxy(
IEnumSTATPROPSETSTG* This,
ULONG celt,
STATPROPSETSTG* rgelt,
ULONG* pceltFetched);
void __RPC_STUB IEnumSTATPROPSETSTG_RemoteNext_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumSTATPROPSETSTG_Next_Proxy(
IEnumSTATPROPSETSTG* This,
ULONG celt,
STATPROPSETSTG* rgelt,
ULONG* pceltFetched);
HRESULT __RPC_STUB IEnumSTATPROPSETSTG_Next_Stub(
IEnumSTATPROPSETSTG* This,
ULONG celt,
STATPROPSETSTG* rgelt,
ULONG* pceltFetched);
HRESULT CALLBACK IEnumSTATPROPSETSTG_Skip_Proxy(
IEnumSTATPROPSETSTG* This,
ULONG celt);
void __RPC_STUB IEnumSTATPROPSETSTG_Skip_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumSTATPROPSETSTG_Reset_Proxy(
IEnumSTATPROPSETSTG* This);
void __RPC_STUB IEnumSTATPROPSETSTG_Reset_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumSTATPROPSETSTG_Clone_Proxy(
IEnumSTATPROPSETSTG* This,
IEnumSTATPROPSETSTG** ppenum);
void __RPC_STUB IEnumSTATPROPSETSTG_Clone_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IClientSecurity IClientSecurity;
typedef struct tagSOLE_AUTHENTICATION_SERVICE {
DWORD dwAuthnSvc;
DWORD dwAuthzSvc;
OLECHAR *pPrincipalName;
HRESULT hr;
} SOLE_AUTHENTICATION_SERVICE;
typedef SOLE_AUTHENTICATION_SERVICE *PSOLE_AUTHENTICATION_SERVICE;
typedef enum tagEOLE_AUTHENTICATION_CAPABILITIES {
EOAC_NONE = 0x0,
EOAC_MUTUAL_AUTH = 0x1,
EOAC_CLOAKING = 0x10,
EOAC_SECURE_REFS = 0x2,
EOAC_ACCESS_CONTROL = 0x4,
EOAC_APPID = 0x8
} EOLE_AUTHENTICATION_CAPABILITIES;
/*****************************************************************************
* IClientSecurity interface
*/
DEFINE_GUID(IID_IClientSecurity, 0x0000013d, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IClientSecurity: IUnknown {
virtual HRESULT CALLBACK QueryBlanket(
IUnknown* pProxy,
DWORD* pAuthnSvc,
DWORD* pAuthzSvc,
OLECHAR** pServerPrincName,
DWORD* pAuthnLevel,
DWORD* pImpLevel,
void** pAuthInfo,
DWORD* pCapabilites) = 0;
virtual HRESULT CALLBACK SetBlanket(
IUnknown* pProxy,
DWORD AuthnSvc,
DWORD AuthzSvc,
OLECHAR* pServerPrincName,
DWORD AuthnLevel,
DWORD ImpLevel,
void* pAuthInfo,
DWORD Capabilities) = 0;
virtual HRESULT CALLBACK CopyProxy(
IUnknown* pProxy,
IUnknown** ppCopy) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IClientSecurityVtbl IClientSecurityVtbl;
struct IClientSecurity {
const IClientSecurityVtbl* lpVtbl;
};
struct IClientSecurityVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IClientSecurity* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IClientSecurity* This);
ULONG (CALLBACK *Release)(
IClientSecurity* This);
/*** IClientSecurity methods ***/
HRESULT (CALLBACK *QueryBlanket)(
IClientSecurity* This,
IUnknown* pProxy,
DWORD* pAuthnSvc,
DWORD* pAuthzSvc,
OLECHAR** pServerPrincName,
DWORD* pAuthnLevel,
DWORD* pImpLevel,
void** pAuthInfo,
DWORD* pCapabilites);
HRESULT (CALLBACK *SetBlanket)(
IClientSecurity* This,
IUnknown* pProxy,
DWORD AuthnSvc,
DWORD AuthzSvc,
OLECHAR* pServerPrincName,
DWORD AuthnLevel,
DWORD ImpLevel,
void* pAuthInfo,
DWORD Capabilities);
HRESULT (CALLBACK *CopyProxy)(
IClientSecurity* This,
IUnknown* pProxy,
IUnknown** ppCopy);
};
#define IClientSecurity_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD8 (HRESULT,QueryBlanket,IUnknown*,pProxy,DWORD*,pAuthnSvc,DWORD*,pAuthzSvc,OLECHAR**,pServerPrincName,DWORD*,pAuthnLevel,DWORD*,pImpLevel,void**,pAuthInfo,DWORD*,pCapabilites) \
ICOM_METHOD8 (HRESULT,SetBlanket,IUnknown*,pProxy,DWORD,AuthnSvc,DWORD,AuthzSvc,OLECHAR*,pServerPrincName,DWORD,AuthnLevel,DWORD,ImpLevel,void*,pAuthInfo,DWORD,Capabilities) \
ICOM_METHOD2 (HRESULT,CopyProxy,IUnknown*,pProxy,IUnknown**,ppCopy)
/*** IUnknown methods ***/
#define IClientSecurity_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IClientSecurity_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IClientSecurity_Release(p) (p)->lpVtbl->Release(p)
/*** IClientSecurity methods ***/
#define IClientSecurity_QueryBlanket(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->QueryBlanket(p,a,b,c,d,e,f,g,h)
#define IClientSecurity_SetBlanket(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->SetBlanket(p,a,b,c,d,e,f,g,h)
#define IClientSecurity_CopyProxy(p,a,b) (p)->lpVtbl->CopyProxy(p,a,b)
#endif
HRESULT CALLBACK IClientSecurity_QueryBlanket_Proxy(
IClientSecurity* This,
IUnknown* pProxy,
DWORD* pAuthnSvc,
DWORD* pAuthzSvc,
OLECHAR** pServerPrincName,
DWORD* pAuthnLevel,
DWORD* pImpLevel,
void** pAuthInfo,
DWORD* pCapabilites);
void __RPC_STUB IClientSecurity_QueryBlanket_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IClientSecurity_SetBlanket_Proxy(
IClientSecurity* This,
IUnknown* pProxy,
DWORD AuthnSvc,
DWORD AuthzSvc,
OLECHAR* pServerPrincName,
DWORD AuthnLevel,
DWORD ImpLevel,
void* pAuthInfo,
DWORD Capabilities);
void __RPC_STUB IClientSecurity_SetBlanket_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IClientSecurity_CopyProxy_Proxy(
IClientSecurity* This,
IUnknown* pProxy,
IUnknown** ppCopy);
void __RPC_STUB IClientSecurity_CopyProxy_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IServerSecurity IServerSecurity;
/*****************************************************************************
* IServerSecurity interface
*/
DEFINE_GUID(IID_IServerSecurity, 0x0000013e, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IServerSecurity: IUnknown {
virtual HRESULT CALLBACK QueryBlanket(
DWORD* pAuthnSvc,
DWORD* pAuthzSvc,
OLECHAR** pServerPrincName,
DWORD* pAuthnLevel,
DWORD* pImpLevel,
void** pPrivs,
DWORD* pCapabilities) = 0;
virtual HRESULT CALLBACK ImpersonateClient(
) = 0;
virtual HRESULT CALLBACK RevertToSelf(
) = 0;
virtual BOOL CALLBACK IsImpersonating(
) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IServerSecurityVtbl IServerSecurityVtbl;
struct IServerSecurity {
const IServerSecurityVtbl* lpVtbl;
};
struct IServerSecurityVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IServerSecurity* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IServerSecurity* This);
ULONG (CALLBACK *Release)(
IServerSecurity* This);
/*** IServerSecurity methods ***/
HRESULT (CALLBACK *QueryBlanket)(
IServerSecurity* This,
DWORD* pAuthnSvc,
DWORD* pAuthzSvc,
OLECHAR** pServerPrincName,
DWORD* pAuthnLevel,
DWORD* pImpLevel,
void** pPrivs,
DWORD* pCapabilities);
HRESULT (CALLBACK *ImpersonateClient)(
IServerSecurity* This);
HRESULT (CALLBACK *RevertToSelf)(
IServerSecurity* This);
BOOL (CALLBACK *IsImpersonating)(
IServerSecurity* This);
};
#define IServerSecurity_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD7 (HRESULT,QueryBlanket,DWORD*,pAuthnSvc,DWORD*,pAuthzSvc,OLECHAR**,pServerPrincName,DWORD*,pAuthnLevel,DWORD*,pImpLevel,void**,pPrivs,DWORD*,pCapabilities) \
ICOM_METHOD (HRESULT,ImpersonateClient) \
ICOM_METHOD (HRESULT,RevertToSelf) \
ICOM_METHOD (BOOL,IsImpersonating)
/*** IUnknown methods ***/
#define IServerSecurity_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IServerSecurity_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IServerSecurity_Release(p) (p)->lpVtbl->Release(p)
/*** IServerSecurity methods ***/
#define IServerSecurity_QueryBlanket(p,a,b,c,d,e,f,g) (p)->lpVtbl->QueryBlanket(p,a,b,c,d,e,f,g)
#define IServerSecurity_ImpersonateClient(p) (p)->lpVtbl->ImpersonateClient(p)
#define IServerSecurity_RevertToSelf(p) (p)->lpVtbl->RevertToSelf(p)
#define IServerSecurity_IsImpersonating(p) (p)->lpVtbl->IsImpersonating(p)
#endif
HRESULT CALLBACK IServerSecurity_QueryBlanket_Proxy(
IServerSecurity* This,
DWORD* pAuthnSvc,
DWORD* pAuthzSvc,
OLECHAR** pServerPrincName,
DWORD* pAuthnLevel,
DWORD* pImpLevel,
void** pPrivs,
DWORD* pCapabilities);
void __RPC_STUB IServerSecurity_QueryBlanket_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IServerSecurity_ImpersonateClient_Proxy(
IServerSecurity* This);
void __RPC_STUB IServerSecurity_ImpersonateClient_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IServerSecurity_RevertToSelf_Proxy(
IServerSecurity* This);
void __RPC_STUB IServerSecurity_RevertToSelf_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
BOOL CALLBACK IServerSecurity_IsImpersonating_Proxy(
IServerSecurity* This);
void __RPC_STUB IServerSecurity_IsImpersonating_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef struct IAsyncSetup IAsyncSetup;
/*****************************************************************************
* IAsyncSetup interface
*/
DEFINE_GUID(IID_IAsyncSetup, 0x00000024, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IAsyncSetup: IUnknown {
virtual HRESULT CALLBACK GetAsyncManager(
REFIID riid,
IUnknown* pOuter,
DWORD dwFlags,
IUnknown** ppInner,
IAsyncManager** ppAsyncMgr) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IAsyncSetupVtbl IAsyncSetupVtbl;
struct IAsyncSetup {
const IAsyncSetupVtbl* lpVtbl;
};
struct IAsyncSetupVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IAsyncSetup* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IAsyncSetup* This);
ULONG (CALLBACK *Release)(
IAsyncSetup* This);
/*** IAsyncSetup methods ***/
HRESULT (CALLBACK *GetAsyncManager)(
IAsyncSetup* This,
REFIID riid,
IUnknown* pOuter,
DWORD dwFlags,
IUnknown** ppInner,
IAsyncManager** ppAsyncMgr);
};
#define IAsyncSetup_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD5 (HRESULT,GetAsyncManager,REFIID,riid,IUnknown*,pOuter,DWORD,dwFlags,IUnknown**,ppInner,IAsyncManager**,ppAsyncMgr)
/*** IUnknown methods ***/
#define IAsyncSetup_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IAsyncSetup_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IAsyncSetup_Release(p) (p)->lpVtbl->Release(p)
/*** IAsyncSetup methods ***/
#define IAsyncSetup_GetAsyncManager(p,a,b,c,d,e) (p)->lpVtbl->GetAsyncManager(p,a,b,c,d,e)
#endif
HRESULT CALLBACK IAsyncSetup_GetAsyncManager_Proxy(
IAsyncSetup* This,
REFIID riid,
IUnknown* pOuter,
DWORD dwFlags,
IUnknown** ppInner,
IAsyncManager** ppAsyncMgr);
void __RPC_STUB IAsyncSetup_GetAsyncManager_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
typedef enum tagDCOM_CALL_STATE {
DCOM_NONE = 0,
DCOM_CALL_COMPLETE = 1,
DCOM_CALL_CANCELED = 2
} DCOM_CALL_STATE;
/*****************************************************************************
* IAsyncManager interface
*/
DEFINE_GUID(IID_IAsyncManager, 0x0000002a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IAsyncManager: IUnknown {
virtual HRESULT CALLBACK CompleteCall(
HRESULT Result) = 0;
virtual HRESULT CALLBACK GetCallContext(
REFIID riid,
void** pInterface) = 0;
virtual HRESULT CALLBACK GetState(
ULONG* pulStateFlags) = 0;
} ICOM_COM_INTERFACE_ATTRIBUTE;
#else
typedef struct IAsyncManagerVtbl IAsyncManagerVtbl;
struct IAsyncManager {
const IAsyncManagerVtbl* lpVtbl;
};
struct IAsyncManagerVtbl {
ICOM_MSVTABLE_COMPAT_FIELDS
/*** IUnknown methods ***/
HRESULT (CALLBACK *QueryInterface)(
IAsyncManager* This,
REFIID riid,
void** ppvObject);
ULONG (CALLBACK *AddRef)(
IAsyncManager* This);
ULONG (CALLBACK *Release)(
IAsyncManager* This);
/*** IAsyncManager methods ***/
HRESULT (CALLBACK *CompleteCall)(
IAsyncManager* This,
HRESULT Result);
HRESULT (CALLBACK *GetCallContext)(
IAsyncManager* This,
REFIID riid,
void** pInterface);
HRESULT (CALLBACK *GetState)(
IAsyncManager* This,
ULONG* pulStateFlags);
};
#define IAsyncManager_IMETHODS \
IUnknown_IMETHODS \
ICOM_METHOD1 (HRESULT,CompleteCall,HRESULT,Result) \
ICOM_METHOD2 (HRESULT,GetCallContext,REFIID,riid,void**,pInterface) \
ICOM_METHOD1 (HRESULT,GetState,ULONG*,pulStateFlags)
/*** IUnknown methods ***/
#define IAsyncManager_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IAsyncManager_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IAsyncManager_Release(p) (p)->lpVtbl->Release(p)
/*** IAsyncManager methods ***/
#define IAsyncManager_CompleteCall(p,a) (p)->lpVtbl->CompleteCall(p,a)
#define IAsyncManager_GetCallContext(p,a,b) (p)->lpVtbl->GetCallContext(p,a,b)
#define IAsyncManager_GetState(p,a) (p)->lpVtbl->GetState(p,a)
#endif
HRESULT CALLBACK IAsyncManager_CompleteCall_Proxy(
IAsyncManager* This,
HRESULT Result);
void __RPC_STUB IAsyncManager_CompleteCall_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IAsyncManager_GetCallContext_Proxy(
IAsyncManager* This,
REFIID riid,
void** pInterface);
void __RPC_STUB IAsyncManager_GetCallContext_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT CALLBACK IAsyncManager_GetState_Proxy(
IAsyncManager* This,
ULONG* pulStateFlags);
void __RPC_STUB IAsyncManager_GetState_Stub(
struct IRpcStubBuffer* This,
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
#ifdef __cplusplus
}
#endif
#endif /* __WIDL_OBJIDL_H */
Reference in New Issue View Git Blame Copy Permalink