diff options
Diffstat (limited to 'src/VBox/Devices/Graphics/shaderlib/wine/include/objidl.h')
| -rw-r--r-- | src/VBox/Devices/Graphics/shaderlib/wine/include/objidl.h | 10438 |
1 files changed, 10438 insertions, 0 deletions
diff --git a/src/VBox/Devices/Graphics/shaderlib/wine/include/objidl.h b/src/VBox/Devices/Graphics/shaderlib/wine/include/objidl.h new file mode 100644 index 00000000..ec9cdf64 --- /dev/null +++ b/src/VBox/Devices/Graphics/shaderlib/wine/include/objidl.h @@ -0,0 +1,10438 @@ +/*** Autogenerated by WIDL 1.1.36 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 + +/* Headers for imported files */ + +#include <unknwn.h> + +/* Forward declarations */ + +#ifndef __IMarshal_FWD_DEFINED__ +#define __IMarshal_FWD_DEFINED__ +typedef interface IMarshal IMarshal; +#endif + +#ifndef __IMarshal2_FWD_DEFINED__ +#define __IMarshal2_FWD_DEFINED__ +typedef interface IMarshal2 IMarshal2; +#endif + +#ifndef __IStdMarshalInfo_FWD_DEFINED__ +#define __IStdMarshalInfo_FWD_DEFINED__ +typedef interface IStdMarshalInfo IStdMarshalInfo; +#endif + +#ifndef __IExternalConnection_FWD_DEFINED__ +#define __IExternalConnection_FWD_DEFINED__ +typedef interface IExternalConnection IExternalConnection; +#endif + +#ifndef __IMultiQI_FWD_DEFINED__ +#define __IMultiQI_FWD_DEFINED__ +typedef interface IMultiQI IMultiQI; +#endif + +#ifndef __IMalloc_FWD_DEFINED__ +#define __IMalloc_FWD_DEFINED__ +typedef interface IMalloc IMalloc; +#endif + +#ifndef __IMallocSpy_FWD_DEFINED__ +#define __IMallocSpy_FWD_DEFINED__ +typedef interface IMallocSpy IMallocSpy; +#endif + +#ifndef __IInternalUnknown_FWD_DEFINED__ +#define __IInternalUnknown_FWD_DEFINED__ +typedef interface IInternalUnknown IInternalUnknown; +#endif + +#ifndef __IEnumUnknown_FWD_DEFINED__ +#define __IEnumUnknown_FWD_DEFINED__ +typedef interface IEnumUnknown IEnumUnknown; +#endif + +#ifndef __ISurrogate_FWD_DEFINED__ +#define __ISurrogate_FWD_DEFINED__ +typedef interface ISurrogate ISurrogate; +#endif + +#ifndef __IGlobalInterfaceTable_FWD_DEFINED__ +#define __IGlobalInterfaceTable_FWD_DEFINED__ +typedef interface IGlobalInterfaceTable IGlobalInterfaceTable; +#endif + +#ifndef __IBindCtx_FWD_DEFINED__ +#define __IBindCtx_FWD_DEFINED__ +typedef interface IBindCtx IBindCtx; +#endif + +#ifndef __IEnumMoniker_FWD_DEFINED__ +#define __IEnumMoniker_FWD_DEFINED__ +typedef interface IEnumMoniker IEnumMoniker; +#endif + +#ifndef __IRunnableObject_FWD_DEFINED__ +#define __IRunnableObject_FWD_DEFINED__ +typedef interface IRunnableObject IRunnableObject; +#endif + +#ifndef __IRunningObjectTable_FWD_DEFINED__ +#define __IRunningObjectTable_FWD_DEFINED__ +typedef interface IRunningObjectTable IRunningObjectTable; +#endif + +#ifndef __IPersist_FWD_DEFINED__ +#define __IPersist_FWD_DEFINED__ +typedef interface IPersist IPersist; +#endif + +#ifndef __IPersistStream_FWD_DEFINED__ +#define __IPersistStream_FWD_DEFINED__ +typedef interface IPersistStream IPersistStream; +#endif + +#ifndef __IMoniker_FWD_DEFINED__ +#define __IMoniker_FWD_DEFINED__ +typedef interface IMoniker IMoniker; +#endif + +#ifndef __IROTData_FWD_DEFINED__ +#define __IROTData_FWD_DEFINED__ +typedef interface IROTData IROTData; +#endif + +#ifndef __IEnumString_FWD_DEFINED__ +#define __IEnumString_FWD_DEFINED__ +typedef interface IEnumString IEnumString; +#endif + +#ifndef __IClassActivator_FWD_DEFINED__ +#define __IClassActivator_FWD_DEFINED__ +typedef interface IClassActivator IClassActivator; +#endif + +#ifndef __ISequentialStream_FWD_DEFINED__ +#define __ISequentialStream_FWD_DEFINED__ +typedef interface ISequentialStream ISequentialStream; +#endif + +#ifndef __IStream_FWD_DEFINED__ +#define __IStream_FWD_DEFINED__ +typedef interface IStream IStream; +#endif + +#ifndef __IEnumSTATSTG_FWD_DEFINED__ +#define __IEnumSTATSTG_FWD_DEFINED__ +typedef interface IEnumSTATSTG IEnumSTATSTG; +#endif + +#ifndef __IStorage_FWD_DEFINED__ +#define __IStorage_FWD_DEFINED__ +typedef interface IStorage IStorage; +#endif + +#ifndef __IPersistFile_FWD_DEFINED__ +#define __IPersistFile_FWD_DEFINED__ +typedef interface IPersistFile IPersistFile; +#endif + +#ifndef __IPersistStorage_FWD_DEFINED__ +#define __IPersistStorage_FWD_DEFINED__ +typedef interface IPersistStorage IPersistStorage; +#endif + +#ifndef __IRootStorage_FWD_DEFINED__ +#define __IRootStorage_FWD_DEFINED__ +typedef interface IRootStorage IRootStorage; +#endif + +#ifndef __ILockBytes_FWD_DEFINED__ +#define __ILockBytes_FWD_DEFINED__ +typedef interface ILockBytes ILockBytes; +#endif + +#ifndef __IFillLockBytes_FWD_DEFINED__ +#define __IFillLockBytes_FWD_DEFINED__ +typedef interface IFillLockBytes IFillLockBytes; +#endif + +#ifndef __IProgressNotify_FWD_DEFINED__ +#define __IProgressNotify_FWD_DEFINED__ +typedef interface IProgressNotify IProgressNotify; +#endif + +#ifndef __ILayoutStorage_FWD_DEFINED__ +#define __ILayoutStorage_FWD_DEFINED__ +typedef interface ILayoutStorage ILayoutStorage; +#endif + +#ifndef __IBlockingLock_FWD_DEFINED__ +#define __IBlockingLock_FWD_DEFINED__ +typedef interface IBlockingLock IBlockingLock; +#endif + +#ifndef __ITimeAndNoticeControl_FWD_DEFINED__ +#define __ITimeAndNoticeControl_FWD_DEFINED__ +typedef interface ITimeAndNoticeControl ITimeAndNoticeControl; +#endif + +#ifndef __IOplockStorage_FWD_DEFINED__ +#define __IOplockStorage_FWD_DEFINED__ +typedef interface IOplockStorage IOplockStorage; +#endif + +#ifndef __IEnumFORMATETC_FWD_DEFINED__ +#define __IEnumFORMATETC_FWD_DEFINED__ +typedef interface IEnumFORMATETC IEnumFORMATETC; +#endif + +#ifndef __IEnumSTATDATA_FWD_DEFINED__ +#define __IEnumSTATDATA_FWD_DEFINED__ +typedef interface IEnumSTATDATA IEnumSTATDATA; +#endif + +#ifndef __IAdviseSink_FWD_DEFINED__ +#define __IAdviseSink_FWD_DEFINED__ +typedef interface IAdviseSink IAdviseSink; +#endif + +#ifndef __IAdviseSink2_FWD_DEFINED__ +#define __IAdviseSink2_FWD_DEFINED__ +typedef interface IAdviseSink2 IAdviseSink2; +#endif + +#ifndef __IDataObject_FWD_DEFINED__ +#define __IDataObject_FWD_DEFINED__ +typedef interface IDataObject IDataObject; +#endif + +#ifndef __IDataAdviseHolder_FWD_DEFINED__ +#define __IDataAdviseHolder_FWD_DEFINED__ +typedef interface IDataAdviseHolder IDataAdviseHolder; +#endif + +#ifndef __IMessageFilter_FWD_DEFINED__ +#define __IMessageFilter_FWD_DEFINED__ +typedef interface IMessageFilter IMessageFilter; +#endif + +#ifndef __IRpcChannelBuffer_FWD_DEFINED__ +#define __IRpcChannelBuffer_FWD_DEFINED__ +typedef interface IRpcChannelBuffer IRpcChannelBuffer; +#endif + +#ifndef __IRpcChannelBuffer2_FWD_DEFINED__ +#define __IRpcChannelBuffer2_FWD_DEFINED__ +typedef interface IRpcChannelBuffer2 IRpcChannelBuffer2; +#endif + +#ifndef __IRpcChannelBuffer3_FWD_DEFINED__ +#define __IRpcChannelBuffer3_FWD_DEFINED__ +typedef interface IRpcChannelBuffer3 IRpcChannelBuffer3; +#endif + +#ifndef __IAsyncRpcChannelBuffer_FWD_DEFINED__ +#define __IAsyncRpcChannelBuffer_FWD_DEFINED__ +typedef interface IAsyncRpcChannelBuffer IAsyncRpcChannelBuffer; +#endif + +#ifndef __IRpcSyntaxNegotiate_FWD_DEFINED__ +#define __IRpcSyntaxNegotiate_FWD_DEFINED__ +typedef interface IRpcSyntaxNegotiate IRpcSyntaxNegotiate; +#endif + +#ifndef __IRpcProxyBuffer_FWD_DEFINED__ +#define __IRpcProxyBuffer_FWD_DEFINED__ +typedef interface IRpcProxyBuffer IRpcProxyBuffer; +#endif + +#ifndef __IRpcStubBuffer_FWD_DEFINED__ +#define __IRpcStubBuffer_FWD_DEFINED__ +typedef interface IRpcStubBuffer IRpcStubBuffer; +#endif + +#ifndef __IPSFactoryBuffer_FWD_DEFINED__ +#define __IPSFactoryBuffer_FWD_DEFINED__ +typedef interface IPSFactoryBuffer IPSFactoryBuffer; +#endif + +#ifndef __IChannelHook_FWD_DEFINED__ +#define __IChannelHook_FWD_DEFINED__ +typedef interface IChannelHook IChannelHook; +#endif + +#ifndef __IClientSecurity_FWD_DEFINED__ +#define __IClientSecurity_FWD_DEFINED__ +typedef interface IClientSecurity IClientSecurity; +#endif + +#ifndef __IServerSecurity_FWD_DEFINED__ +#define __IServerSecurity_FWD_DEFINED__ +typedef interface IServerSecurity IServerSecurity; +#endif + +#ifndef __IAsyncSetup_FWD_DEFINED__ +#define __IAsyncSetup_FWD_DEFINED__ +typedef interface IAsyncSetup IAsyncSetup; +#endif + +#ifndef __IDirectWriterLock_FWD_DEFINED__ +#define __IDirectWriterLock_FWD_DEFINED__ +typedef interface IDirectWriterLock IDirectWriterLock; +#endif + +#ifndef __ISynchronize_FWD_DEFINED__ +#define __ISynchronize_FWD_DEFINED__ +typedef interface ISynchronize ISynchronize; +#endif + +#ifndef __ISynchronizeHandle_FWD_DEFINED__ +#define __ISynchronizeHandle_FWD_DEFINED__ +typedef interface ISynchronizeHandle ISynchronizeHandle; +#endif + +#ifndef __ISynchronizeEvent_FWD_DEFINED__ +#define __ISynchronizeEvent_FWD_DEFINED__ +typedef interface ISynchronizeEvent ISynchronizeEvent; +#endif + +#ifndef __ISynchronizeContainer_FWD_DEFINED__ +#define __ISynchronizeContainer_FWD_DEFINED__ +typedef interface ISynchronizeContainer ISynchronizeContainer; +#endif + +#ifndef __ISynchronizeMutex_FWD_DEFINED__ +#define __ISynchronizeMutex_FWD_DEFINED__ +typedef interface ISynchronizeMutex ISynchronizeMutex; +#endif + +#ifndef __ICancelMethodCalls_FWD_DEFINED__ +#define __ICancelMethodCalls_FWD_DEFINED__ +typedef interface ICancelMethodCalls ICancelMethodCalls; +#endif + +#ifndef __IAsyncManager_FWD_DEFINED__ +#define __IAsyncManager_FWD_DEFINED__ +typedef interface IAsyncManager IAsyncManager; +#endif + +#ifndef __ICallFactory_FWD_DEFINED__ +#define __ICallFactory_FWD_DEFINED__ +typedef interface ICallFactory ICallFactory; +#endif + +#ifndef __IRpcOptions_FWD_DEFINED__ +#define __IRpcOptions_FWD_DEFINED__ +typedef interface IRpcOptions IRpcOptions; +#endif + +#ifndef __IRpcHelper_FWD_DEFINED__ +#define __IRpcHelper_FWD_DEFINED__ +typedef interface IRpcHelper IRpcHelper; +#endif + +#ifndef __IReleaseMarshalBuffers_FWD_DEFINED__ +#define __IReleaseMarshalBuffers_FWD_DEFINED__ +typedef interface IReleaseMarshalBuffers IReleaseMarshalBuffers; +#endif + +#ifndef __IWaitMultiple_FWD_DEFINED__ +#define __IWaitMultiple_FWD_DEFINED__ +typedef interface IWaitMultiple IWaitMultiple; +#endif + +#ifndef __IUrlMon_FWD_DEFINED__ +#define __IUrlMon_FWD_DEFINED__ +typedef interface IUrlMon IUrlMon; +#endif + +#ifndef __IForegroundTransfer_FWD_DEFINED__ +#define __IForegroundTransfer_FWD_DEFINED__ +typedef interface IForegroundTransfer IForegroundTransfer; +#endif + +#ifndef __IAddrTrackingControl_FWD_DEFINED__ +#define __IAddrTrackingControl_FWD_DEFINED__ +typedef interface IAddrTrackingControl IAddrTrackingControl; +#endif + +#ifndef __IAddrExclusionControl_FWD_DEFINED__ +#define __IAddrExclusionControl_FWD_DEFINED__ +typedef interface IAddrExclusionControl IAddrExclusionControl; +#endif + +#ifndef __IComThreadingInfo_FWD_DEFINED__ +#define __IComThreadingInfo_FWD_DEFINED__ +typedef interface IComThreadingInfo IComThreadingInfo; +#endif + +#ifndef __IProcessInitControl_FWD_DEFINED__ +#define __IProcessInitControl_FWD_DEFINED__ +typedef interface IProcessInitControl IProcessInitControl; +#endif + +#ifndef __IInitializeSpy_FWD_DEFINED__ +#define __IInitializeSpy_FWD_DEFINED__ +typedef interface IInitializeSpy IInitializeSpy; +#endif + +#ifndef __IThumbnailExtractor_FWD_DEFINED__ +#define __IThumbnailExtractor_FWD_DEFINED__ +typedef interface IThumbnailExtractor IThumbnailExtractor; +#endif + +#ifndef __IEnumContextProps_FWD_DEFINED__ +#define __IEnumContextProps_FWD_DEFINED__ +typedef interface IEnumContextProps IEnumContextProps; +#endif + +#ifndef __IContext_FWD_DEFINED__ +#define __IContext_FWD_DEFINED__ +typedef interface IContext IContext; +#endif + +#ifndef __IObjContext_FWD_DEFINED__ +#define __IObjContext_FWD_DEFINED__ +typedef interface IObjContext IObjContext; +#endif + + +#ifndef __IStream_FWD_DEFINED__ +#define __IStream_FWD_DEFINED__ +typedef interface IStream IStream; +#endif + +#ifndef __IEnumString_FWD_DEFINED__ +#define __IEnumString_FWD_DEFINED__ +typedef interface IEnumString IEnumString; +#endif + +#ifndef __IRunningObjectTable_FWD_DEFINED__ +#define __IRunningObjectTable_FWD_DEFINED__ +typedef interface IRunningObjectTable IRunningObjectTable; +#endif + +#ifndef __IMoniker_FWD_DEFINED__ +#define __IMoniker_FWD_DEFINED__ +typedef interface IMoniker IMoniker; +#endif + +#ifndef __IAdviseSink_FWD_DEFINED__ +#define __IAdviseSink_FWD_DEFINED__ +typedef interface IAdviseSink IAdviseSink; +#endif + +#ifndef __IAsyncManager_FWD_DEFINED__ +#define __IAsyncManager_FWD_DEFINED__ +typedef interface IAsyncManager IAsyncManager; +#endif + +#ifndef __ISynchronize_FWD_DEFINED__ +#define __ISynchronize_FWD_DEFINED__ +typedef interface ISynchronize ISynchronize; +#endif + +typedef struct _COSERVERINFO { + DWORD dwReserved1; + LPWSTR pwszName; + COAUTHINFO *pAuthInfo; + DWORD dwReserved2; +} COSERVERINFO; +/***************************************************************************** + * IMarshal interface + */ +#ifndef __IMarshal_INTERFACE_DEFINED__ +#define __IMarshal_INTERFACE_DEFINED__ + +typedef IMarshal *LPMARSHAL; +DEFINE_GUID(IID_IMarshal, 0x00000003, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IMarshal : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetUnmarshalClass( + REFIID riid, + void *pv, + DWORD dwDestContext, + void *pvDestContext, + DWORD mshlflags, + CLSID *pCid) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMarshalSizeMax( + REFIID riid, + void *pv, + DWORD dwDestContext, + void *pvDestContext, + DWORD mshlflags, + DWORD *pSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE MarshalInterface( + IStream *pStm, + REFIID riid, + void *pv, + DWORD dwDestContext, + void *pvDestContext, + DWORD mshlflags) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnmarshalInterface( + IStream *pStm, + REFIID riid, + void **ppv) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReleaseMarshalData( + IStream *pStm) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisconnectObject( + DWORD dwReserved) = 0; + +}; +#else +typedef struct IMarshalVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IMarshal* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IMarshal* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IMarshal* This); + + /*** IMarshal methods ***/ + HRESULT (STDMETHODCALLTYPE *GetUnmarshalClass)( + IMarshal* This, + REFIID riid, + void *pv, + DWORD dwDestContext, + void *pvDestContext, + DWORD mshlflags, + CLSID *pCid); + + HRESULT (STDMETHODCALLTYPE *GetMarshalSizeMax)( + IMarshal* This, + REFIID riid, + void *pv, + DWORD dwDestContext, + void *pvDestContext, + DWORD mshlflags, + DWORD *pSize); + + HRESULT (STDMETHODCALLTYPE *MarshalInterface)( + IMarshal* This, + IStream *pStm, + REFIID riid, + void *pv, + DWORD dwDestContext, + void *pvDestContext, + DWORD mshlflags); + + HRESULT (STDMETHODCALLTYPE *UnmarshalInterface)( + IMarshal* This, + IStream *pStm, + REFIID riid, + void **ppv); + + HRESULT (STDMETHODCALLTYPE *ReleaseMarshalData)( + IMarshal* This, + IStream *pStm); + + HRESULT (STDMETHODCALLTYPE *DisconnectObject)( + IMarshal* This, + DWORD dwReserved); + + END_INTERFACE +} IMarshalVtbl; +interface IMarshal { + CONST_VTBL IMarshalVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IMarshal_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IMarshal_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IMarshal_Release(This) (This)->lpVtbl->Release(This) +/*** IMarshal methods ***/ +#define IMarshal_GetUnmarshalClass(This,riid,pv,dwDestContext,pvDestContext,mshlflags,pCid) (This)->lpVtbl->GetUnmarshalClass(This,riid,pv,dwDestContext,pvDestContext,mshlflags,pCid) +#define IMarshal_GetMarshalSizeMax(This,riid,pv,dwDestContext,pvDestContext,mshlflags,pSize) (This)->lpVtbl->GetMarshalSizeMax(This,riid,pv,dwDestContext,pvDestContext,mshlflags,pSize) +#define IMarshal_MarshalInterface(This,pStm,riid,pv,dwDestContext,pvDestContext,mshlflags) (This)->lpVtbl->MarshalInterface(This,pStm,riid,pv,dwDestContext,pvDestContext,mshlflags) +#define IMarshal_UnmarshalInterface(This,pStm,riid,ppv) (This)->lpVtbl->UnmarshalInterface(This,pStm,riid,ppv) +#define IMarshal_ReleaseMarshalData(This,pStm) (This)->lpVtbl->ReleaseMarshalData(This,pStm) +#define IMarshal_DisconnectObject(This,dwReserved) (This)->lpVtbl->DisconnectObject(This,dwReserved) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IMarshal_GetUnmarshalClass_Proxy( + IMarshal* This, + REFIID riid, + void *pv, + DWORD dwDestContext, + void *pvDestContext, + DWORD mshlflags, + CLSID *pCid); +void __RPC_STUB IMarshal_GetUnmarshalClass_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMarshal_GetMarshalSizeMax_Proxy( + IMarshal* This, + REFIID riid, + void *pv, + DWORD dwDestContext, + void *pvDestContext, + DWORD mshlflags, + DWORD *pSize); +void __RPC_STUB IMarshal_GetMarshalSizeMax_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMarshal_MarshalInterface_Proxy( + IMarshal* This, + IStream *pStm, + REFIID riid, + void *pv, + DWORD dwDestContext, + void *pvDestContext, + DWORD mshlflags); +void __RPC_STUB IMarshal_MarshalInterface_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMarshal_UnmarshalInterface_Proxy( + IMarshal* This, + IStream *pStm, + REFIID riid, + void **ppv); +void __RPC_STUB IMarshal_UnmarshalInterface_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMarshal_ReleaseMarshalData_Proxy( + IMarshal* This, + IStream *pStm); +void __RPC_STUB IMarshal_ReleaseMarshalData_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMarshal_DisconnectObject_Proxy( + IMarshal* This, + DWORD dwReserved); +void __RPC_STUB IMarshal_DisconnectObject_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IMarshal_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IMarshal2 interface + */ +#ifndef __IMarshal2_INTERFACE_DEFINED__ +#define __IMarshal2_INTERFACE_DEFINED__ + +typedef IMarshal2 *LPMARSHAL2; +DEFINE_GUID(IID_IMarshal2, 0x000001cf, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IMarshal2 : public IMarshal +{ +}; +#else +typedef struct IMarshal2Vtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IMarshal2* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IMarshal2* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IMarshal2* This); + + /*** IMarshal methods ***/ + HRESULT (STDMETHODCALLTYPE *GetUnmarshalClass)( + IMarshal2* This, + REFIID riid, + void *pv, + DWORD dwDestContext, + void *pvDestContext, + DWORD mshlflags, + CLSID *pCid); + + HRESULT (STDMETHODCALLTYPE *GetMarshalSizeMax)( + IMarshal2* This, + REFIID riid, + void *pv, + DWORD dwDestContext, + void *pvDestContext, + DWORD mshlflags, + DWORD *pSize); + + HRESULT (STDMETHODCALLTYPE *MarshalInterface)( + IMarshal2* This, + IStream *pStm, + REFIID riid, + void *pv, + DWORD dwDestContext, + void *pvDestContext, + DWORD mshlflags); + + HRESULT (STDMETHODCALLTYPE *UnmarshalInterface)( + IMarshal2* This, + IStream *pStm, + REFIID riid, + void **ppv); + + HRESULT (STDMETHODCALLTYPE *ReleaseMarshalData)( + IMarshal2* This, + IStream *pStm); + + HRESULT (STDMETHODCALLTYPE *DisconnectObject)( + IMarshal2* This, + DWORD dwReserved); + + END_INTERFACE +} IMarshal2Vtbl; +interface IMarshal2 { + CONST_VTBL IMarshal2Vtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IMarshal2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IMarshal2_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IMarshal2_Release(This) (This)->lpVtbl->Release(This) +/*** IMarshal methods ***/ +#define IMarshal2_GetUnmarshalClass(This,riid,pv,dwDestContext,pvDestContext,mshlflags,pCid) (This)->lpVtbl->GetUnmarshalClass(This,riid,pv,dwDestContext,pvDestContext,mshlflags,pCid) +#define IMarshal2_GetMarshalSizeMax(This,riid,pv,dwDestContext,pvDestContext,mshlflags,pSize) (This)->lpVtbl->GetMarshalSizeMax(This,riid,pv,dwDestContext,pvDestContext,mshlflags,pSize) +#define IMarshal2_MarshalInterface(This,pStm,riid,pv,dwDestContext,pvDestContext,mshlflags) (This)->lpVtbl->MarshalInterface(This,pStm,riid,pv,dwDestContext,pvDestContext,mshlflags) +#define IMarshal2_UnmarshalInterface(This,pStm,riid,ppv) (This)->lpVtbl->UnmarshalInterface(This,pStm,riid,ppv) +#define IMarshal2_ReleaseMarshalData(This,pStm) (This)->lpVtbl->ReleaseMarshalData(This,pStm) +#define IMarshal2_DisconnectObject(This,dwReserved) (This)->lpVtbl->DisconnectObject(This,dwReserved) +#endif + +#endif + + +#endif /* __IMarshal2_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IStdMarshalInfo interface + */ +#ifndef __IStdMarshalInfo_INTERFACE_DEFINED__ +#define __IStdMarshalInfo_INTERFACE_DEFINED__ + +typedef IStdMarshalInfo *LPSTDMARSHALINFO; +DEFINE_GUID(IID_IStdMarshalInfo, 0x00000018, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IStdMarshalInfo : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetClassForHandler( + DWORD dwDestContext, + void *pvDestContext, + CLSID *pClsid) = 0; + +}; +#else +typedef struct IStdMarshalInfoVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IStdMarshalInfo* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IStdMarshalInfo* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IStdMarshalInfo* This); + + /*** IStdMarshalInfo methods ***/ + HRESULT (STDMETHODCALLTYPE *GetClassForHandler)( + IStdMarshalInfo* This, + DWORD dwDestContext, + void *pvDestContext, + CLSID *pClsid); + + END_INTERFACE +} IStdMarshalInfoVtbl; +interface IStdMarshalInfo { + CONST_VTBL IStdMarshalInfoVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IStdMarshalInfo_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IStdMarshalInfo_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IStdMarshalInfo_Release(This) (This)->lpVtbl->Release(This) +/*** IStdMarshalInfo methods ***/ +#define IStdMarshalInfo_GetClassForHandler(This,dwDestContext,pvDestContext,pClsid) (This)->lpVtbl->GetClassForHandler(This,dwDestContext,pvDestContext,pClsid) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IStdMarshalInfo_GetClassForHandler_Proxy( + IStdMarshalInfo* This, + DWORD dwDestContext, + void *pvDestContext, + CLSID *pClsid); +void __RPC_STUB IStdMarshalInfo_GetClassForHandler_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IStdMarshalInfo_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IExternalConnection interface + */ +#ifndef __IExternalConnection_INTERFACE_DEFINED__ +#define __IExternalConnection_INTERFACE_DEFINED__ + +typedef IExternalConnection *LPEXTERNALCONNECTION; +typedef enum tagEXTCONN { + EXTCONN_STRONG = 0x1, + EXTCONN_WEAK = 0x2, + EXTCONN_CALLABLE = 0x4 +} EXTCONN; +DEFINE_GUID(IID_IExternalConnection, 0x00000019, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IExternalConnection : public IUnknown +{ + virtual DWORD STDMETHODCALLTYPE AddConnection( + DWORD extconn, + DWORD reserved) = 0; + + virtual DWORD STDMETHODCALLTYPE ReleaseConnection( + DWORD extconn, + DWORD reserved, + BOOL fLastReleaseCloses) = 0; + +}; +#else +typedef struct IExternalConnectionVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IExternalConnection* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IExternalConnection* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IExternalConnection* This); + + /*** IExternalConnection methods ***/ + DWORD (STDMETHODCALLTYPE *AddConnection)( + IExternalConnection* This, + DWORD extconn, + DWORD reserved); + + DWORD (STDMETHODCALLTYPE *ReleaseConnection)( + IExternalConnection* This, + DWORD extconn, + DWORD reserved, + BOOL fLastReleaseCloses); + + END_INTERFACE +} IExternalConnectionVtbl; +interface IExternalConnection { + CONST_VTBL IExternalConnectionVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IExternalConnection_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IExternalConnection_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IExternalConnection_Release(This) (This)->lpVtbl->Release(This) +/*** IExternalConnection methods ***/ +#define IExternalConnection_AddConnection(This,extconn,reserved) (This)->lpVtbl->AddConnection(This,extconn,reserved) +#define IExternalConnection_ReleaseConnection(This,extconn,reserved,fLastReleaseCloses) (This)->lpVtbl->ReleaseConnection(This,extconn,reserved,fLastReleaseCloses) +#endif + +#endif + +DWORD STDMETHODCALLTYPE IExternalConnection_AddConnection_Proxy( + IExternalConnection* This, + DWORD extconn, + DWORD reserved); +void __RPC_STUB IExternalConnection_AddConnection_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +DWORD STDMETHODCALLTYPE IExternalConnection_ReleaseConnection_Proxy( + IExternalConnection* This, + DWORD extconn, + DWORD reserved, + BOOL fLastReleaseCloses); +void __RPC_STUB IExternalConnection_ReleaseConnection_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IExternalConnection_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IMultiQI interface + */ +#ifndef __IMultiQI_INTERFACE_DEFINED__ +#define __IMultiQI_INTERFACE_DEFINED__ + +typedef IMultiQI *LPMULTIQI; +typedef struct tagMULTI_QI { + const IID *pIID; + IUnknown *pItf; + HRESULT hr; +} MULTI_QI; +DEFINE_GUID(IID_IMultiQI, 0x00000020, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IMultiQI : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE QueryMultipleInterfaces( + ULONG cMQIs, + MULTI_QI *pMQIs) = 0; + +}; +#else +typedef struct IMultiQIVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IMultiQI* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IMultiQI* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IMultiQI* This); + + /*** IMultiQI methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryMultipleInterfaces)( + IMultiQI* This, + ULONG cMQIs, + MULTI_QI *pMQIs); + + END_INTERFACE +} IMultiQIVtbl; +interface IMultiQI { + CONST_VTBL IMultiQIVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IMultiQI_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IMultiQI_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IMultiQI_Release(This) (This)->lpVtbl->Release(This) +/*** IMultiQI methods ***/ +#define IMultiQI_QueryMultipleInterfaces(This,cMQIs,pMQIs) (This)->lpVtbl->QueryMultipleInterfaces(This,cMQIs,pMQIs) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IMultiQI_QueryMultipleInterfaces_Proxy( + IMultiQI* This, + ULONG cMQIs, + MULTI_QI *pMQIs); +void __RPC_STUB IMultiQI_QueryMultipleInterfaces_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IMultiQI_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IMalloc interface + */ +#ifndef __IMalloc_INTERFACE_DEFINED__ +#define __IMalloc_INTERFACE_DEFINED__ + +typedef IMalloc *LPMALLOC; +DEFINE_GUID(IID_IMalloc, 0x00000002, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IMalloc : public IUnknown +{ + virtual LPVOID STDMETHODCALLTYPE Alloc( + ULONG cb) = 0; + + virtual LPVOID STDMETHODCALLTYPE Realloc( + LPVOID pv, + ULONG cb) = 0; + + virtual void STDMETHODCALLTYPE Free( + LPVOID pv) = 0; + + virtual ULONG STDMETHODCALLTYPE GetSize( + LPVOID pv) = 0; + + virtual int STDMETHODCALLTYPE DidAlloc( + LPVOID pv) = 0; + + virtual void STDMETHODCALLTYPE HeapMinimize( + ) = 0; + +}; +#else +typedef struct IMallocVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IMalloc* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IMalloc* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IMalloc* This); + + /*** IMalloc methods ***/ + LPVOID (STDMETHODCALLTYPE *Alloc)( + IMalloc* This, + ULONG cb); + + LPVOID (STDMETHODCALLTYPE *Realloc)( + IMalloc* This, + LPVOID pv, + ULONG cb); + + void (STDMETHODCALLTYPE *Free)( + IMalloc* This, + LPVOID pv); + + ULONG (STDMETHODCALLTYPE *GetSize)( + IMalloc* This, + LPVOID pv); + + int (STDMETHODCALLTYPE *DidAlloc)( + IMalloc* This, + LPVOID pv); + + void (STDMETHODCALLTYPE *HeapMinimize)( + IMalloc* This); + + END_INTERFACE +} IMallocVtbl; +interface IMalloc { + CONST_VTBL IMallocVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IMalloc_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IMalloc_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IMalloc_Release(This) (This)->lpVtbl->Release(This) +/*** IMalloc methods ***/ +#define IMalloc_Alloc(This,cb) (This)->lpVtbl->Alloc(This,cb) +#define IMalloc_Realloc(This,pv,cb) (This)->lpVtbl->Realloc(This,pv,cb) +#define IMalloc_Free(This,pv) (This)->lpVtbl->Free(This,pv) +#define IMalloc_GetSize(This,pv) (This)->lpVtbl->GetSize(This,pv) +#define IMalloc_DidAlloc(This,pv) (This)->lpVtbl->DidAlloc(This,pv) +#define IMalloc_HeapMinimize(This) (This)->lpVtbl->HeapMinimize(This) +#endif + +#endif + +LPVOID STDMETHODCALLTYPE IMalloc_Alloc_Proxy( + IMalloc* This, + ULONG cb); +void __RPC_STUB IMalloc_Alloc_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +LPVOID STDMETHODCALLTYPE IMalloc_Realloc_Proxy( + IMalloc* This, + LPVOID pv, + ULONG cb); +void __RPC_STUB IMalloc_Realloc_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IMalloc_Free_Proxy( + IMalloc* This, + LPVOID pv); +void __RPC_STUB IMalloc_Free_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +ULONG STDMETHODCALLTYPE IMalloc_GetSize_Proxy( + IMalloc* This, + LPVOID pv); +void __RPC_STUB IMalloc_GetSize_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +int STDMETHODCALLTYPE IMalloc_DidAlloc_Proxy( + IMalloc* This, + LPVOID pv); +void __RPC_STUB IMalloc_DidAlloc_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IMalloc_HeapMinimize_Proxy( + IMalloc* This); +void __RPC_STUB IMalloc_HeapMinimize_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IMalloc_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IMallocSpy interface + */ +#ifndef __IMallocSpy_INTERFACE_DEFINED__ +#define __IMallocSpy_INTERFACE_DEFINED__ + +typedef IMallocSpy *LPMALLOCSPY; +DEFINE_GUID(IID_IMallocSpy, 0x0000001d, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IMallocSpy : public IUnknown +{ + virtual ULONG STDMETHODCALLTYPE PreAlloc( + ULONG cbRequest) = 0; + + virtual LPVOID STDMETHODCALLTYPE PostAlloc( + LPVOID pActual) = 0; + + virtual LPVOID STDMETHODCALLTYPE PreFree( + LPVOID pRequest, + BOOL fSpyed) = 0; + + virtual void STDMETHODCALLTYPE PostFree( + BOOL fSpyed) = 0; + + virtual ULONG STDMETHODCALLTYPE PreRealloc( + LPVOID pRequest, + ULONG cbRequest, + LPVOID *ppNewRequest, + BOOL fSpyed) = 0; + + virtual LPVOID STDMETHODCALLTYPE PostRealloc( + LPVOID pActual, + BOOL fSpyed) = 0; + + virtual LPVOID STDMETHODCALLTYPE PreGetSize( + LPVOID pRequest, + BOOL fSpyed) = 0; + + virtual ULONG STDMETHODCALLTYPE PostGetSize( + ULONG cbActual, + BOOL fSpyed) = 0; + + virtual LPVOID STDMETHODCALLTYPE PreDidAlloc( + LPVOID pRequest, + BOOL fSpyed) = 0; + + virtual int STDMETHODCALLTYPE PostDidAlloc( + LPVOID pRequest, + BOOL fSpyed, + int fActual) = 0; + + virtual void STDMETHODCALLTYPE PreHeapMinimize( + ) = 0; + + virtual void STDMETHODCALLTYPE PostHeapMinimize( + ) = 0; + +}; +#else +typedef struct IMallocSpyVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IMallocSpy* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IMallocSpy* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IMallocSpy* This); + + /*** IMallocSpy methods ***/ + ULONG (STDMETHODCALLTYPE *PreAlloc)( + IMallocSpy* This, + ULONG cbRequest); + + LPVOID (STDMETHODCALLTYPE *PostAlloc)( + IMallocSpy* This, + LPVOID pActual); + + LPVOID (STDMETHODCALLTYPE *PreFree)( + IMallocSpy* This, + LPVOID pRequest, + BOOL fSpyed); + + void (STDMETHODCALLTYPE *PostFree)( + IMallocSpy* This, + BOOL fSpyed); + + ULONG (STDMETHODCALLTYPE *PreRealloc)( + IMallocSpy* This, + LPVOID pRequest, + ULONG cbRequest, + LPVOID *ppNewRequest, + BOOL fSpyed); + + LPVOID (STDMETHODCALLTYPE *PostRealloc)( + IMallocSpy* This, + LPVOID pActual, + BOOL fSpyed); + + LPVOID (STDMETHODCALLTYPE *PreGetSize)( + IMallocSpy* This, + LPVOID pRequest, + BOOL fSpyed); + + ULONG (STDMETHODCALLTYPE *PostGetSize)( + IMallocSpy* This, + ULONG cbActual, + BOOL fSpyed); + + LPVOID (STDMETHODCALLTYPE *PreDidAlloc)( + IMallocSpy* This, + LPVOID pRequest, + BOOL fSpyed); + + int (STDMETHODCALLTYPE *PostDidAlloc)( + IMallocSpy* This, + LPVOID pRequest, + BOOL fSpyed, + int fActual); + + void (STDMETHODCALLTYPE *PreHeapMinimize)( + IMallocSpy* This); + + void (STDMETHODCALLTYPE *PostHeapMinimize)( + IMallocSpy* This); + + END_INTERFACE +} IMallocSpyVtbl; +interface IMallocSpy { + CONST_VTBL IMallocSpyVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IMallocSpy_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IMallocSpy_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IMallocSpy_Release(This) (This)->lpVtbl->Release(This) +/*** IMallocSpy methods ***/ +#define IMallocSpy_PreAlloc(This,cbRequest) (This)->lpVtbl->PreAlloc(This,cbRequest) +#define IMallocSpy_PostAlloc(This,pActual) (This)->lpVtbl->PostAlloc(This,pActual) +#define IMallocSpy_PreFree(This,pRequest,fSpyed) (This)->lpVtbl->PreFree(This,pRequest,fSpyed) +#define IMallocSpy_PostFree(This,fSpyed) (This)->lpVtbl->PostFree(This,fSpyed) +#define IMallocSpy_PreRealloc(This,pRequest,cbRequest,ppNewRequest,fSpyed) (This)->lpVtbl->PreRealloc(This,pRequest,cbRequest,ppNewRequest,fSpyed) +#define IMallocSpy_PostRealloc(This,pActual,fSpyed) (This)->lpVtbl->PostRealloc(This,pActual,fSpyed) +#define IMallocSpy_PreGetSize(This,pRequest,fSpyed) (This)->lpVtbl->PreGetSize(This,pRequest,fSpyed) +#define IMallocSpy_PostGetSize(This,cbActual,fSpyed) (This)->lpVtbl->PostGetSize(This,cbActual,fSpyed) +#define IMallocSpy_PreDidAlloc(This,pRequest,fSpyed) (This)->lpVtbl->PreDidAlloc(This,pRequest,fSpyed) +#define IMallocSpy_PostDidAlloc(This,pRequest,fSpyed,fActual) (This)->lpVtbl->PostDidAlloc(This,pRequest,fSpyed,fActual) +#define IMallocSpy_PreHeapMinimize(This) (This)->lpVtbl->PreHeapMinimize(This) +#define IMallocSpy_PostHeapMinimize(This) (This)->lpVtbl->PostHeapMinimize(This) +#endif + +#endif + +ULONG STDMETHODCALLTYPE IMallocSpy_PreAlloc_Proxy( + IMallocSpy* This, + ULONG cbRequest); +void __RPC_STUB IMallocSpy_PreAlloc_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +LPVOID STDMETHODCALLTYPE IMallocSpy_PostAlloc_Proxy( + IMallocSpy* This, + LPVOID pActual); +void __RPC_STUB IMallocSpy_PostAlloc_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +LPVOID STDMETHODCALLTYPE IMallocSpy_PreFree_Proxy( + IMallocSpy* This, + LPVOID pRequest, + BOOL fSpyed); +void __RPC_STUB IMallocSpy_PreFree_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IMallocSpy_PostFree_Proxy( + IMallocSpy* This, + BOOL fSpyed); +void __RPC_STUB IMallocSpy_PostFree_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +ULONG STDMETHODCALLTYPE IMallocSpy_PreRealloc_Proxy( + IMallocSpy* This, + LPVOID pRequest, + ULONG cbRequest, + LPVOID *ppNewRequest, + BOOL fSpyed); +void __RPC_STUB IMallocSpy_PreRealloc_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +LPVOID STDMETHODCALLTYPE IMallocSpy_PostRealloc_Proxy( + IMallocSpy* This, + LPVOID pActual, + BOOL fSpyed); +void __RPC_STUB IMallocSpy_PostRealloc_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +LPVOID STDMETHODCALLTYPE IMallocSpy_PreGetSize_Proxy( + IMallocSpy* This, + LPVOID pRequest, + BOOL fSpyed); +void __RPC_STUB IMallocSpy_PreGetSize_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +ULONG STDMETHODCALLTYPE IMallocSpy_PostGetSize_Proxy( + IMallocSpy* This, + ULONG cbActual, + BOOL fSpyed); +void __RPC_STUB IMallocSpy_PostGetSize_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +LPVOID STDMETHODCALLTYPE IMallocSpy_PreDidAlloc_Proxy( + IMallocSpy* This, + LPVOID pRequest, + BOOL fSpyed); +void __RPC_STUB IMallocSpy_PreDidAlloc_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +int STDMETHODCALLTYPE IMallocSpy_PostDidAlloc_Proxy( + IMallocSpy* This, + LPVOID pRequest, + BOOL fSpyed, + int fActual); +void __RPC_STUB IMallocSpy_PostDidAlloc_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IMallocSpy_PreHeapMinimize_Proxy( + IMallocSpy* This); +void __RPC_STUB IMallocSpy_PreHeapMinimize_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IMallocSpy_PostHeapMinimize_Proxy( + IMallocSpy* This); +void __RPC_STUB IMallocSpy_PostHeapMinimize_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IMallocSpy_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IInternalUnknown interface + */ +#ifndef __IInternalUnknown_INTERFACE_DEFINED__ +#define __IInternalUnknown_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IInternalUnknown, 0x00000021, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IInternalUnknown : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE QueryInternalInterface( + REFIID riid, + void **ppv) = 0; + +}; +#else +typedef struct IInternalUnknownVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IInternalUnknown* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IInternalUnknown* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IInternalUnknown* This); + + /*** IInternalUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInternalInterface)( + IInternalUnknown* This, + REFIID riid, + void **ppv); + + END_INTERFACE +} IInternalUnknownVtbl; +interface IInternalUnknown { + CONST_VTBL IInternalUnknownVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IInternalUnknown_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IInternalUnknown_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IInternalUnknown_Release(This) (This)->lpVtbl->Release(This) +/*** IInternalUnknown methods ***/ +#define IInternalUnknown_QueryInternalInterface(This,riid,ppv) (This)->lpVtbl->QueryInternalInterface(This,riid,ppv) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IInternalUnknown_QueryInternalInterface_Proxy( + IInternalUnknown* This, + REFIID riid, + void **ppv); +void __RPC_STUB IInternalUnknown_QueryInternalInterface_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IInternalUnknown_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IEnumUnknown interface + */ +#ifndef __IEnumUnknown_INTERFACE_DEFINED__ +#define __IEnumUnknown_INTERFACE_DEFINED__ + +typedef IEnumUnknown *LPENUMUNKNOWN; +DEFINE_GUID(IID_IEnumUnknown, 0x00000100, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IEnumUnknown : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Next( + ULONG celt, + IUnknown **rgelt, + ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + IEnumUnknown **ppenum) = 0; + +}; +#else +typedef struct IEnumUnknownVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IEnumUnknown* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IEnumUnknown* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IEnumUnknown* This); + + /*** IEnumUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *Next)( + IEnumUnknown* This, + ULONG celt, + IUnknown **rgelt, + ULONG *pceltFetched); + + HRESULT (STDMETHODCALLTYPE *Skip)( + IEnumUnknown* This, + ULONG celt); + + HRESULT (STDMETHODCALLTYPE *Reset)( + IEnumUnknown* This); + + HRESULT (STDMETHODCALLTYPE *Clone)( + IEnumUnknown* This, + IEnumUnknown **ppenum); + + END_INTERFACE +} IEnumUnknownVtbl; +interface IEnumUnknown { + CONST_VTBL IEnumUnknownVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IEnumUnknown_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IEnumUnknown_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IEnumUnknown_Release(This) (This)->lpVtbl->Release(This) +/*** IEnumUnknown methods ***/ +#define IEnumUnknown_Next(This,celt,rgelt,pceltFetched) (This)->lpVtbl->Next(This,celt,rgelt,pceltFetched) +#define IEnumUnknown_Skip(This,celt) (This)->lpVtbl->Skip(This,celt) +#define IEnumUnknown_Reset(This) (This)->lpVtbl->Reset(This) +#define IEnumUnknown_Clone(This,ppenum) (This)->lpVtbl->Clone(This,ppenum) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IEnumUnknown_RemoteNext_Proxy( + IEnumUnknown* This, + ULONG celt, + IUnknown **rgelt, + ULONG *pceltFetched); +void __RPC_STUB IEnumUnknown_RemoteNext_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumUnknown_Skip_Proxy( + IEnumUnknown* This, + ULONG celt); +void __RPC_STUB IEnumUnknown_Skip_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumUnknown_Reset_Proxy( + IEnumUnknown* This); +void __RPC_STUB IEnumUnknown_Reset_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumUnknown_Clone_Proxy( + IEnumUnknown* This, + IEnumUnknown **ppenum); +void __RPC_STUB IEnumUnknown_Clone_Stub( + IRpcStubBuffer* This, + 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); + +#endif /* __IEnumUnknown_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * ISurrogate interface + */ +#ifndef __ISurrogate_INTERFACE_DEFINED__ +#define __ISurrogate_INTERFACE_DEFINED__ + +typedef ISurrogate *LPSURROGATE; +DEFINE_GUID(IID_ISurrogate, 0x00000022, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface ISurrogate : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE LoadDllServer( + REFCLSID Clsid) = 0; + + virtual HRESULT STDMETHODCALLTYPE FreeSurrogate( + ) = 0; + +}; +#else +typedef struct ISurrogateVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ISurrogate* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ISurrogate* This); + + ULONG (STDMETHODCALLTYPE *Release)( + ISurrogate* This); + + /*** ISurrogate methods ***/ + HRESULT (STDMETHODCALLTYPE *LoadDllServer)( + ISurrogate* This, + REFCLSID Clsid); + + HRESULT (STDMETHODCALLTYPE *FreeSurrogate)( + ISurrogate* This); + + END_INTERFACE +} ISurrogateVtbl; +interface ISurrogate { + CONST_VTBL ISurrogateVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define ISurrogate_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define ISurrogate_AddRef(This) (This)->lpVtbl->AddRef(This) +#define ISurrogate_Release(This) (This)->lpVtbl->Release(This) +/*** ISurrogate methods ***/ +#define ISurrogate_LoadDllServer(This,Clsid) (This)->lpVtbl->LoadDllServer(This,Clsid) +#define ISurrogate_FreeSurrogate(This) (This)->lpVtbl->FreeSurrogate(This) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE ISurrogate_LoadDllServer_Proxy( + ISurrogate* This, + REFCLSID Clsid); +void __RPC_STUB ISurrogate_LoadDllServer_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE ISurrogate_FreeSurrogate_Proxy( + ISurrogate* This); +void __RPC_STUB ISurrogate_FreeSurrogate_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __ISurrogate_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IGlobalInterfaceTable interface + */ +#ifndef __IGlobalInterfaceTable_INTERFACE_DEFINED__ +#define __IGlobalInterfaceTable_INTERFACE_DEFINED__ + +typedef IGlobalInterfaceTable *LPGLOBALINTERFACETABLE; +DEFINE_GUID(IID_IGlobalInterfaceTable, 0x00000146, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IGlobalInterfaceTable : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE RegisterInterfaceInGlobal( + IUnknown *pUnk, + REFIID riid, + DWORD *pdwCookie) = 0; + + virtual HRESULT STDMETHODCALLTYPE RevokeInterfaceFromGlobal( + DWORD dwCookie) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInterfaceFromGlobal( + DWORD dwCookie, + REFIID riid, + void **ppv) = 0; + +}; +#else +typedef struct IGlobalInterfaceTableVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IGlobalInterfaceTable* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IGlobalInterfaceTable* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IGlobalInterfaceTable* This); + + /*** IGlobalInterfaceTable methods ***/ + HRESULT (STDMETHODCALLTYPE *RegisterInterfaceInGlobal)( + IGlobalInterfaceTable* This, + IUnknown *pUnk, + REFIID riid, + DWORD *pdwCookie); + + HRESULT (STDMETHODCALLTYPE *RevokeInterfaceFromGlobal)( + IGlobalInterfaceTable* This, + DWORD dwCookie); + + HRESULT (STDMETHODCALLTYPE *GetInterfaceFromGlobal)( + IGlobalInterfaceTable* This, + DWORD dwCookie, + REFIID riid, + void **ppv); + + END_INTERFACE +} IGlobalInterfaceTableVtbl; +interface IGlobalInterfaceTable { + CONST_VTBL IGlobalInterfaceTableVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IGlobalInterfaceTable_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IGlobalInterfaceTable_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IGlobalInterfaceTable_Release(This) (This)->lpVtbl->Release(This) +/*** IGlobalInterfaceTable methods ***/ +#define IGlobalInterfaceTable_RegisterInterfaceInGlobal(This,pUnk,riid,pdwCookie) (This)->lpVtbl->RegisterInterfaceInGlobal(This,pUnk,riid,pdwCookie) +#define IGlobalInterfaceTable_RevokeInterfaceFromGlobal(This,dwCookie) (This)->lpVtbl->RevokeInterfaceFromGlobal(This,dwCookie) +#define IGlobalInterfaceTable_GetInterfaceFromGlobal(This,dwCookie,riid,ppv) (This)->lpVtbl->GetInterfaceFromGlobal(This,dwCookie,riid,ppv) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IGlobalInterfaceTable_RegisterInterfaceInGlobal_Proxy( + IGlobalInterfaceTable* This, + IUnknown *pUnk, + REFIID riid, + DWORD *pdwCookie); +void __RPC_STUB IGlobalInterfaceTable_RegisterInterfaceInGlobal_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IGlobalInterfaceTable_RevokeInterfaceFromGlobal_Proxy( + IGlobalInterfaceTable* This, + DWORD dwCookie); +void __RPC_STUB IGlobalInterfaceTable_RevokeInterfaceFromGlobal_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IGlobalInterfaceTable_GetInterfaceFromGlobal_Proxy( + IGlobalInterfaceTable* This, + DWORD dwCookie, + REFIID riid, + void **ppv); +void __RPC_STUB IGlobalInterfaceTable_GetInterfaceFromGlobal_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IGlobalInterfaceTable_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IBindCtx interface + */ +#ifndef __IBindCtx_INTERFACE_DEFINED__ +#define __IBindCtx_INTERFACE_DEFINED__ + +typedef IBindCtx *LPBINDCTX; +typedef IBindCtx *LPBC; +typedef struct tagBIND_OPTS { + DWORD cbStruct; + DWORD grfFlags; + DWORD grfMode; + DWORD dwTickCountDeadline; +} BIND_OPTS; +typedef struct tagBIND_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; +typedef struct tagBIND_OPTS2 *LPBIND_OPTS2; +typedef enum tagBIND_FLAGS { + BIND_MAYBOTHERUSER = 1, + BIND_JUSTTESTEXISTENCE = 2 +} BIND_FLAGS; +DEFINE_GUID(IID_IBindCtx, 0x0000000e, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IBindCtx : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE RegisterObjectBound( + IUnknown *punk) = 0; + + virtual HRESULT STDMETHODCALLTYPE RevokeObjectBound( + IUnknown *punk) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReleaseBoundObjects( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetBindOptions( + BIND_OPTS *pbindopts) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBindOptions( + BIND_OPTS *pbindopts) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRunningObjectTable( + IRunningObjectTable **pprot) = 0; + + virtual HRESULT STDMETHODCALLTYPE RegisterObjectParam( + LPOLESTR pszKey, + IUnknown *punk) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetObjectParam( + LPOLESTR pszKey, + IUnknown **ppunk) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumObjectParam( + IEnumString **ppenum) = 0; + + virtual HRESULT STDMETHODCALLTYPE RevokeObjectParam( + LPOLESTR pszKey) = 0; + +}; +#else +typedef struct IBindCtxVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IBindCtx* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IBindCtx* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IBindCtx* This); + + /*** IBindCtx methods ***/ + HRESULT (STDMETHODCALLTYPE *RegisterObjectBound)( + IBindCtx* This, + IUnknown *punk); + + HRESULT (STDMETHODCALLTYPE *RevokeObjectBound)( + IBindCtx* This, + IUnknown *punk); + + HRESULT (STDMETHODCALLTYPE *ReleaseBoundObjects)( + IBindCtx* This); + + HRESULT (STDMETHODCALLTYPE *SetBindOptions)( + IBindCtx* This, + BIND_OPTS *pbindopts); + + HRESULT (STDMETHODCALLTYPE *GetBindOptions)( + IBindCtx* This, + BIND_OPTS *pbindopts); + + HRESULT (STDMETHODCALLTYPE *GetRunningObjectTable)( + IBindCtx* This, + IRunningObjectTable **pprot); + + HRESULT (STDMETHODCALLTYPE *RegisterObjectParam)( + IBindCtx* This, + LPOLESTR pszKey, + IUnknown *punk); + + HRESULT (STDMETHODCALLTYPE *GetObjectParam)( + IBindCtx* This, + LPOLESTR pszKey, + IUnknown **ppunk); + + HRESULT (STDMETHODCALLTYPE *EnumObjectParam)( + IBindCtx* This, + IEnumString **ppenum); + + HRESULT (STDMETHODCALLTYPE *RevokeObjectParam)( + IBindCtx* This, + LPOLESTR pszKey); + + END_INTERFACE +} IBindCtxVtbl; +interface IBindCtx { + CONST_VTBL IBindCtxVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IBindCtx_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IBindCtx_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IBindCtx_Release(This) (This)->lpVtbl->Release(This) +/*** IBindCtx methods ***/ +#define IBindCtx_RegisterObjectBound(This,punk) (This)->lpVtbl->RegisterObjectBound(This,punk) +#define IBindCtx_RevokeObjectBound(This,punk) (This)->lpVtbl->RevokeObjectBound(This,punk) +#define IBindCtx_ReleaseBoundObjects(This) (This)->lpVtbl->ReleaseBoundObjects(This) +#define IBindCtx_SetBindOptions(This,pbindopts) (This)->lpVtbl->SetBindOptions(This,pbindopts) +#define IBindCtx_GetBindOptions(This,pbindopts) (This)->lpVtbl->GetBindOptions(This,pbindopts) +#define IBindCtx_GetRunningObjectTable(This,pprot) (This)->lpVtbl->GetRunningObjectTable(This,pprot) +#define IBindCtx_RegisterObjectParam(This,pszKey,punk) (This)->lpVtbl->RegisterObjectParam(This,pszKey,punk) +#define IBindCtx_GetObjectParam(This,pszKey,ppunk) (This)->lpVtbl->GetObjectParam(This,pszKey,ppunk) +#define IBindCtx_EnumObjectParam(This,ppenum) (This)->lpVtbl->EnumObjectParam(This,ppenum) +#define IBindCtx_RevokeObjectParam(This,pszKey) (This)->lpVtbl->RevokeObjectParam(This,pszKey) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IBindCtx_RegisterObjectBound_Proxy( + IBindCtx* This, + IUnknown *punk); +void __RPC_STUB IBindCtx_RegisterObjectBound_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IBindCtx_RevokeObjectBound_Proxy( + IBindCtx* This, + IUnknown *punk); +void __RPC_STUB IBindCtx_RevokeObjectBound_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IBindCtx_ReleaseBoundObjects_Proxy( + IBindCtx* This); +void __RPC_STUB IBindCtx_ReleaseBoundObjects_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IBindCtx_RemoteSetBindOptions_Proxy( + IBindCtx* This, + BIND_OPTS2 *pbindopts); +void __RPC_STUB IBindCtx_RemoteSetBindOptions_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IBindCtx_RemoteGetBindOptions_Proxy( + IBindCtx* This, + BIND_OPTS2 *pbindopts); +void __RPC_STUB IBindCtx_RemoteGetBindOptions_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IBindCtx_GetRunningObjectTable_Proxy( + IBindCtx* This, + IRunningObjectTable **pprot); +void __RPC_STUB IBindCtx_GetRunningObjectTable_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IBindCtx_RegisterObjectParam_Proxy( + IBindCtx* This, + LPOLESTR pszKey, + IUnknown *punk); +void __RPC_STUB IBindCtx_RegisterObjectParam_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IBindCtx_GetObjectParam_Proxy( + IBindCtx* This, + LPOLESTR pszKey, + IUnknown **ppunk); +void __RPC_STUB IBindCtx_GetObjectParam_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IBindCtx_EnumObjectParam_Proxy( + IBindCtx* This, + IEnumString **ppenum); +void __RPC_STUB IBindCtx_EnumObjectParam_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IBindCtx_RevokeObjectParam_Proxy( + IBindCtx* This, + LPOLESTR pszKey); +void __RPC_STUB IBindCtx_RevokeObjectParam_Stub( + IRpcStubBuffer* This, + 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_GetBindOptions_Proxy( + IBindCtx* This, + BIND_OPTS *pbindopts); +HRESULT __RPC_STUB IBindCtx_GetBindOptions_Stub( + IBindCtx* This, + BIND_OPTS2 *pbindopts); + +#endif /* __IBindCtx_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IEnumMoniker interface + */ +#ifndef __IEnumMoniker_INTERFACE_DEFINED__ +#define __IEnumMoniker_INTERFACE_DEFINED__ + +typedef IEnumMoniker *LPENUMMONIKER; +DEFINE_GUID(IID_IEnumMoniker, 0x00000102, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IEnumMoniker : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Next( + ULONG celt, + IMoniker **rgelt, + ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + IEnumMoniker **ppenum) = 0; + +}; +#else +typedef struct IEnumMonikerVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IEnumMoniker* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IEnumMoniker* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IEnumMoniker* This); + + /*** IEnumMoniker methods ***/ + HRESULT (STDMETHODCALLTYPE *Next)( + IEnumMoniker* This, + ULONG celt, + IMoniker **rgelt, + ULONG *pceltFetched); + + HRESULT (STDMETHODCALLTYPE *Skip)( + IEnumMoniker* This, + ULONG celt); + + HRESULT (STDMETHODCALLTYPE *Reset)( + IEnumMoniker* This); + + HRESULT (STDMETHODCALLTYPE *Clone)( + IEnumMoniker* This, + IEnumMoniker **ppenum); + + END_INTERFACE +} IEnumMonikerVtbl; +interface IEnumMoniker { + CONST_VTBL IEnumMonikerVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IEnumMoniker_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IEnumMoniker_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IEnumMoniker_Release(This) (This)->lpVtbl->Release(This) +/*** IEnumMoniker methods ***/ +#define IEnumMoniker_Next(This,celt,rgelt,pceltFetched) (This)->lpVtbl->Next(This,celt,rgelt,pceltFetched) +#define IEnumMoniker_Skip(This,celt) (This)->lpVtbl->Skip(This,celt) +#define IEnumMoniker_Reset(This) (This)->lpVtbl->Reset(This) +#define IEnumMoniker_Clone(This,ppenum) (This)->lpVtbl->Clone(This,ppenum) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IEnumMoniker_RemoteNext_Proxy( + IEnumMoniker* This, + ULONG celt, + IMoniker **rgelt, + ULONG *pceltFetched); +void __RPC_STUB IEnumMoniker_RemoteNext_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumMoniker_Skip_Proxy( + IEnumMoniker* This, + ULONG celt); +void __RPC_STUB IEnumMoniker_Skip_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumMoniker_Reset_Proxy( + IEnumMoniker* This); +void __RPC_STUB IEnumMoniker_Reset_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumMoniker_Clone_Proxy( + IEnumMoniker* This, + IEnumMoniker **ppenum); +void __RPC_STUB IEnumMoniker_Clone_Stub( + IRpcStubBuffer* This, + 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); + +#endif /* __IEnumMoniker_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IRunnableObject interface + */ +#ifndef __IRunnableObject_INTERFACE_DEFINED__ +#define __IRunnableObject_INTERFACE_DEFINED__ + +typedef IRunnableObject *LPRUNNABLEOBJECT; +DEFINE_GUID(IID_IRunnableObject, 0x00000126, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IRunnableObject : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetRunningClass( + LPCLSID lpClsid) = 0; + + virtual HRESULT STDMETHODCALLTYPE Run( + LPBINDCTX pbc) = 0; + + virtual BOOL STDMETHODCALLTYPE IsRunning( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE LockRunning( + BOOL fLock, + BOOL fLastUnlockCloses) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetContainedObject( + BOOL fContained) = 0; + +}; +#else +typedef struct IRunnableObjectVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IRunnableObject* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IRunnableObject* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IRunnableObject* This); + + /*** IRunnableObject methods ***/ + HRESULT (STDMETHODCALLTYPE *GetRunningClass)( + IRunnableObject* This, + LPCLSID lpClsid); + + HRESULT (STDMETHODCALLTYPE *Run)( + IRunnableObject* This, + LPBINDCTX pbc); + + BOOL (STDMETHODCALLTYPE *IsRunning)( + IRunnableObject* This); + + HRESULT (STDMETHODCALLTYPE *LockRunning)( + IRunnableObject* This, + BOOL fLock, + BOOL fLastUnlockCloses); + + HRESULT (STDMETHODCALLTYPE *SetContainedObject)( + IRunnableObject* This, + BOOL fContained); + + END_INTERFACE +} IRunnableObjectVtbl; +interface IRunnableObject { + CONST_VTBL IRunnableObjectVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IRunnableObject_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IRunnableObject_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IRunnableObject_Release(This) (This)->lpVtbl->Release(This) +/*** IRunnableObject methods ***/ +#define IRunnableObject_GetRunningClass(This,lpClsid) (This)->lpVtbl->GetRunningClass(This,lpClsid) +#define IRunnableObject_Run(This,pbc) (This)->lpVtbl->Run(This,pbc) +#define IRunnableObject_IsRunning(This) (This)->lpVtbl->IsRunning(This) +#define IRunnableObject_LockRunning(This,fLock,fLastUnlockCloses) (This)->lpVtbl->LockRunning(This,fLock,fLastUnlockCloses) +#define IRunnableObject_SetContainedObject(This,fContained) (This)->lpVtbl->SetContainedObject(This,fContained) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IRunnableObject_GetRunningClass_Proxy( + IRunnableObject* This, + LPCLSID lpClsid); +void __RPC_STUB IRunnableObject_GetRunningClass_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRunnableObject_Run_Proxy( + IRunnableObject* This, + LPBINDCTX pbc); +void __RPC_STUB IRunnableObject_Run_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRunnableObject_RemoteIsRunning_Proxy( + IRunnableObject* This); +void __RPC_STUB IRunnableObject_RemoteIsRunning_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRunnableObject_LockRunning_Proxy( + IRunnableObject* This, + BOOL fLock, + BOOL fLastUnlockCloses); +void __RPC_STUB IRunnableObject_LockRunning_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRunnableObject_SetContainedObject_Proxy( + IRunnableObject* This, + BOOL fContained); +void __RPC_STUB IRunnableObject_SetContainedObject_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +BOOL CALLBACK IRunnableObject_IsRunning_Proxy( + IRunnableObject* This); +HRESULT __RPC_STUB IRunnableObject_IsRunning_Stub( + IRunnableObject* This); + +#endif /* __IRunnableObject_INTERFACE_DEFINED__ */ + +#ifdef WINE_NO_UNICODE_MACROS +#undef GetObject +#endif +/***************************************************************************** + * IRunningObjectTable interface + */ +#ifndef __IRunningObjectTable_INTERFACE_DEFINED__ +#define __IRunningObjectTable_INTERFACE_DEFINED__ + +typedef IRunningObjectTable *LPRUNNINGOBJECTTABLE; +DEFINE_GUID(IID_IRunningObjectTable, 0x00000010, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IRunningObjectTable : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Register( + DWORD grfFlags, + IUnknown *punkObject, + IMoniker *pmkObjectName, + DWORD *pdwRegister) = 0; + + virtual HRESULT STDMETHODCALLTYPE Revoke( + DWORD dwRegister) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsRunning( + IMoniker *pmkObjectName) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetObject( + IMoniker *pmkObjectName, + IUnknown **ppunkObject) = 0; + + virtual HRESULT STDMETHODCALLTYPE NoteChangeTime( + DWORD dwRegister, + FILETIME *pfiletime) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimeOfLastChange( + IMoniker *pmkObjectName, + FILETIME *pfiletime) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumRunning( + IEnumMoniker **ppenumMoniker) = 0; + +}; +#else +typedef struct IRunningObjectTableVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IRunningObjectTable* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IRunningObjectTable* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IRunningObjectTable* This); + + /*** IRunningObjectTable methods ***/ + HRESULT (STDMETHODCALLTYPE *Register)( + IRunningObjectTable* This, + DWORD grfFlags, + IUnknown *punkObject, + IMoniker *pmkObjectName, + DWORD *pdwRegister); + + HRESULT (STDMETHODCALLTYPE *Revoke)( + IRunningObjectTable* This, + DWORD dwRegister); + + HRESULT (STDMETHODCALLTYPE *IsRunning)( + IRunningObjectTable* This, + IMoniker *pmkObjectName); + + HRESULT (STDMETHODCALLTYPE *GetObject)( + IRunningObjectTable* This, + IMoniker *pmkObjectName, + IUnknown **ppunkObject); + + HRESULT (STDMETHODCALLTYPE *NoteChangeTime)( + IRunningObjectTable* This, + DWORD dwRegister, + FILETIME *pfiletime); + + HRESULT (STDMETHODCALLTYPE *GetTimeOfLastChange)( + IRunningObjectTable* This, + IMoniker *pmkObjectName, + FILETIME *pfiletime); + + HRESULT (STDMETHODCALLTYPE *EnumRunning)( + IRunningObjectTable* This, + IEnumMoniker **ppenumMoniker); + + END_INTERFACE +} IRunningObjectTableVtbl; +interface IRunningObjectTable { + CONST_VTBL IRunningObjectTableVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IRunningObjectTable_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IRunningObjectTable_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IRunningObjectTable_Release(This) (This)->lpVtbl->Release(This) +/*** IRunningObjectTable methods ***/ +#define IRunningObjectTable_Register(This,grfFlags,punkObject,pmkObjectName,pdwRegister) (This)->lpVtbl->Register(This,grfFlags,punkObject,pmkObjectName,pdwRegister) +#define IRunningObjectTable_Revoke(This,dwRegister) (This)->lpVtbl->Revoke(This,dwRegister) +#define IRunningObjectTable_IsRunning(This,pmkObjectName) (This)->lpVtbl->IsRunning(This,pmkObjectName) +#define IRunningObjectTable_GetObject(This,pmkObjectName,ppunkObject) (This)->lpVtbl->GetObject(This,pmkObjectName,ppunkObject) +#define IRunningObjectTable_NoteChangeTime(This,dwRegister,pfiletime) (This)->lpVtbl->NoteChangeTime(This,dwRegister,pfiletime) +#define IRunningObjectTable_GetTimeOfLastChange(This,pmkObjectName,pfiletime) (This)->lpVtbl->GetTimeOfLastChange(This,pmkObjectName,pfiletime) +#define IRunningObjectTable_EnumRunning(This,ppenumMoniker) (This)->lpVtbl->EnumRunning(This,ppenumMoniker) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IRunningObjectTable_Register_Proxy( + IRunningObjectTable* This, + DWORD grfFlags, + IUnknown *punkObject, + IMoniker *pmkObjectName, + DWORD *pdwRegister); +void __RPC_STUB IRunningObjectTable_Register_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRunningObjectTable_Revoke_Proxy( + IRunningObjectTable* This, + DWORD dwRegister); +void __RPC_STUB IRunningObjectTable_Revoke_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRunningObjectTable_IsRunning_Proxy( + IRunningObjectTable* This, + IMoniker *pmkObjectName); +void __RPC_STUB IRunningObjectTable_IsRunning_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRunningObjectTable_GetObject_Proxy( + IRunningObjectTable* This, + IMoniker *pmkObjectName, + IUnknown **ppunkObject); +void __RPC_STUB IRunningObjectTable_GetObject_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRunningObjectTable_NoteChangeTime_Proxy( + IRunningObjectTable* This, + DWORD dwRegister, + FILETIME *pfiletime); +void __RPC_STUB IRunningObjectTable_NoteChangeTime_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRunningObjectTable_GetTimeOfLastChange_Proxy( + IRunningObjectTable* This, + IMoniker *pmkObjectName, + FILETIME *pfiletime); +void __RPC_STUB IRunningObjectTable_GetTimeOfLastChange_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRunningObjectTable_EnumRunning_Proxy( + IRunningObjectTable* This, + IEnumMoniker **ppenumMoniker); +void __RPC_STUB IRunningObjectTable_EnumRunning_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IRunningObjectTable_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IPersist interface + */ +#ifndef __IPersist_INTERFACE_DEFINED__ +#define __IPersist_INTERFACE_DEFINED__ + +typedef IPersist *LPPERSIST; +DEFINE_GUID(IID_IPersist, 0x0000010c, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IPersist : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetClassID( + CLSID *pClassID) = 0; + +}; +#else +typedef struct IPersistVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPersist* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPersist* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPersist* This); + + /*** IPersist methods ***/ + HRESULT (STDMETHODCALLTYPE *GetClassID)( + IPersist* This, + CLSID *pClassID); + + END_INTERFACE +} IPersistVtbl; +interface IPersist { + CONST_VTBL IPersistVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IPersist_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IPersist_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IPersist_Release(This) (This)->lpVtbl->Release(This) +/*** IPersist methods ***/ +#define IPersist_GetClassID(This,pClassID) (This)->lpVtbl->GetClassID(This,pClassID) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IPersist_GetClassID_Proxy( + IPersist* This, + CLSID *pClassID); +void __RPC_STUB IPersist_GetClassID_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPersist_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IPersistStream interface + */ +#ifndef __IPersistStream_INTERFACE_DEFINED__ +#define __IPersistStream_INTERFACE_DEFINED__ + +typedef IPersistStream *LPPERSISTSTREAM; +DEFINE_GUID(IID_IPersistStream, 0x00000109, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IPersistStream : public IPersist +{ + virtual HRESULT STDMETHODCALLTYPE IsDirty( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Load( + IStream *pStm) = 0; + + virtual HRESULT STDMETHODCALLTYPE Save( + IStream *pStm, + BOOL fClearDirty) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSizeMax( + ULARGE_INTEGER *pcbSize) = 0; + +}; +#else +typedef struct IPersistStreamVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPersistStream* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPersistStream* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPersistStream* This); + + /*** IPersist methods ***/ + HRESULT (STDMETHODCALLTYPE *GetClassID)( + IPersistStream* This, + CLSID *pClassID); + + /*** IPersistStream methods ***/ + HRESULT (STDMETHODCALLTYPE *IsDirty)( + IPersistStream* This); + + HRESULT (STDMETHODCALLTYPE *Load)( + IPersistStream* This, + IStream *pStm); + + HRESULT (STDMETHODCALLTYPE *Save)( + IPersistStream* This, + IStream *pStm, + BOOL fClearDirty); + + HRESULT (STDMETHODCALLTYPE *GetSizeMax)( + IPersistStream* This, + ULARGE_INTEGER *pcbSize); + + END_INTERFACE +} IPersistStreamVtbl; +interface IPersistStream { + CONST_VTBL IPersistStreamVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IPersistStream_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IPersistStream_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IPersistStream_Release(This) (This)->lpVtbl->Release(This) +/*** IPersist methods ***/ +#define IPersistStream_GetClassID(This,pClassID) (This)->lpVtbl->GetClassID(This,pClassID) +/*** IPersistStream methods ***/ +#define IPersistStream_IsDirty(This) (This)->lpVtbl->IsDirty(This) +#define IPersistStream_Load(This,pStm) (This)->lpVtbl->Load(This,pStm) +#define IPersistStream_Save(This,pStm,fClearDirty) (This)->lpVtbl->Save(This,pStm,fClearDirty) +#define IPersistStream_GetSizeMax(This,pcbSize) (This)->lpVtbl->GetSizeMax(This,pcbSize) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IPersistStream_IsDirty_Proxy( + IPersistStream* This); +void __RPC_STUB IPersistStream_IsDirty_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPersistStream_Load_Proxy( + IPersistStream* This, + IStream *pStm); +void __RPC_STUB IPersistStream_Load_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPersistStream_Save_Proxy( + IPersistStream* This, + IStream *pStm, + BOOL fClearDirty); +void __RPC_STUB IPersistStream_Save_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPersistStream_GetSizeMax_Proxy( + IPersistStream* This, + ULARGE_INTEGER *pcbSize); +void __RPC_STUB IPersistStream_GetSizeMax_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPersistStream_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IMoniker interface + */ +#ifndef __IMoniker_INTERFACE_DEFINED__ +#define __IMoniker_INTERFACE_DEFINED__ + +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; +DEFINE_GUID(IID_IMoniker, 0x0000000f, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IMoniker : public IPersistStream +{ + virtual HRESULT STDMETHODCALLTYPE BindToObject( + IBindCtx *pbc, + IMoniker *pmkToLeft, + REFIID riidResult, + void **ppvResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE BindToStorage( + IBindCtx *pbc, + IMoniker *pmkToLeft, + REFIID riid, + void **ppvObj) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reduce( + IBindCtx *pbc, + DWORD dwReduceHowFar, + IMoniker **ppmkToLeft, + IMoniker **ppmkReduced) = 0; + + virtual HRESULT STDMETHODCALLTYPE ComposeWith( + IMoniker *pmkRight, + BOOL fOnlyIfNotGeneric, + IMoniker **ppmkComposite) = 0; + + virtual HRESULT STDMETHODCALLTYPE Enum( + BOOL fForward, + IEnumMoniker **ppenumMoniker) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsEqual( + IMoniker *pmkOtherMoniker) = 0; + + virtual HRESULT STDMETHODCALLTYPE Hash( + DWORD *pdwHash) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsRunning( + IBindCtx *pbc, + IMoniker *pmkToLeft, + IMoniker *pmkNewlyRunning) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimeOfLastChange( + IBindCtx *pbc, + IMoniker *pmkToLeft, + FILETIME *pFileTime) = 0; + + virtual HRESULT STDMETHODCALLTYPE Inverse( + IMoniker **ppmk) = 0; + + virtual HRESULT STDMETHODCALLTYPE CommonPrefixWith( + IMoniker *pmkOther, + IMoniker **ppmkPrefix) = 0; + + virtual HRESULT STDMETHODCALLTYPE RelativePathTo( + IMoniker *pmkOther, + IMoniker **ppmkRelPath) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayName( + IBindCtx *pbc, + IMoniker *pmkToLeft, + LPOLESTR *ppszDisplayName) = 0; + + virtual HRESULT STDMETHODCALLTYPE ParseDisplayName( + IBindCtx *pbc, + IMoniker *pmkToLeft, + LPOLESTR pszDisplayName, + ULONG *pchEaten, + IMoniker **ppmkOut) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsSystemMoniker( + DWORD *pdwMksys) = 0; + +}; +#else +typedef struct IMonikerVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IMoniker* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IMoniker* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IMoniker* This); + + /*** IPersist methods ***/ + HRESULT (STDMETHODCALLTYPE *GetClassID)( + IMoniker* This, + CLSID *pClassID); + + /*** IPersistStream methods ***/ + HRESULT (STDMETHODCALLTYPE *IsDirty)( + IMoniker* This); + + HRESULT (STDMETHODCALLTYPE *Load)( + IMoniker* This, + IStream *pStm); + + HRESULT (STDMETHODCALLTYPE *Save)( + IMoniker* This, + IStream *pStm, + BOOL fClearDirty); + + HRESULT (STDMETHODCALLTYPE *GetSizeMax)( + IMoniker* This, + ULARGE_INTEGER *pcbSize); + + /*** IMoniker methods ***/ + HRESULT (STDMETHODCALLTYPE *BindToObject)( + IMoniker* This, + IBindCtx *pbc, + IMoniker *pmkToLeft, + REFIID riidResult, + void **ppvResult); + + HRESULT (STDMETHODCALLTYPE *BindToStorage)( + IMoniker* This, + IBindCtx *pbc, + IMoniker *pmkToLeft, + REFIID riid, + void **ppvObj); + + HRESULT (STDMETHODCALLTYPE *Reduce)( + IMoniker* This, + IBindCtx *pbc, + DWORD dwReduceHowFar, + IMoniker **ppmkToLeft, + IMoniker **ppmkReduced); + + HRESULT (STDMETHODCALLTYPE *ComposeWith)( + IMoniker* This, + IMoniker *pmkRight, + BOOL fOnlyIfNotGeneric, + IMoniker **ppmkComposite); + + HRESULT (STDMETHODCALLTYPE *Enum)( + IMoniker* This, + BOOL fForward, + IEnumMoniker **ppenumMoniker); + + HRESULT (STDMETHODCALLTYPE *IsEqual)( + IMoniker* This, + IMoniker *pmkOtherMoniker); + + HRESULT (STDMETHODCALLTYPE *Hash)( + IMoniker* This, + DWORD *pdwHash); + + HRESULT (STDMETHODCALLTYPE *IsRunning)( + IMoniker* This, + IBindCtx *pbc, + IMoniker *pmkToLeft, + IMoniker *pmkNewlyRunning); + + HRESULT (STDMETHODCALLTYPE *GetTimeOfLastChange)( + IMoniker* This, + IBindCtx *pbc, + IMoniker *pmkToLeft, + FILETIME *pFileTime); + + HRESULT (STDMETHODCALLTYPE *Inverse)( + IMoniker* This, + IMoniker **ppmk); + + HRESULT (STDMETHODCALLTYPE *CommonPrefixWith)( + IMoniker* This, + IMoniker *pmkOther, + IMoniker **ppmkPrefix); + + HRESULT (STDMETHODCALLTYPE *RelativePathTo)( + IMoniker* This, + IMoniker *pmkOther, + IMoniker **ppmkRelPath); + + HRESULT (STDMETHODCALLTYPE *GetDisplayName)( + IMoniker* This, + IBindCtx *pbc, + IMoniker *pmkToLeft, + LPOLESTR *ppszDisplayName); + + HRESULT (STDMETHODCALLTYPE *ParseDisplayName)( + IMoniker* This, + IBindCtx *pbc, + IMoniker *pmkToLeft, + LPOLESTR pszDisplayName, + ULONG *pchEaten, + IMoniker **ppmkOut); + + HRESULT (STDMETHODCALLTYPE *IsSystemMoniker)( + IMoniker* This, + DWORD *pdwMksys); + + END_INTERFACE +} IMonikerVtbl; +interface IMoniker { + CONST_VTBL IMonikerVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IMoniker_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IMoniker_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IMoniker_Release(This) (This)->lpVtbl->Release(This) +/*** IPersist methods ***/ +#define IMoniker_GetClassID(This,pClassID) (This)->lpVtbl->GetClassID(This,pClassID) +/*** IPersistStream methods ***/ +#define IMoniker_IsDirty(This) (This)->lpVtbl->IsDirty(This) +#define IMoniker_Load(This,pStm) (This)->lpVtbl->Load(This,pStm) +#define IMoniker_Save(This,pStm,fClearDirty) (This)->lpVtbl->Save(This,pStm,fClearDirty) +#define IMoniker_GetSizeMax(This,pcbSize) (This)->lpVtbl->GetSizeMax(This,pcbSize) +/*** IMoniker methods ***/ +#define IMoniker_BindToObject(This,pbc,pmkToLeft,riidResult,ppvResult) (This)->lpVtbl->BindToObject(This,pbc,pmkToLeft,riidResult,ppvResult) +#define IMoniker_BindToStorage(This,pbc,pmkToLeft,riid,ppvObj) (This)->lpVtbl->BindToStorage(This,pbc,pmkToLeft,riid,ppvObj) +#define IMoniker_Reduce(This,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced) (This)->lpVtbl->Reduce(This,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced) +#define IMoniker_ComposeWith(This,pmkRight,fOnlyIfNotGeneric,ppmkComposite) (This)->lpVtbl->ComposeWith(This,pmkRight,fOnlyIfNotGeneric,ppmkComposite) +#define IMoniker_Enum(This,fForward,ppenumMoniker) (This)->lpVtbl->Enum(This,fForward,ppenumMoniker) +#define IMoniker_IsEqual(This,pmkOtherMoniker) (This)->lpVtbl->IsEqual(This,pmkOtherMoniker) +#define IMoniker_Hash(This,pdwHash) (This)->lpVtbl->Hash(This,pdwHash) +#define IMoniker_IsRunning(This,pbc,pmkToLeft,pmkNewlyRunning) (This)->lpVtbl->IsRunning(This,pbc,pmkToLeft,pmkNewlyRunning) +#define IMoniker_GetTimeOfLastChange(This,pbc,pmkToLeft,pFileTime) (This)->lpVtbl->GetTimeOfLastChange(This,pbc,pmkToLeft,pFileTime) +#define IMoniker_Inverse(This,ppmk) (This)->lpVtbl->Inverse(This,ppmk) +#define IMoniker_CommonPrefixWith(This,pmkOther,ppmkPrefix) (This)->lpVtbl->CommonPrefixWith(This,pmkOther,ppmkPrefix) +#define IMoniker_RelativePathTo(This,pmkOther,ppmkRelPath) (This)->lpVtbl->RelativePathTo(This,pmkOther,ppmkRelPath) +#define IMoniker_GetDisplayName(This,pbc,pmkToLeft,ppszDisplayName) (This)->lpVtbl->GetDisplayName(This,pbc,pmkToLeft,ppszDisplayName) +#define IMoniker_ParseDisplayName(This,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut) (This)->lpVtbl->ParseDisplayName(This,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut) +#define IMoniker_IsSystemMoniker(This,pdwMksys) (This)->lpVtbl->IsSystemMoniker(This,pdwMksys) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IMoniker_RemoteBindToObject_Proxy( + IMoniker* This, + IBindCtx *pbc, + IMoniker *pmkToLeft, + REFIID riidResult, + IUnknown **ppvResult); +void __RPC_STUB IMoniker_RemoteBindToObject_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMoniker_RemoteBindToStorage_Proxy( + IMoniker* This, + IBindCtx *pbc, + IMoniker *pmkToLeft, + REFIID riid, + IUnknown **ppvObj); +void __RPC_STUB IMoniker_RemoteBindToStorage_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMoniker_Reduce_Proxy( + IMoniker* This, + IBindCtx *pbc, + DWORD dwReduceHowFar, + IMoniker **ppmkToLeft, + IMoniker **ppmkReduced); +void __RPC_STUB IMoniker_Reduce_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMoniker_ComposeWith_Proxy( + IMoniker* This, + IMoniker *pmkRight, + BOOL fOnlyIfNotGeneric, + IMoniker **ppmkComposite); +void __RPC_STUB IMoniker_ComposeWith_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMoniker_Enum_Proxy( + IMoniker* This, + BOOL fForward, + IEnumMoniker **ppenumMoniker); +void __RPC_STUB IMoniker_Enum_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMoniker_IsEqual_Proxy( + IMoniker* This, + IMoniker *pmkOtherMoniker); +void __RPC_STUB IMoniker_IsEqual_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMoniker_Hash_Proxy( + IMoniker* This, + DWORD *pdwHash); +void __RPC_STUB IMoniker_Hash_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMoniker_IsRunning_Proxy( + IMoniker* This, + IBindCtx *pbc, + IMoniker *pmkToLeft, + IMoniker *pmkNewlyRunning); +void __RPC_STUB IMoniker_IsRunning_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMoniker_GetTimeOfLastChange_Proxy( + IMoniker* This, + IBindCtx *pbc, + IMoniker *pmkToLeft, + FILETIME *pFileTime); +void __RPC_STUB IMoniker_GetTimeOfLastChange_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMoniker_Inverse_Proxy( + IMoniker* This, + IMoniker **ppmk); +void __RPC_STUB IMoniker_Inverse_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMoniker_CommonPrefixWith_Proxy( + IMoniker* This, + IMoniker *pmkOther, + IMoniker **ppmkPrefix); +void __RPC_STUB IMoniker_CommonPrefixWith_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMoniker_RelativePathTo_Proxy( + IMoniker* This, + IMoniker *pmkOther, + IMoniker **ppmkRelPath); +void __RPC_STUB IMoniker_RelativePathTo_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMoniker_GetDisplayName_Proxy( + IMoniker* This, + IBindCtx *pbc, + IMoniker *pmkToLeft, + LPOLESTR *ppszDisplayName); +void __RPC_STUB IMoniker_GetDisplayName_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMoniker_ParseDisplayName_Proxy( + IMoniker* This, + IBindCtx *pbc, + IMoniker *pmkToLeft, + LPOLESTR pszDisplayName, + ULONG *pchEaten, + IMoniker **ppmkOut); +void __RPC_STUB IMoniker_ParseDisplayName_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMoniker_IsSystemMoniker_Proxy( + IMoniker* This, + DWORD *pdwMksys); +void __RPC_STUB IMoniker_IsSystemMoniker_Stub( + IRpcStubBuffer* This, + 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_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); + +#endif /* __IMoniker_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IROTData interface + */ +#ifndef __IROTData_INTERFACE_DEFINED__ +#define __IROTData_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IROTData, 0xf29f6bc0, 0x5021, 0x11ce, 0xaa,0x15, 0x00,0x00,0x69,0x01,0x29,0x3f); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IROTData : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetComparisonData( + byte *pbData, + ULONG cbMax, + ULONG *pcbData) = 0; + +}; +#else +typedef struct IROTDataVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IROTData* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IROTData* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IROTData* This); + + /*** IROTData methods ***/ + HRESULT (STDMETHODCALLTYPE *GetComparisonData)( + IROTData* This, + byte *pbData, + ULONG cbMax, + ULONG *pcbData); + + END_INTERFACE +} IROTDataVtbl; +interface IROTData { + CONST_VTBL IROTDataVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IROTData_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IROTData_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IROTData_Release(This) (This)->lpVtbl->Release(This) +/*** IROTData methods ***/ +#define IROTData_GetComparisonData(This,pbData,cbMax,pcbData) (This)->lpVtbl->GetComparisonData(This,pbData,cbMax,pcbData) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IROTData_GetComparisonData_Proxy( + IROTData* This, + byte *pbData, + ULONG cbMax, + ULONG *pcbData); +void __RPC_STUB IROTData_GetComparisonData_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IROTData_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IEnumString interface + */ +#ifndef __IEnumString_INTERFACE_DEFINED__ +#define __IEnumString_INTERFACE_DEFINED__ + +typedef IEnumString *LPENUMSTRING; +DEFINE_GUID(IID_IEnumString, 0x00000101, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IEnumString : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Next( + ULONG celt, + LPOLESTR *rgelt, + ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + IEnumString **ppenum) = 0; + +}; +#else +typedef struct IEnumStringVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IEnumString* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IEnumString* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IEnumString* This); + + /*** IEnumString methods ***/ + HRESULT (STDMETHODCALLTYPE *Next)( + IEnumString* This, + ULONG celt, + LPOLESTR *rgelt, + ULONG *pceltFetched); + + HRESULT (STDMETHODCALLTYPE *Skip)( + IEnumString* This, + ULONG celt); + + HRESULT (STDMETHODCALLTYPE *Reset)( + IEnumString* This); + + HRESULT (STDMETHODCALLTYPE *Clone)( + IEnumString* This, + IEnumString **ppenum); + + END_INTERFACE +} IEnumStringVtbl; +interface IEnumString { + CONST_VTBL IEnumStringVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IEnumString_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IEnumString_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IEnumString_Release(This) (This)->lpVtbl->Release(This) +/*** IEnumString methods ***/ +#define IEnumString_Next(This,celt,rgelt,pceltFetched) (This)->lpVtbl->Next(This,celt,rgelt,pceltFetched) +#define IEnumString_Skip(This,celt) (This)->lpVtbl->Skip(This,celt) +#define IEnumString_Reset(This) (This)->lpVtbl->Reset(This) +#define IEnumString_Clone(This,ppenum) (This)->lpVtbl->Clone(This,ppenum) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IEnumString_RemoteNext_Proxy( + IEnumString* This, + ULONG celt, + LPOLESTR *rgelt, + ULONG *pceltFetched); +void __RPC_STUB IEnumString_RemoteNext_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumString_Skip_Proxy( + IEnumString* This, + ULONG celt); +void __RPC_STUB IEnumString_Skip_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumString_Reset_Proxy( + IEnumString* This); +void __RPC_STUB IEnumString_Reset_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumString_Clone_Proxy( + IEnumString* This, + IEnumString **ppenum); +void __RPC_STUB IEnumString_Clone_Stub( + IRpcStubBuffer* This, + 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); + +#endif /* __IEnumString_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IClassActivator interface + */ +#ifndef __IClassActivator_INTERFACE_DEFINED__ +#define __IClassActivator_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IClassActivator, 0x00000140, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IClassActivator : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetClassObject( + REFCLSID rclsid, + DWORD dwClassContext, + LCID locale, + REFIID riid, + void **ppv) = 0; + +}; +#else +typedef struct IClassActivatorVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IClassActivator* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IClassActivator* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IClassActivator* This); + + /*** IClassActivator methods ***/ + HRESULT (STDMETHODCALLTYPE *GetClassObject)( + IClassActivator* This, + REFCLSID rclsid, + DWORD dwClassContext, + LCID locale, + REFIID riid, + void **ppv); + + END_INTERFACE +} IClassActivatorVtbl; +interface IClassActivator { + CONST_VTBL IClassActivatorVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IClassActivator_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IClassActivator_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IClassActivator_Release(This) (This)->lpVtbl->Release(This) +/*** IClassActivator methods ***/ +#define IClassActivator_GetClassObject(This,rclsid,dwClassContext,locale,riid,ppv) (This)->lpVtbl->GetClassObject(This,rclsid,dwClassContext,locale,riid,ppv) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IClassActivator_GetClassObject_Proxy( + IClassActivator* This, + REFCLSID rclsid, + DWORD dwClassContext, + LCID locale, + REFIID riid, + void **ppv); +void __RPC_STUB IClassActivator_GetClassObject_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IClassActivator_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * ISequentialStream interface + */ +#ifndef __ISequentialStream_INTERFACE_DEFINED__ +#define __ISequentialStream_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_ISequentialStream, 0x0c733a30, 0x2a1c, 0x11ce, 0xad,0xe5, 0x00,0xaa,0x00,0x44,0x77,0x3d); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface ISequentialStream : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Read( + void *pv, + ULONG cb, + ULONG *pcbRead) = 0; + + virtual HRESULT STDMETHODCALLTYPE Write( + const void *pv, + ULONG cb, + ULONG *pcbWritten) = 0; + +}; +#else +typedef struct ISequentialStreamVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ISequentialStream* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ISequentialStream* This); + + ULONG (STDMETHODCALLTYPE *Release)( + ISequentialStream* This); + + /*** ISequentialStream methods ***/ + HRESULT (STDMETHODCALLTYPE *Read)( + ISequentialStream* This, + void *pv, + ULONG cb, + ULONG *pcbRead); + + HRESULT (STDMETHODCALLTYPE *Write)( + ISequentialStream* This, + const void *pv, + ULONG cb, + ULONG *pcbWritten); + + END_INTERFACE +} ISequentialStreamVtbl; +interface ISequentialStream { + CONST_VTBL ISequentialStreamVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define ISequentialStream_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define ISequentialStream_AddRef(This) (This)->lpVtbl->AddRef(This) +#define ISequentialStream_Release(This) (This)->lpVtbl->Release(This) +/*** ISequentialStream methods ***/ +#define ISequentialStream_Read(This,pv,cb,pcbRead) (This)->lpVtbl->Read(This,pv,cb,pcbRead) +#define ISequentialStream_Write(This,pv,cb,pcbWritten) (This)->lpVtbl->Write(This,pv,cb,pcbWritten) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE ISequentialStream_RemoteRead_Proxy( + ISequentialStream* This, + byte *pv, + ULONG cb, + ULONG *pcbRead); +void __RPC_STUB ISequentialStream_RemoteRead_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE ISequentialStream_RemoteWrite_Proxy( + ISequentialStream* This, + const byte *pv, + ULONG cb, + ULONG *pcbWritten); +void __RPC_STUB ISequentialStream_RemoteWrite_Stub( + IRpcStubBuffer* This, + 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_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); + +#endif /* __ISequentialStream_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IStream interface + */ +#ifndef __IStream_INTERFACE_DEFINED__ +#define __IStream_INTERFACE_DEFINED__ + +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; +DEFINE_GUID(IID_IStream, 0x0000000c, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IStream : public ISequentialStream +{ + virtual HRESULT STDMETHODCALLTYPE Seek( + LARGE_INTEGER dlibMove, + DWORD dwOrigin, + ULARGE_INTEGER *plibNewPosition) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSize( + ULARGE_INTEGER libNewSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE CopyTo( + IStream *pstm, + ULARGE_INTEGER cb, + ULARGE_INTEGER *pcbRead, + ULARGE_INTEGER *pcbWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE Commit( + DWORD grfCommitFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE Revert( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE LockRegion( + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnlockRegion( + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType) = 0; + + virtual HRESULT STDMETHODCALLTYPE Stat( + STATSTG *pstatstg, + DWORD grfStatFlag) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + IStream **ppstm) = 0; + +}; +#else +typedef struct IStreamVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IStream* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IStream* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IStream* This); + + /*** ISequentialStream methods ***/ + HRESULT (STDMETHODCALLTYPE *Read)( + IStream* This, + void *pv, + ULONG cb, + ULONG *pcbRead); + + HRESULT (STDMETHODCALLTYPE *Write)( + IStream* This, + const void *pv, + ULONG cb, + ULONG *pcbWritten); + + /*** IStream methods ***/ + HRESULT (STDMETHODCALLTYPE *Seek)( + IStream* This, + LARGE_INTEGER dlibMove, + DWORD dwOrigin, + ULARGE_INTEGER *plibNewPosition); + + HRESULT (STDMETHODCALLTYPE *SetSize)( + IStream* This, + ULARGE_INTEGER libNewSize); + + HRESULT (STDMETHODCALLTYPE *CopyTo)( + IStream* This, + IStream *pstm, + ULARGE_INTEGER cb, + ULARGE_INTEGER *pcbRead, + ULARGE_INTEGER *pcbWritten); + + HRESULT (STDMETHODCALLTYPE *Commit)( + IStream* This, + DWORD grfCommitFlags); + + HRESULT (STDMETHODCALLTYPE *Revert)( + IStream* This); + + HRESULT (STDMETHODCALLTYPE *LockRegion)( + IStream* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); + + HRESULT (STDMETHODCALLTYPE *UnlockRegion)( + IStream* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); + + HRESULT (STDMETHODCALLTYPE *Stat)( + IStream* This, + STATSTG *pstatstg, + DWORD grfStatFlag); + + HRESULT (STDMETHODCALLTYPE *Clone)( + IStream* This, + IStream **ppstm); + + END_INTERFACE +} IStreamVtbl; +interface IStream { + CONST_VTBL IStreamVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IStream_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IStream_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IStream_Release(This) (This)->lpVtbl->Release(This) +/*** ISequentialStream methods ***/ +#define IStream_Read(This,pv,cb,pcbRead) (This)->lpVtbl->Read(This,pv,cb,pcbRead) +#define IStream_Write(This,pv,cb,pcbWritten) (This)->lpVtbl->Write(This,pv,cb,pcbWritten) +/*** IStream methods ***/ +#define IStream_Seek(This,dlibMove,dwOrigin,plibNewPosition) (This)->lpVtbl->Seek(This,dlibMove,dwOrigin,plibNewPosition) +#define IStream_SetSize(This,libNewSize) (This)->lpVtbl->SetSize(This,libNewSize) +#define IStream_CopyTo(This,pstm,cb,pcbRead,pcbWritten) (This)->lpVtbl->CopyTo(This,pstm,cb,pcbRead,pcbWritten) +#define IStream_Commit(This,grfCommitFlags) (This)->lpVtbl->Commit(This,grfCommitFlags) +#define IStream_Revert(This) (This)->lpVtbl->Revert(This) +#define IStream_LockRegion(This,libOffset,cb,dwLockType) (This)->lpVtbl->LockRegion(This,libOffset,cb,dwLockType) +#define IStream_UnlockRegion(This,libOffset,cb,dwLockType) (This)->lpVtbl->UnlockRegion(This,libOffset,cb,dwLockType) +#define IStream_Stat(This,pstatstg,grfStatFlag) (This)->lpVtbl->Stat(This,pstatstg,grfStatFlag) +#define IStream_Clone(This,ppstm) (This)->lpVtbl->Clone(This,ppstm) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IStream_RemoteSeek_Proxy( + IStream* This, + LARGE_INTEGER dlibMove, + DWORD dwOrigin, + ULARGE_INTEGER *plibNewPosition); +void __RPC_STUB IStream_RemoteSeek_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStream_SetSize_Proxy( + IStream* This, + ULARGE_INTEGER libNewSize); +void __RPC_STUB IStream_SetSize_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStream_RemoteCopyTo_Proxy( + IStream* This, + IStream *pstm, + ULARGE_INTEGER cb, + ULARGE_INTEGER *pcbRead, + ULARGE_INTEGER *pcbWritten); +void __RPC_STUB IStream_RemoteCopyTo_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStream_Commit_Proxy( + IStream* This, + DWORD grfCommitFlags); +void __RPC_STUB IStream_Commit_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStream_Revert_Proxy( + IStream* This); +void __RPC_STUB IStream_Revert_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStream_LockRegion_Proxy( + IStream* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); +void __RPC_STUB IStream_LockRegion_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStream_UnlockRegion_Proxy( + IStream* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); +void __RPC_STUB IStream_UnlockRegion_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStream_Stat_Proxy( + IStream* This, + STATSTG *pstatstg, + DWORD grfStatFlag); +void __RPC_STUB IStream_Stat_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStream_Clone_Proxy( + IStream* This, + IStream **ppstm); +void __RPC_STUB IStream_Clone_Stub( + IRpcStubBuffer* This, + 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_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); + +#endif /* __IStream_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IEnumSTATSTG interface + */ +#ifndef __IEnumSTATSTG_INTERFACE_DEFINED__ +#define __IEnumSTATSTG_INTERFACE_DEFINED__ + +typedef IEnumSTATSTG *LPENUMSTATSTG; +DEFINE_GUID(IID_IEnumSTATSTG, 0x0000000d, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IEnumSTATSTG : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Next( + ULONG celt, + STATSTG *rgelt, + ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + IEnumSTATSTG **ppenum) = 0; + +}; +#else +typedef struct IEnumSTATSTGVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IEnumSTATSTG* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IEnumSTATSTG* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IEnumSTATSTG* This); + + /*** IEnumSTATSTG methods ***/ + HRESULT (STDMETHODCALLTYPE *Next)( + IEnumSTATSTG* This, + ULONG celt, + STATSTG *rgelt, + ULONG *pceltFetched); + + HRESULT (STDMETHODCALLTYPE *Skip)( + IEnumSTATSTG* This, + ULONG celt); + + HRESULT (STDMETHODCALLTYPE *Reset)( + IEnumSTATSTG* This); + + HRESULT (STDMETHODCALLTYPE *Clone)( + IEnumSTATSTG* This, + IEnumSTATSTG **ppenum); + + END_INTERFACE +} IEnumSTATSTGVtbl; +interface IEnumSTATSTG { + CONST_VTBL IEnumSTATSTGVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IEnumSTATSTG_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IEnumSTATSTG_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IEnumSTATSTG_Release(This) (This)->lpVtbl->Release(This) +/*** IEnumSTATSTG methods ***/ +#define IEnumSTATSTG_Next(This,celt,rgelt,pceltFetched) (This)->lpVtbl->Next(This,celt,rgelt,pceltFetched) +#define IEnumSTATSTG_Skip(This,celt) (This)->lpVtbl->Skip(This,celt) +#define IEnumSTATSTG_Reset(This) (This)->lpVtbl->Reset(This) +#define IEnumSTATSTG_Clone(This,ppenum) (This)->lpVtbl->Clone(This,ppenum) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IEnumSTATSTG_RemoteNext_Proxy( + IEnumSTATSTG* This, + ULONG celt, + STATSTG *rgelt, + ULONG *pceltFetched); +void __RPC_STUB IEnumSTATSTG_RemoteNext_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumSTATSTG_Skip_Proxy( + IEnumSTATSTG* This, + ULONG celt); +void __RPC_STUB IEnumSTATSTG_Skip_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumSTATSTG_Reset_Proxy( + IEnumSTATSTG* This); +void __RPC_STUB IEnumSTATSTG_Reset_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumSTATSTG_Clone_Proxy( + IEnumSTATSTG* This, + IEnumSTATSTG **ppenum); +void __RPC_STUB IEnumSTATSTG_Clone_Stub( + IRpcStubBuffer* This, + 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); + +#endif /* __IEnumSTATSTG_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IStorage interface + */ +#ifndef __IStorage_INTERFACE_DEFINED__ +#define __IStorage_INTERFACE_DEFINED__ + +typedef IStorage *LPSTORAGE; +typedef struct tagRemSNB { + ULONG ulCntStr; + ULONG ulCntChar; + OLECHAR rgString[1]; +} RemSNB; +typedef RemSNB *wireSNB; +typedef OLECHAR **SNB; +DEFINE_GUID(IID_IStorage, 0x0000000b, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IStorage : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE CreateStream( + LPCOLESTR pwcsName, + DWORD grfMode, + DWORD reserved1, + DWORD reserved2, + IStream **ppstm) = 0; + + virtual HRESULT STDMETHODCALLTYPE OpenStream( + LPCOLESTR pwcsName, + void *reserved1, + DWORD grfMode, + DWORD reserved2, + IStream **ppstm) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateStorage( + LPCOLESTR pwcsName, + DWORD grfMode, + DWORD dwStgFmt, + DWORD reserved2, + IStorage **ppstg) = 0; + + virtual HRESULT STDMETHODCALLTYPE OpenStorage( + LPCOLESTR pwcsName, + IStorage *pstgPriority, + DWORD grfMode, + SNB snbExclude, + DWORD reserved, + IStorage **ppstg) = 0; + + virtual HRESULT STDMETHODCALLTYPE CopyTo( + DWORD ciidExclude, + const IID *rgiidExclude, + SNB snbExclude, + IStorage *pstgDest) = 0; + + virtual HRESULT STDMETHODCALLTYPE MoveElementTo( + LPCOLESTR pwcsName, + IStorage *pstgDest, + LPCOLESTR pwcsNewName, + DWORD grfFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE Commit( + DWORD grfCommitFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE Revert( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumElements( + DWORD reserved1, + void *reserved2, + DWORD reserved3, + IEnumSTATSTG **ppenum) = 0; + + virtual HRESULT STDMETHODCALLTYPE DestroyElement( + LPCOLESTR pwcsName) = 0; + + virtual HRESULT STDMETHODCALLTYPE RenameElement( + LPCOLESTR pwcsOldName, + LPCOLESTR pwcsNewName) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetElementTimes( + LPCOLESTR pwcsName, + const FILETIME *pctime, + const FILETIME *patime, + const FILETIME *pmtime) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetClass( + REFCLSID clsid) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetStateBits( + DWORD grfStateBits, + DWORD grfMask) = 0; + + virtual HRESULT STDMETHODCALLTYPE Stat( + STATSTG *pstatstg, + DWORD grfStatFlag) = 0; + +}; +#else +typedef struct IStorageVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IStorage* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IStorage* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IStorage* This); + + /*** IStorage methods ***/ + HRESULT (STDMETHODCALLTYPE *CreateStream)( + IStorage* This, + LPCOLESTR pwcsName, + DWORD grfMode, + DWORD reserved1, + DWORD reserved2, + IStream **ppstm); + + HRESULT (STDMETHODCALLTYPE *OpenStream)( + IStorage* This, + LPCOLESTR pwcsName, + void *reserved1, + DWORD grfMode, + DWORD reserved2, + IStream **ppstm); + + HRESULT (STDMETHODCALLTYPE *CreateStorage)( + IStorage* This, + LPCOLESTR pwcsName, + DWORD grfMode, + DWORD dwStgFmt, + DWORD reserved2, + IStorage **ppstg); + + HRESULT (STDMETHODCALLTYPE *OpenStorage)( + IStorage* This, + LPCOLESTR pwcsName, + IStorage *pstgPriority, + DWORD grfMode, + SNB snbExclude, + DWORD reserved, + IStorage **ppstg); + + HRESULT (STDMETHODCALLTYPE *CopyTo)( + IStorage* This, + DWORD ciidExclude, + const IID *rgiidExclude, + SNB snbExclude, + IStorage *pstgDest); + + HRESULT (STDMETHODCALLTYPE *MoveElementTo)( + IStorage* This, + LPCOLESTR pwcsName, + IStorage *pstgDest, + LPCOLESTR pwcsNewName, + DWORD grfFlags); + + HRESULT (STDMETHODCALLTYPE *Commit)( + IStorage* This, + DWORD grfCommitFlags); + + HRESULT (STDMETHODCALLTYPE *Revert)( + IStorage* This); + + HRESULT (STDMETHODCALLTYPE *EnumElements)( + IStorage* This, + DWORD reserved1, + void *reserved2, + DWORD reserved3, + IEnumSTATSTG **ppenum); + + HRESULT (STDMETHODCALLTYPE *DestroyElement)( + IStorage* This, + LPCOLESTR pwcsName); + + HRESULT (STDMETHODCALLTYPE *RenameElement)( + IStorage* This, + LPCOLESTR pwcsOldName, + LPCOLESTR pwcsNewName); + + HRESULT (STDMETHODCALLTYPE *SetElementTimes)( + IStorage* This, + LPCOLESTR pwcsName, + const FILETIME *pctime, + const FILETIME *patime, + const FILETIME *pmtime); + + HRESULT (STDMETHODCALLTYPE *SetClass)( + IStorage* This, + REFCLSID clsid); + + HRESULT (STDMETHODCALLTYPE *SetStateBits)( + IStorage* This, + DWORD grfStateBits, + DWORD grfMask); + + HRESULT (STDMETHODCALLTYPE *Stat)( + IStorage* This, + STATSTG *pstatstg, + DWORD grfStatFlag); + + END_INTERFACE +} IStorageVtbl; +interface IStorage { + CONST_VTBL IStorageVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IStorage_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IStorage_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IStorage_Release(This) (This)->lpVtbl->Release(This) +/*** IStorage methods ***/ +#define IStorage_CreateStream(This,pwcsName,grfMode,reserved1,reserved2,ppstm) (This)->lpVtbl->CreateStream(This,pwcsName,grfMode,reserved1,reserved2,ppstm) +#define IStorage_OpenStream(This,pwcsName,reserved1,grfMode,reserved2,ppstm) (This)->lpVtbl->OpenStream(This,pwcsName,reserved1,grfMode,reserved2,ppstm) +#define IStorage_CreateStorage(This,pwcsName,grfMode,dwStgFmt,reserved2,ppstg) (This)->lpVtbl->CreateStorage(This,pwcsName,grfMode,dwStgFmt,reserved2,ppstg) +#define IStorage_OpenStorage(This,pwcsName,pstgPriority,grfMode,snbExclude,reserved,ppstg) (This)->lpVtbl->OpenStorage(This,pwcsName,pstgPriority,grfMode,snbExclude,reserved,ppstg) +#define IStorage_CopyTo(This,ciidExclude,rgiidExclude,snbExclude,pstgDest) (This)->lpVtbl->CopyTo(This,ciidExclude,rgiidExclude,snbExclude,pstgDest) +#define IStorage_MoveElementTo(This,pwcsName,pstgDest,pwcsNewName,grfFlags) (This)->lpVtbl->MoveElementTo(This,pwcsName,pstgDest,pwcsNewName,grfFlags) +#define IStorage_Commit(This,grfCommitFlags) (This)->lpVtbl->Commit(This,grfCommitFlags) +#define IStorage_Revert(This) (This)->lpVtbl->Revert(This) +#define IStorage_EnumElements(This,reserved1,reserved2,reserved3,ppenum) (This)->lpVtbl->EnumElements(This,reserved1,reserved2,reserved3,ppenum) +#define IStorage_DestroyElement(This,pwcsName) (This)->lpVtbl->DestroyElement(This,pwcsName) +#define IStorage_RenameElement(This,pwcsOldName,pwcsNewName) (This)->lpVtbl->RenameElement(This,pwcsOldName,pwcsNewName) +#define IStorage_SetElementTimes(This,pwcsName,pctime,patime,pmtime) (This)->lpVtbl->SetElementTimes(This,pwcsName,pctime,patime,pmtime) +#define IStorage_SetClass(This,clsid) (This)->lpVtbl->SetClass(This,clsid) +#define IStorage_SetStateBits(This,grfStateBits,grfMask) (This)->lpVtbl->SetStateBits(This,grfStateBits,grfMask) +#define IStorage_Stat(This,pstatstg,grfStatFlag) (This)->lpVtbl->Stat(This,pstatstg,grfStatFlag) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IStorage_CreateStream_Proxy( + IStorage* This, + LPCOLESTR pwcsName, + DWORD grfMode, + DWORD reserved1, + DWORD reserved2, + IStream **ppstm); +void __RPC_STUB IStorage_CreateStream_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStorage_RemoteOpenStream_Proxy( + IStorage* This, + LPCOLESTR pwcsName, + ULONG cbReserved1, + byte *reserved1, + DWORD grfMode, + DWORD reserved2, + IStream **ppstm); +void __RPC_STUB IStorage_RemoteOpenStream_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStorage_CreateStorage_Proxy( + IStorage* This, + LPCOLESTR pwcsName, + DWORD grfMode, + DWORD dwStgFmt, + DWORD reserved2, + IStorage **ppstg); +void __RPC_STUB IStorage_CreateStorage_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStorage_OpenStorage_Proxy( + IStorage* This, + LPCOLESTR pwcsName, + IStorage *pstgPriority, + DWORD grfMode, + SNB snbExclude, + DWORD reserved, + IStorage **ppstg); +void __RPC_STUB IStorage_OpenStorage_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStorage_CopyTo_Proxy( + IStorage* This, + DWORD ciidExclude, + const IID *rgiidExclude, + SNB snbExclude, + IStorage *pstgDest); +void __RPC_STUB IStorage_CopyTo_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStorage_MoveElementTo_Proxy( + IStorage* This, + LPCOLESTR pwcsName, + IStorage *pstgDest, + LPCOLESTR pwcsNewName, + DWORD grfFlags); +void __RPC_STUB IStorage_MoveElementTo_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStorage_Commit_Proxy( + IStorage* This, + DWORD grfCommitFlags); +void __RPC_STUB IStorage_Commit_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStorage_Revert_Proxy( + IStorage* This); +void __RPC_STUB IStorage_Revert_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStorage_RemoteEnumElements_Proxy( + IStorage* This, + DWORD reserved1, + ULONG cbReserved2, + byte *reserved2, + DWORD reserved3, + IEnumSTATSTG **ppenum); +void __RPC_STUB IStorage_RemoteEnumElements_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStorage_DestroyElement_Proxy( + IStorage* This, + LPCOLESTR pwcsName); +void __RPC_STUB IStorage_DestroyElement_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStorage_RenameElement_Proxy( + IStorage* This, + LPCOLESTR pwcsOldName, + LPCOLESTR pwcsNewName); +void __RPC_STUB IStorage_RenameElement_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStorage_SetElementTimes_Proxy( + IStorage* This, + LPCOLESTR pwcsName, + const FILETIME *pctime, + const FILETIME *patime, + const FILETIME *pmtime); +void __RPC_STUB IStorage_SetElementTimes_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStorage_SetClass_Proxy( + IStorage* This, + REFCLSID clsid); +void __RPC_STUB IStorage_SetClass_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStorage_SetStateBits_Proxy( + IStorage* This, + DWORD grfStateBits, + DWORD grfMask); +void __RPC_STUB IStorage_SetStateBits_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IStorage_Stat_Proxy( + IStorage* This, + STATSTG *pstatstg, + DWORD grfStatFlag); +void __RPC_STUB IStorage_Stat_Stub( + IRpcStubBuffer* This, + 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, + ULONG cbReserved1, + byte *reserved1, + DWORD grfMode, + DWORD reserved2, + IStream **ppstm); +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, + ULONG cbReserved2, + byte *reserved2, + DWORD reserved3, + IEnumSTATSTG **ppenum); + +#endif /* __IStorage_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IPersistFile interface + */ +#ifndef __IPersistFile_INTERFACE_DEFINED__ +#define __IPersistFile_INTERFACE_DEFINED__ + +typedef IPersistFile *LPPERSISTFILE; +DEFINE_GUID(IID_IPersistFile, 0x0000010b, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IPersistFile : public IPersist +{ + virtual HRESULT STDMETHODCALLTYPE IsDirty( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Load( + LPCOLESTR pszFileName, + DWORD dwMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE Save( + LPCOLESTR pszFileName, + BOOL fRemember) = 0; + + virtual HRESULT STDMETHODCALLTYPE SaveCompleted( + LPCOLESTR pszFileName) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCurFile( + LPOLESTR *ppszFileName) = 0; + +}; +#else +typedef struct IPersistFileVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPersistFile* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPersistFile* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPersistFile* This); + + /*** IPersist methods ***/ + HRESULT (STDMETHODCALLTYPE *GetClassID)( + IPersistFile* This, + CLSID *pClassID); + + /*** IPersistFile methods ***/ + HRESULT (STDMETHODCALLTYPE *IsDirty)( + IPersistFile* This); + + HRESULT (STDMETHODCALLTYPE *Load)( + IPersistFile* This, + LPCOLESTR pszFileName, + DWORD dwMode); + + HRESULT (STDMETHODCALLTYPE *Save)( + IPersistFile* This, + LPCOLESTR pszFileName, + BOOL fRemember); + + HRESULT (STDMETHODCALLTYPE *SaveCompleted)( + IPersistFile* This, + LPCOLESTR pszFileName); + + HRESULT (STDMETHODCALLTYPE *GetCurFile)( + IPersistFile* This, + LPOLESTR *ppszFileName); + + END_INTERFACE +} IPersistFileVtbl; +interface IPersistFile { + CONST_VTBL IPersistFileVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IPersistFile_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IPersistFile_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IPersistFile_Release(This) (This)->lpVtbl->Release(This) +/*** IPersist methods ***/ +#define IPersistFile_GetClassID(This,pClassID) (This)->lpVtbl->GetClassID(This,pClassID) +/*** IPersistFile methods ***/ +#define IPersistFile_IsDirty(This) (This)->lpVtbl->IsDirty(This) +#define IPersistFile_Load(This,pszFileName,dwMode) (This)->lpVtbl->Load(This,pszFileName,dwMode) +#define IPersistFile_Save(This,pszFileName,fRemember) (This)->lpVtbl->Save(This,pszFileName,fRemember) +#define IPersistFile_SaveCompleted(This,pszFileName) (This)->lpVtbl->SaveCompleted(This,pszFileName) +#define IPersistFile_GetCurFile(This,ppszFileName) (This)->lpVtbl->GetCurFile(This,ppszFileName) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IPersistFile_IsDirty_Proxy( + IPersistFile* This); +void __RPC_STUB IPersistFile_IsDirty_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPersistFile_Load_Proxy( + IPersistFile* This, + LPCOLESTR pszFileName, + DWORD dwMode); +void __RPC_STUB IPersistFile_Load_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPersistFile_Save_Proxy( + IPersistFile* This, + LPCOLESTR pszFileName, + BOOL fRemember); +void __RPC_STUB IPersistFile_Save_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPersistFile_SaveCompleted_Proxy( + IPersistFile* This, + LPCOLESTR pszFileName); +void __RPC_STUB IPersistFile_SaveCompleted_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPersistFile_GetCurFile_Proxy( + IPersistFile* This, + LPOLESTR *ppszFileName); +void __RPC_STUB IPersistFile_GetCurFile_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPersistFile_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IPersistStorage interface + */ +#ifndef __IPersistStorage_INTERFACE_DEFINED__ +#define __IPersistStorage_INTERFACE_DEFINED__ + +typedef IPersistStorage *LPPERSISTSTORAGE; +DEFINE_GUID(IID_IPersistStorage, 0x0000010a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IPersistStorage : public IPersist +{ + virtual HRESULT STDMETHODCALLTYPE IsDirty( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE InitNew( + IStorage *pStg) = 0; + + virtual HRESULT STDMETHODCALLTYPE Load( + IStorage *pStg) = 0; + + virtual HRESULT STDMETHODCALLTYPE Save( + IStorage *pStgSave, + BOOL fSameAsLoad) = 0; + + virtual HRESULT STDMETHODCALLTYPE SaveCompleted( + IStorage *pStgNew) = 0; + + virtual HRESULT STDMETHODCALLTYPE HandsOffStorage( + ) = 0; + +}; +#else +typedef struct IPersistStorageVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPersistStorage* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPersistStorage* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPersistStorage* This); + + /*** IPersist methods ***/ + HRESULT (STDMETHODCALLTYPE *GetClassID)( + IPersistStorage* This, + CLSID *pClassID); + + /*** IPersistStorage methods ***/ + HRESULT (STDMETHODCALLTYPE *IsDirty)( + IPersistStorage* This); + + HRESULT (STDMETHODCALLTYPE *InitNew)( + IPersistStorage* This, + IStorage *pStg); + + HRESULT (STDMETHODCALLTYPE *Load)( + IPersistStorage* This, + IStorage *pStg); + + HRESULT (STDMETHODCALLTYPE *Save)( + IPersistStorage* This, + IStorage *pStgSave, + BOOL fSameAsLoad); + + HRESULT (STDMETHODCALLTYPE *SaveCompleted)( + IPersistStorage* This, + IStorage *pStgNew); + + HRESULT (STDMETHODCALLTYPE *HandsOffStorage)( + IPersistStorage* This); + + END_INTERFACE +} IPersistStorageVtbl; +interface IPersistStorage { + CONST_VTBL IPersistStorageVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IPersistStorage_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IPersistStorage_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IPersistStorage_Release(This) (This)->lpVtbl->Release(This) +/*** IPersist methods ***/ +#define IPersistStorage_GetClassID(This,pClassID) (This)->lpVtbl->GetClassID(This,pClassID) +/*** IPersistStorage methods ***/ +#define IPersistStorage_IsDirty(This) (This)->lpVtbl->IsDirty(This) +#define IPersistStorage_InitNew(This,pStg) (This)->lpVtbl->InitNew(This,pStg) +#define IPersistStorage_Load(This,pStg) (This)->lpVtbl->Load(This,pStg) +#define IPersistStorage_Save(This,pStgSave,fSameAsLoad) (This)->lpVtbl->Save(This,pStgSave,fSameAsLoad) +#define IPersistStorage_SaveCompleted(This,pStgNew) (This)->lpVtbl->SaveCompleted(This,pStgNew) +#define IPersistStorage_HandsOffStorage(This) (This)->lpVtbl->HandsOffStorage(This) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IPersistStorage_IsDirty_Proxy( + IPersistStorage* This); +void __RPC_STUB IPersistStorage_IsDirty_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPersistStorage_InitNew_Proxy( + IPersistStorage* This, + IStorage *pStg); +void __RPC_STUB IPersistStorage_InitNew_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPersistStorage_Load_Proxy( + IPersistStorage* This, + IStorage *pStg); +void __RPC_STUB IPersistStorage_Load_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPersistStorage_Save_Proxy( + IPersistStorage* This, + IStorage *pStgSave, + BOOL fSameAsLoad); +void __RPC_STUB IPersistStorage_Save_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPersistStorage_SaveCompleted_Proxy( + IPersistStorage* This, + IStorage *pStgNew); +void __RPC_STUB IPersistStorage_SaveCompleted_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPersistStorage_HandsOffStorage_Proxy( + IPersistStorage* This); +void __RPC_STUB IPersistStorage_HandsOffStorage_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPersistStorage_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IRootStorage interface + */ +#ifndef __IRootStorage_INTERFACE_DEFINED__ +#define __IRootStorage_INTERFACE_DEFINED__ + +typedef IRootStorage *LPROOTSTORAGE; +DEFINE_GUID(IID_IRootStorage, 0x00000012, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IRootStorage : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE SwitchToFile( + LPOLESTR pszFile) = 0; + +}; +#else +typedef struct IRootStorageVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IRootStorage* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IRootStorage* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IRootStorage* This); + + /*** IRootStorage methods ***/ + HRESULT (STDMETHODCALLTYPE *SwitchToFile)( + IRootStorage* This, + LPOLESTR pszFile); + + END_INTERFACE +} IRootStorageVtbl; +interface IRootStorage { + CONST_VTBL IRootStorageVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IRootStorage_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IRootStorage_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IRootStorage_Release(This) (This)->lpVtbl->Release(This) +/*** IRootStorage methods ***/ +#define IRootStorage_SwitchToFile(This,pszFile) (This)->lpVtbl->SwitchToFile(This,pszFile) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IRootStorage_SwitchToFile_Proxy( + IRootStorage* This, + LPOLESTR pszFile); +void __RPC_STUB IRootStorage_SwitchToFile_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IRootStorage_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * ILockBytes interface + */ +#ifndef __ILockBytes_INTERFACE_DEFINED__ +#define __ILockBytes_INTERFACE_DEFINED__ + +typedef ILockBytes *LPLOCKBYTES; +DEFINE_GUID(IID_ILockBytes, 0x0000000a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface ILockBytes : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE ReadAt( + ULARGE_INTEGER ulOffset, + void *pv, + ULONG cb, + ULONG *pcbRead) = 0; + + virtual HRESULT STDMETHODCALLTYPE WriteAt( + ULARGE_INTEGER ulOffset, + const void *pv, + ULONG cb, + ULONG *pcbWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE Flush( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSize( + ULARGE_INTEGER cb) = 0; + + virtual HRESULT STDMETHODCALLTYPE LockRegion( + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnlockRegion( + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType) = 0; + + virtual HRESULT STDMETHODCALLTYPE Stat( + STATSTG *pstatstg, + DWORD grfStatFlag) = 0; + +}; +#else +typedef struct ILockBytesVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ILockBytes* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ILockBytes* This); + + ULONG (STDMETHODCALLTYPE *Release)( + ILockBytes* This); + + /*** ILockBytes methods ***/ + HRESULT (STDMETHODCALLTYPE *ReadAt)( + ILockBytes* This, + ULARGE_INTEGER ulOffset, + void *pv, + ULONG cb, + ULONG *pcbRead); + + HRESULT (STDMETHODCALLTYPE *WriteAt)( + ILockBytes* This, + ULARGE_INTEGER ulOffset, + const void *pv, + ULONG cb, + ULONG *pcbWritten); + + HRESULT (STDMETHODCALLTYPE *Flush)( + ILockBytes* This); + + HRESULT (STDMETHODCALLTYPE *SetSize)( + ILockBytes* This, + ULARGE_INTEGER cb); + + HRESULT (STDMETHODCALLTYPE *LockRegion)( + ILockBytes* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); + + HRESULT (STDMETHODCALLTYPE *UnlockRegion)( + ILockBytes* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); + + HRESULT (STDMETHODCALLTYPE *Stat)( + ILockBytes* This, + STATSTG *pstatstg, + DWORD grfStatFlag); + + END_INTERFACE +} ILockBytesVtbl; +interface ILockBytes { + CONST_VTBL ILockBytesVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define ILockBytes_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define ILockBytes_AddRef(This) (This)->lpVtbl->AddRef(This) +#define ILockBytes_Release(This) (This)->lpVtbl->Release(This) +/*** ILockBytes methods ***/ +#define ILockBytes_ReadAt(This,ulOffset,pv,cb,pcbRead) (This)->lpVtbl->ReadAt(This,ulOffset,pv,cb,pcbRead) +#define ILockBytes_WriteAt(This,ulOffset,pv,cb,pcbWritten) (This)->lpVtbl->WriteAt(This,ulOffset,pv,cb,pcbWritten) +#define ILockBytes_Flush(This) (This)->lpVtbl->Flush(This) +#define ILockBytes_SetSize(This,cb) (This)->lpVtbl->SetSize(This,cb) +#define ILockBytes_LockRegion(This,libOffset,cb,dwLockType) (This)->lpVtbl->LockRegion(This,libOffset,cb,dwLockType) +#define ILockBytes_UnlockRegion(This,libOffset,cb,dwLockType) (This)->lpVtbl->UnlockRegion(This,libOffset,cb,dwLockType) +#define ILockBytes_Stat(This,pstatstg,grfStatFlag) (This)->lpVtbl->Stat(This,pstatstg,grfStatFlag) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE ILockBytes_RemoteReadAt_Proxy( + ILockBytes* This, + ULARGE_INTEGER ulOffset, + byte *pv, + ULONG cb, + ULONG *pcbRead); +void __RPC_STUB ILockBytes_RemoteReadAt_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE ILockBytes_RemoteWriteAt_Proxy( + ILockBytes* This, + ULARGE_INTEGER ulOffset, + const byte *pv, + ULONG cb, + ULONG *pcbWritten); +void __RPC_STUB ILockBytes_RemoteWriteAt_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE ILockBytes_Flush_Proxy( + ILockBytes* This); +void __RPC_STUB ILockBytes_Flush_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE ILockBytes_SetSize_Proxy( + ILockBytes* This, + ULARGE_INTEGER cb); +void __RPC_STUB ILockBytes_SetSize_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE ILockBytes_LockRegion_Proxy( + ILockBytes* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); +void __RPC_STUB ILockBytes_LockRegion_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE ILockBytes_UnlockRegion_Proxy( + ILockBytes* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); +void __RPC_STUB ILockBytes_UnlockRegion_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE ILockBytes_Stat_Proxy( + ILockBytes* This, + STATSTG *pstatstg, + DWORD grfStatFlag); +void __RPC_STUB ILockBytes_Stat_Stub( + IRpcStubBuffer* This, + 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_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); + +#endif /* __ILockBytes_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IFillLockBytes interface + */ +#ifndef __IFillLockBytes_INTERFACE_DEFINED__ +#define __IFillLockBytes_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IFillLockBytes, 0x99caf010, 0x415e, 0x11cf, 0x88,0x14, 0x00,0xaa,0x00,0xb5,0x69,0xf5); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IFillLockBytes : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE FillAppend( + const void *pv, + ULONG cb, + ULONG *pcbWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE FillAt( + ULARGE_INTEGER ulOffset, + const void *pv, + ULONG cb, + ULONG *pcbWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFillSize( + ULARGE_INTEGER ulSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE Terminate( + BOOL bCanceled) = 0; + +}; +#else +typedef struct IFillLockBytesVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IFillLockBytes* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IFillLockBytes* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IFillLockBytes* This); + + /*** IFillLockBytes methods ***/ + HRESULT (STDMETHODCALLTYPE *FillAppend)( + IFillLockBytes* This, + const void *pv, + ULONG cb, + ULONG *pcbWritten); + + HRESULT (STDMETHODCALLTYPE *FillAt)( + IFillLockBytes* This, + ULARGE_INTEGER ulOffset, + const void *pv, + ULONG cb, + ULONG *pcbWritten); + + HRESULT (STDMETHODCALLTYPE *SetFillSize)( + IFillLockBytes* This, + ULARGE_INTEGER ulSize); + + HRESULT (STDMETHODCALLTYPE *Terminate)( + IFillLockBytes* This, + BOOL bCanceled); + + END_INTERFACE +} IFillLockBytesVtbl; +interface IFillLockBytes { + CONST_VTBL IFillLockBytesVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IFillLockBytes_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IFillLockBytes_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IFillLockBytes_Release(This) (This)->lpVtbl->Release(This) +/*** IFillLockBytes methods ***/ +#define IFillLockBytes_FillAppend(This,pv,cb,pcbWritten) (This)->lpVtbl->FillAppend(This,pv,cb,pcbWritten) +#define IFillLockBytes_FillAt(This,ulOffset,pv,cb,pcbWritten) (This)->lpVtbl->FillAt(This,ulOffset,pv,cb,pcbWritten) +#define IFillLockBytes_SetFillSize(This,ulSize) (This)->lpVtbl->SetFillSize(This,ulSize) +#define IFillLockBytes_Terminate(This,bCanceled) (This)->lpVtbl->Terminate(This,bCanceled) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IFillLockBytes_RemoteFillAppend_Proxy( + IFillLockBytes* This, + const byte *pv, + ULONG cb, + ULONG *pcbWritten); +void __RPC_STUB IFillLockBytes_RemoteFillAppend_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IFillLockBytes_RemoteFillAt_Proxy( + IFillLockBytes* This, + ULARGE_INTEGER ulOffset, + const byte *pv, + ULONG cb, + ULONG *pcbWritten); +void __RPC_STUB IFillLockBytes_RemoteFillAt_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IFillLockBytes_SetFillSize_Proxy( + IFillLockBytes* This, + ULARGE_INTEGER ulSize); +void __RPC_STUB IFillLockBytes_SetFillSize_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IFillLockBytes_Terminate_Proxy( + IFillLockBytes* This, + BOOL bCanceled); +void __RPC_STUB IFillLockBytes_Terminate_Stub( + IRpcStubBuffer* This, + 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_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); + +#endif /* __IFillLockBytes_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IProgressNotify interface + */ +#ifndef __IProgressNotify_INTERFACE_DEFINED__ +#define __IProgressNotify_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IProgressNotify, 0xa9d758a0, 0x4617, 0x11cf, 0x95,0xfc, 0x00,0xaa,0x00,0x68,0x0d,0xb4); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IProgressNotify : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE OnProgress( + DWORD dwProgressCurrent, + DWORD dwProgressMaximum, + BOOL fAccurate, + BOOL fOwner) = 0; + +}; +#else +typedef struct IProgressNotifyVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IProgressNotify* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IProgressNotify* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IProgressNotify* This); + + /*** IProgressNotify methods ***/ + HRESULT (STDMETHODCALLTYPE *OnProgress)( + IProgressNotify* This, + DWORD dwProgressCurrent, + DWORD dwProgressMaximum, + BOOL fAccurate, + BOOL fOwner); + + END_INTERFACE +} IProgressNotifyVtbl; +interface IProgressNotify { + CONST_VTBL IProgressNotifyVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IProgressNotify_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IProgressNotify_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IProgressNotify_Release(This) (This)->lpVtbl->Release(This) +/*** IProgressNotify methods ***/ +#define IProgressNotify_OnProgress(This,dwProgressCurrent,dwProgressMaximum,fAccurate,fOwner) (This)->lpVtbl->OnProgress(This,dwProgressCurrent,dwProgressMaximum,fAccurate,fOwner) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IProgressNotify_OnProgress_Proxy( + IProgressNotify* This, + DWORD dwProgressCurrent, + DWORD dwProgressMaximum, + BOOL fAccurate, + BOOL fOwner); +void __RPC_STUB IProgressNotify_OnProgress_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IProgressNotify_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * ILayoutStorage interface + */ +#ifndef __ILayoutStorage_INTERFACE_DEFINED__ +#define __ILayoutStorage_INTERFACE_DEFINED__ + +typedef struct tagStorageLayout { + DWORD LayoutType; + OLECHAR *pwcsElementName; + LARGE_INTEGER cOffset; + LARGE_INTEGER cBytes; +} StorageLayout; +DEFINE_GUID(IID_ILayoutStorage, 0x0e6d4d90, 0x6738, 0x11cf, 0x96,0x08, 0x00,0xaa,0x00,0x68,0x0d,0xb4); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface ILayoutStorage : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE LayoutScript( + StorageLayout *pStorageLayout, + DWORD nEntries, + DWORD glfInterleavedFlag) = 0; + + virtual HRESULT STDMETHODCALLTYPE BeginMonitor( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndMonitor( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReLayoutDocfile( + OLECHAR *pwcsNewDfName) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReLayoutDocfileOnILockBytes( + ILockBytes *pILockBytes) = 0; + +}; +#else +typedef struct ILayoutStorageVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ILayoutStorage* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ILayoutStorage* This); + + ULONG (STDMETHODCALLTYPE *Release)( + ILayoutStorage* This); + + /*** ILayoutStorage methods ***/ + HRESULT (STDMETHODCALLTYPE *LayoutScript)( + ILayoutStorage* This, + StorageLayout *pStorageLayout, + DWORD nEntries, + DWORD glfInterleavedFlag); + + HRESULT (STDMETHODCALLTYPE *BeginMonitor)( + ILayoutStorage* This); + + HRESULT (STDMETHODCALLTYPE *EndMonitor)( + ILayoutStorage* This); + + HRESULT (STDMETHODCALLTYPE *ReLayoutDocfile)( + ILayoutStorage* This, + OLECHAR *pwcsNewDfName); + + HRESULT (STDMETHODCALLTYPE *ReLayoutDocfileOnILockBytes)( + ILayoutStorage* This, + ILockBytes *pILockBytes); + + END_INTERFACE +} ILayoutStorageVtbl; +interface ILayoutStorage { + CONST_VTBL ILayoutStorageVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define ILayoutStorage_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define ILayoutStorage_AddRef(This) (This)->lpVtbl->AddRef(This) +#define ILayoutStorage_Release(This) (This)->lpVtbl->Release(This) +/*** ILayoutStorage methods ***/ +#define ILayoutStorage_LayoutScript(This,pStorageLayout,nEntries,glfInterleavedFlag) (This)->lpVtbl->LayoutScript(This,pStorageLayout,nEntries,glfInterleavedFlag) +#define ILayoutStorage_BeginMonitor(This) (This)->lpVtbl->BeginMonitor(This) +#define ILayoutStorage_EndMonitor(This) (This)->lpVtbl->EndMonitor(This) +#define ILayoutStorage_ReLayoutDocfile(This,pwcsNewDfName) (This)->lpVtbl->ReLayoutDocfile(This,pwcsNewDfName) +#define ILayoutStorage_ReLayoutDocfileOnILockBytes(This,pILockBytes) (This)->lpVtbl->ReLayoutDocfileOnILockBytes(This,pILockBytes) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE ILayoutStorage_LayoutScript_Proxy( + ILayoutStorage* This, + StorageLayout *pStorageLayout, + DWORD nEntries, + DWORD glfInterleavedFlag); +void __RPC_STUB ILayoutStorage_LayoutScript_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE ILayoutStorage_BeginMonitor_Proxy( + ILayoutStorage* This); +void __RPC_STUB ILayoutStorage_BeginMonitor_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE ILayoutStorage_EndMonitor_Proxy( + ILayoutStorage* This); +void __RPC_STUB ILayoutStorage_EndMonitor_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE ILayoutStorage_ReLayoutDocfile_Proxy( + ILayoutStorage* This, + OLECHAR *pwcsNewDfName); +void __RPC_STUB ILayoutStorage_ReLayoutDocfile_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE ILayoutStorage_ReLayoutDocfileOnILockBytes_Proxy( + ILayoutStorage* This, + ILockBytes *pILockBytes); +void __RPC_STUB ILayoutStorage_ReLayoutDocfileOnILockBytes_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __ILayoutStorage_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IBlockingLock interface + */ +#ifndef __IBlockingLock_INTERFACE_DEFINED__ +#define __IBlockingLock_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IBlockingLock, 0x30f3d47a, 0x6447, 0x11d1, 0x8e,0x3c, 0x00,0xc0,0x4f,0xb9,0x38,0x6d); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IBlockingLock : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Lock( + DWORD dwTimeout) = 0; + + virtual HRESULT STDMETHODCALLTYPE Unlock( + ) = 0; + +}; +#else +typedef struct IBlockingLockVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IBlockingLock* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IBlockingLock* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IBlockingLock* This); + + /*** IBlockingLock methods ***/ + HRESULT (STDMETHODCALLTYPE *Lock)( + IBlockingLock* This, + DWORD dwTimeout); + + HRESULT (STDMETHODCALLTYPE *Unlock)( + IBlockingLock* This); + + END_INTERFACE +} IBlockingLockVtbl; +interface IBlockingLock { + CONST_VTBL IBlockingLockVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IBlockingLock_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IBlockingLock_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IBlockingLock_Release(This) (This)->lpVtbl->Release(This) +/*** IBlockingLock methods ***/ +#define IBlockingLock_Lock(This,dwTimeout) (This)->lpVtbl->Lock(This,dwTimeout) +#define IBlockingLock_Unlock(This) (This)->lpVtbl->Unlock(This) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IBlockingLock_Lock_Proxy( + IBlockingLock* This, + DWORD dwTimeout); +void __RPC_STUB IBlockingLock_Lock_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IBlockingLock_Unlock_Proxy( + IBlockingLock* This); +void __RPC_STUB IBlockingLock_Unlock_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IBlockingLock_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * ITimeAndNoticeControl interface + */ +#ifndef __ITimeAndNoticeControl_INTERFACE_DEFINED__ +#define __ITimeAndNoticeControl_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_ITimeAndNoticeControl, 0xbc0bf6ae, 0x8878, 0x11d1, 0x83,0xe9, 0x00,0xc0,0x4f,0xc2,0xc6,0xd4); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface ITimeAndNoticeControl : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE SuppressChanges( + DWORD res1, + DWORD res2) = 0; + +}; +#else +typedef struct ITimeAndNoticeControlVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ITimeAndNoticeControl* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ITimeAndNoticeControl* This); + + ULONG (STDMETHODCALLTYPE *Release)( + ITimeAndNoticeControl* This); + + /*** ITimeAndNoticeControl methods ***/ + HRESULT (STDMETHODCALLTYPE *SuppressChanges)( + ITimeAndNoticeControl* This, + DWORD res1, + DWORD res2); + + END_INTERFACE +} ITimeAndNoticeControlVtbl; +interface ITimeAndNoticeControl { + CONST_VTBL ITimeAndNoticeControlVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define ITimeAndNoticeControl_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define ITimeAndNoticeControl_AddRef(This) (This)->lpVtbl->AddRef(This) +#define ITimeAndNoticeControl_Release(This) (This)->lpVtbl->Release(This) +/*** ITimeAndNoticeControl methods ***/ +#define ITimeAndNoticeControl_SuppressChanges(This,res1,res2) (This)->lpVtbl->SuppressChanges(This,res1,res2) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE ITimeAndNoticeControl_SuppressChanges_Proxy( + ITimeAndNoticeControl* This, + DWORD res1, + DWORD res2); +void __RPC_STUB ITimeAndNoticeControl_SuppressChanges_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __ITimeAndNoticeControl_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IOplockStorage interface + */ +#ifndef __IOplockStorage_INTERFACE_DEFINED__ +#define __IOplockStorage_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IOplockStorage, 0x8d19c834, 0x8879, 0x11d1, 0x83,0xe9, 0x00,0xc0,0x4f,0xc2,0xc6,0xd4); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IOplockStorage : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE CreateStorageEx( + LPCWSTR pwcsName, + DWORD grfMode, + DWORD stgfmt, + DWORD grfAttrs, + REFIID riid, + void **ppstgOpen) = 0; + + virtual HRESULT STDMETHODCALLTYPE OpenStorageEx( + LPCWSTR pwcsName, + DWORD grfMode, + DWORD stgfmt, + DWORD grfAttrs, + REFIID riid, + void **ppstgOpen) = 0; + +}; +#else +typedef struct IOplockStorageVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IOplockStorage* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IOplockStorage* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IOplockStorage* This); + + /*** IOplockStorage methods ***/ + HRESULT (STDMETHODCALLTYPE *CreateStorageEx)( + IOplockStorage* This, + LPCWSTR pwcsName, + DWORD grfMode, + DWORD stgfmt, + DWORD grfAttrs, + REFIID riid, + void **ppstgOpen); + + HRESULT (STDMETHODCALLTYPE *OpenStorageEx)( + IOplockStorage* This, + LPCWSTR pwcsName, + DWORD grfMode, + DWORD stgfmt, + DWORD grfAttrs, + REFIID riid, + void **ppstgOpen); + + END_INTERFACE +} IOplockStorageVtbl; +interface IOplockStorage { + CONST_VTBL IOplockStorageVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IOplockStorage_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IOplockStorage_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IOplockStorage_Release(This) (This)->lpVtbl->Release(This) +/*** IOplockStorage methods ***/ +#define IOplockStorage_CreateStorageEx(This,pwcsName,grfMode,stgfmt,grfAttrs,riid,ppstgOpen) (This)->lpVtbl->CreateStorageEx(This,pwcsName,grfMode,stgfmt,grfAttrs,riid,ppstgOpen) +#define IOplockStorage_OpenStorageEx(This,pwcsName,grfMode,stgfmt,grfAttrs,riid,ppstgOpen) (This)->lpVtbl->OpenStorageEx(This,pwcsName,grfMode,stgfmt,grfAttrs,riid,ppstgOpen) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IOplockStorage_CreateStorageEx_Proxy( + IOplockStorage* This, + LPCWSTR pwcsName, + DWORD grfMode, + DWORD stgfmt, + DWORD grfAttrs, + REFIID riid, + void **ppstgOpen); +void __RPC_STUB IOplockStorage_CreateStorageEx_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IOplockStorage_OpenStorageEx_Proxy( + IOplockStorage* This, + LPCWSTR pwcsName, + DWORD grfMode, + DWORD stgfmt, + DWORD grfAttrs, + REFIID riid, + void **ppstgOpen); +void __RPC_STUB IOplockStorage_OpenStorageEx_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IOplockStorage_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IEnumFORMATETC interface + */ +#ifndef __IEnumFORMATETC_INTERFACE_DEFINED__ +#define __IEnumFORMATETC_INTERFACE_DEFINED__ + +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; +typedef struct tagFORMATETC *LPFORMATETC; +DEFINE_GUID(IID_IEnumFORMATETC, 0x00000103, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IEnumFORMATETC : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Next( + ULONG celt, + FORMATETC *rgelt, + ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + IEnumFORMATETC **ppenum) = 0; + +}; +#else +typedef struct IEnumFORMATETCVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IEnumFORMATETC* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IEnumFORMATETC* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IEnumFORMATETC* This); + + /*** IEnumFORMATETC methods ***/ + HRESULT (STDMETHODCALLTYPE *Next)( + IEnumFORMATETC* This, + ULONG celt, + FORMATETC *rgelt, + ULONG *pceltFetched); + + HRESULT (STDMETHODCALLTYPE *Skip)( + IEnumFORMATETC* This, + ULONG celt); + + HRESULT (STDMETHODCALLTYPE *Reset)( + IEnumFORMATETC* This); + + HRESULT (STDMETHODCALLTYPE *Clone)( + IEnumFORMATETC* This, + IEnumFORMATETC **ppenum); + + END_INTERFACE +} IEnumFORMATETCVtbl; +interface IEnumFORMATETC { + CONST_VTBL IEnumFORMATETCVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IEnumFORMATETC_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IEnumFORMATETC_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IEnumFORMATETC_Release(This) (This)->lpVtbl->Release(This) +/*** IEnumFORMATETC methods ***/ +#define IEnumFORMATETC_Next(This,celt,rgelt,pceltFetched) (This)->lpVtbl->Next(This,celt,rgelt,pceltFetched) +#define IEnumFORMATETC_Skip(This,celt) (This)->lpVtbl->Skip(This,celt) +#define IEnumFORMATETC_Reset(This) (This)->lpVtbl->Reset(This) +#define IEnumFORMATETC_Clone(This,ppenum) (This)->lpVtbl->Clone(This,ppenum) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IEnumFORMATETC_RemoteNext_Proxy( + IEnumFORMATETC* This, + ULONG celt, + FORMATETC *rgelt, + ULONG *pceltFetched); +void __RPC_STUB IEnumFORMATETC_RemoteNext_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumFORMATETC_Skip_Proxy( + IEnumFORMATETC* This, + ULONG celt); +void __RPC_STUB IEnumFORMATETC_Skip_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumFORMATETC_Reset_Proxy( + IEnumFORMATETC* This); +void __RPC_STUB IEnumFORMATETC_Reset_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumFORMATETC_Clone_Proxy( + IEnumFORMATETC* This, + IEnumFORMATETC **ppenum); +void __RPC_STUB IEnumFORMATETC_Clone_Stub( + IRpcStubBuffer* This, + 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); + +#endif /* __IEnumFORMATETC_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IEnumSTATDATA interface + */ +#ifndef __IEnumSTATDATA_INTERFACE_DEFINED__ +#define __IEnumSTATDATA_INTERFACE_DEFINED__ + +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; +typedef struct tagSTATDATA *LPSTATDATA; +DEFINE_GUID(IID_IEnumSTATDATA, 0x00000105, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IEnumSTATDATA : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Next( + ULONG celt, + STATDATA *rgelt, + ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + IEnumSTATDATA **ppenum) = 0; + +}; +#else +typedef struct IEnumSTATDATAVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IEnumSTATDATA* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IEnumSTATDATA* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IEnumSTATDATA* This); + + /*** IEnumSTATDATA methods ***/ + HRESULT (STDMETHODCALLTYPE *Next)( + IEnumSTATDATA* This, + ULONG celt, + STATDATA *rgelt, + ULONG *pceltFetched); + + HRESULT (STDMETHODCALLTYPE *Skip)( + IEnumSTATDATA* This, + ULONG celt); + + HRESULT (STDMETHODCALLTYPE *Reset)( + IEnumSTATDATA* This); + + HRESULT (STDMETHODCALLTYPE *Clone)( + IEnumSTATDATA* This, + IEnumSTATDATA **ppenum); + + END_INTERFACE +} IEnumSTATDATAVtbl; +interface IEnumSTATDATA { + CONST_VTBL IEnumSTATDATAVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IEnumSTATDATA_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IEnumSTATDATA_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IEnumSTATDATA_Release(This) (This)->lpVtbl->Release(This) +/*** IEnumSTATDATA methods ***/ +#define IEnumSTATDATA_Next(This,celt,rgelt,pceltFetched) (This)->lpVtbl->Next(This,celt,rgelt,pceltFetched) +#define IEnumSTATDATA_Skip(This,celt) (This)->lpVtbl->Skip(This,celt) +#define IEnumSTATDATA_Reset(This) (This)->lpVtbl->Reset(This) +#define IEnumSTATDATA_Clone(This,ppenum) (This)->lpVtbl->Clone(This,ppenum) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IEnumSTATDATA_RemoteNext_Proxy( + IEnumSTATDATA* This, + ULONG celt, + STATDATA *rgelt, + ULONG *pceltFetched); +void __RPC_STUB IEnumSTATDATA_RemoteNext_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumSTATDATA_Skip_Proxy( + IEnumSTATDATA* This, + ULONG celt); +void __RPC_STUB IEnumSTATDATA_Skip_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumSTATDATA_Reset_Proxy( + IEnumSTATDATA* This); +void __RPC_STUB IEnumSTATDATA_Reset_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumSTATDATA_Clone_Proxy( + IEnumSTATDATA* This, + IEnumSTATDATA **ppenum); +void __RPC_STUB IEnumSTATDATA_Clone_Stub( + IRpcStubBuffer* This, + 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); + +#endif /* __IEnumSTATDATA_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IAdviseSink interface + */ +#ifndef __IAdviseSink_INTERFACE_DEFINED__ +#define __IAdviseSink_INTERFACE_DEFINED__ + +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; + ULONG pData; + ULONG pUnkForRelease; + ULONG 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 { + DWORD tymed; + union { + wireHMETAFILEPICT hMetaFilePict; + wireHENHMETAFILE hHEnhMetaFile; + GDI_OBJECT *hGdiHandle; + wireHGLOBAL hGlobal; + LPOLESTR lpszFileName; + BYTE_BLOB *pstm; + BYTE_BLOB *pstg; + } u; + } DUMMYUNIONNAME; + IUnknown *pUnkForRelease; +} userSTGMEDIUM; +typedef userSTGMEDIUM *wireSTGMEDIUM; +typedef uSTGMEDIUM STGMEDIUM; +typedef userSTGMEDIUM *wireASYNC_STGMEDIUM; +typedef STGMEDIUM 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; +DEFINE_GUID(IID_IAdviseSink, 0x0000010f, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IAdviseSink : public IUnknown +{ + virtual void STDMETHODCALLTYPE OnDataChange( + FORMATETC *pFormatetc, + STGMEDIUM *pStgmed) = 0; + + virtual void STDMETHODCALLTYPE OnViewChange( + DWORD dwAspect, + LONG lindex) = 0; + + virtual void STDMETHODCALLTYPE OnRename( + IMoniker *pmk) = 0; + + virtual void STDMETHODCALLTYPE OnSave( + ) = 0; + + virtual void STDMETHODCALLTYPE OnClose( + ) = 0; + +}; +#else +typedef struct IAdviseSinkVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IAdviseSink* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IAdviseSink* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IAdviseSink* This); + + /*** IAdviseSink methods ***/ + void (STDMETHODCALLTYPE *OnDataChange)( + IAdviseSink* This, + FORMATETC *pFormatetc, + STGMEDIUM *pStgmed); + + void (STDMETHODCALLTYPE *OnViewChange)( + IAdviseSink* This, + DWORD dwAspect, + LONG lindex); + + void (STDMETHODCALLTYPE *OnRename)( + IAdviseSink* This, + IMoniker *pmk); + + void (STDMETHODCALLTYPE *OnSave)( + IAdviseSink* This); + + void (STDMETHODCALLTYPE *OnClose)( + IAdviseSink* This); + + END_INTERFACE +} IAdviseSinkVtbl; +interface IAdviseSink { + CONST_VTBL IAdviseSinkVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IAdviseSink_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IAdviseSink_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IAdviseSink_Release(This) (This)->lpVtbl->Release(This) +/*** IAdviseSink methods ***/ +#define IAdviseSink_OnDataChange(This,pFormatetc,pStgmed) (This)->lpVtbl->OnDataChange(This,pFormatetc,pStgmed) +#define IAdviseSink_OnViewChange(This,dwAspect,lindex) (This)->lpVtbl->OnViewChange(This,dwAspect,lindex) +#define IAdviseSink_OnRename(This,pmk) (This)->lpVtbl->OnRename(This,pmk) +#define IAdviseSink_OnSave(This) (This)->lpVtbl->OnSave(This) +#define IAdviseSink_OnClose(This) (This)->lpVtbl->OnClose(This) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IAdviseSink_RemoteOnDataChange_Proxy( + IAdviseSink* This, + FORMATETC *pFormatetc, + ASYNC_STGMEDIUM *pStgmed); +void __RPC_STUB IAdviseSink_RemoteOnDataChange_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAdviseSink_RemoteOnViewChange_Proxy( + IAdviseSink* This, + DWORD dwAspect, + LONG lindex); +void __RPC_STUB IAdviseSink_RemoteOnViewChange_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAdviseSink_RemoteOnRename_Proxy( + IAdviseSink* This, + IMoniker *pmk); +void __RPC_STUB IAdviseSink_RemoteOnRename_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAdviseSink_RemoteOnSave_Proxy( + IAdviseSink* This); +void __RPC_STUB IAdviseSink_RemoteOnSave_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAdviseSink_RemoteOnClose_Proxy( + IAdviseSink* This); +void __RPC_STUB IAdviseSink_RemoteOnClose_Stub( + IRpcStubBuffer* This, + 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, + FORMATETC *pFormatetc, + ASYNC_STGMEDIUM *pStgmed); +void CALLBACK IAdviseSink_OnViewChange_Proxy( + IAdviseSink* This, + DWORD dwAspect, + LONG lindex); +HRESULT __RPC_STUB IAdviseSink_OnViewChange_Stub( + IAdviseSink* This, + DWORD dwAspect, + LONG lindex); +void CALLBACK IAdviseSink_OnRename_Proxy( + IAdviseSink* This, + IMoniker *pmk); +HRESULT __RPC_STUB IAdviseSink_OnRename_Stub( + IAdviseSink* This, + IMoniker *pmk); +void CALLBACK IAdviseSink_OnSave_Proxy( + IAdviseSink* This); +HRESULT __RPC_STUB IAdviseSink_OnSave_Stub( + IAdviseSink* This); +void CALLBACK IAdviseSink_OnClose_Proxy( + IAdviseSink* This); +HRESULT __RPC_STUB IAdviseSink_OnClose_Stub( + IAdviseSink* This); + +#endif /* __IAdviseSink_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IAdviseSink2 interface + */ +#ifndef __IAdviseSink2_INTERFACE_DEFINED__ +#define __IAdviseSink2_INTERFACE_DEFINED__ + +typedef IAdviseSink2 *LPADVISESINK2; +DEFINE_GUID(IID_IAdviseSink2, 0x00000125, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IAdviseSink2 : public IAdviseSink +{ + virtual void STDMETHODCALLTYPE OnLinkSrcChange( + IMoniker *pmk) = 0; + +}; +#else +typedef struct IAdviseSink2Vtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IAdviseSink2* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IAdviseSink2* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IAdviseSink2* This); + + /*** IAdviseSink methods ***/ + void (STDMETHODCALLTYPE *OnDataChange)( + IAdviseSink2* This, + FORMATETC *pFormatetc, + STGMEDIUM *pStgmed); + + void (STDMETHODCALLTYPE *OnViewChange)( + IAdviseSink2* This, + DWORD dwAspect, + LONG lindex); + + void (STDMETHODCALLTYPE *OnRename)( + IAdviseSink2* This, + IMoniker *pmk); + + void (STDMETHODCALLTYPE *OnSave)( + IAdviseSink2* This); + + void (STDMETHODCALLTYPE *OnClose)( + IAdviseSink2* This); + + /*** IAdviseSink2 methods ***/ + void (STDMETHODCALLTYPE *OnLinkSrcChange)( + IAdviseSink2* This, + IMoniker *pmk); + + END_INTERFACE +} IAdviseSink2Vtbl; +interface IAdviseSink2 { + CONST_VTBL IAdviseSink2Vtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IAdviseSink2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IAdviseSink2_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IAdviseSink2_Release(This) (This)->lpVtbl->Release(This) +/*** IAdviseSink methods ***/ +#define IAdviseSink2_OnDataChange(This,pFormatetc,pStgmed) (This)->lpVtbl->OnDataChange(This,pFormatetc,pStgmed) +#define IAdviseSink2_OnViewChange(This,dwAspect,lindex) (This)->lpVtbl->OnViewChange(This,dwAspect,lindex) +#define IAdviseSink2_OnRename(This,pmk) (This)->lpVtbl->OnRename(This,pmk) +#define IAdviseSink2_OnSave(This) (This)->lpVtbl->OnSave(This) +#define IAdviseSink2_OnClose(This) (This)->lpVtbl->OnClose(This) +/*** IAdviseSink2 methods ***/ +#define IAdviseSink2_OnLinkSrcChange(This,pmk) (This)->lpVtbl->OnLinkSrcChange(This,pmk) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IAdviseSink2_RemoteOnLinkSrcChange_Proxy( + IAdviseSink2* This, + IMoniker *pmk); +void __RPC_STUB IAdviseSink2_RemoteOnLinkSrcChange_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IAdviseSink2_OnLinkSrcChange_Proxy( + IAdviseSink2* This, + IMoniker *pmk); +HRESULT __RPC_STUB IAdviseSink2_OnLinkSrcChange_Stub( + IAdviseSink2* This, + IMoniker *pmk); + +#endif /* __IAdviseSink2_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IDataObject interface + */ +#ifndef __IDataObject_INTERFACE_DEFINED__ +#define __IDataObject_INTERFACE_DEFINED__ + +typedef IDataObject *LPDATAOBJECT; +typedef enum tagDATADIR { + DATADIR_GET = 1, + DATADIR_SET = 2 +} DATADIR; +DEFINE_GUID(IID_IDataObject, 0x0000010e, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IDataObject : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetData( + FORMATETC *pformatetcIn, + STGMEDIUM *pmedium) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDataHere( + FORMATETC *pformatetc, + STGMEDIUM *pmedium) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueryGetData( + FORMATETC *pformatetc) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCanonicalFormatEtc( + FORMATETC *pformatectIn, + FORMATETC *pformatetcOut) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetData( + FORMATETC *pformatetc, + STGMEDIUM *pmedium, + BOOL fRelease) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumFormatEtc( + DWORD dwDirection, + IEnumFORMATETC **ppenumFormatEtc) = 0; + + virtual HRESULT STDMETHODCALLTYPE DAdvise( + FORMATETC *pformatetc, + DWORD advf, + IAdviseSink *pAdvSink, + DWORD *pdwConnection) = 0; + + virtual HRESULT STDMETHODCALLTYPE DUnadvise( + DWORD dwConnection) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumDAdvise( + IEnumSTATDATA **ppenumAdvise) = 0; + +}; +#else +typedef struct IDataObjectVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IDataObject* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IDataObject* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IDataObject* This); + + /*** IDataObject methods ***/ + HRESULT (STDMETHODCALLTYPE *GetData)( + IDataObject* This, + FORMATETC *pformatetcIn, + STGMEDIUM *pmedium); + + HRESULT (STDMETHODCALLTYPE *GetDataHere)( + IDataObject* This, + FORMATETC *pformatetc, + STGMEDIUM *pmedium); + + HRESULT (STDMETHODCALLTYPE *QueryGetData)( + IDataObject* This, + FORMATETC *pformatetc); + + HRESULT (STDMETHODCALLTYPE *GetCanonicalFormatEtc)( + IDataObject* This, + FORMATETC *pformatectIn, + FORMATETC *pformatetcOut); + + HRESULT (STDMETHODCALLTYPE *SetData)( + IDataObject* This, + FORMATETC *pformatetc, + STGMEDIUM *pmedium, + BOOL fRelease); + + HRESULT (STDMETHODCALLTYPE *EnumFormatEtc)( + IDataObject* This, + DWORD dwDirection, + IEnumFORMATETC **ppenumFormatEtc); + + HRESULT (STDMETHODCALLTYPE *DAdvise)( + IDataObject* This, + FORMATETC *pformatetc, + DWORD advf, + IAdviseSink *pAdvSink, + DWORD *pdwConnection); + + HRESULT (STDMETHODCALLTYPE *DUnadvise)( + IDataObject* This, + DWORD dwConnection); + + HRESULT (STDMETHODCALLTYPE *EnumDAdvise)( + IDataObject* This, + IEnumSTATDATA **ppenumAdvise); + + END_INTERFACE +} IDataObjectVtbl; +interface IDataObject { + CONST_VTBL IDataObjectVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IDataObject_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IDataObject_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IDataObject_Release(This) (This)->lpVtbl->Release(This) +/*** IDataObject methods ***/ +#define IDataObject_GetData(This,pformatetcIn,pmedium) (This)->lpVtbl->GetData(This,pformatetcIn,pmedium) +#define IDataObject_GetDataHere(This,pformatetc,pmedium) (This)->lpVtbl->GetDataHere(This,pformatetc,pmedium) +#define IDataObject_QueryGetData(This,pformatetc) (This)->lpVtbl->QueryGetData(This,pformatetc) +#define IDataObject_GetCanonicalFormatEtc(This,pformatectIn,pformatetcOut) (This)->lpVtbl->GetCanonicalFormatEtc(This,pformatectIn,pformatetcOut) +#define IDataObject_SetData(This,pformatetc,pmedium,fRelease) (This)->lpVtbl->SetData(This,pformatetc,pmedium,fRelease) +#define IDataObject_EnumFormatEtc(This,dwDirection,ppenumFormatEtc) (This)->lpVtbl->EnumFormatEtc(This,dwDirection,ppenumFormatEtc) +#define IDataObject_DAdvise(This,pformatetc,advf,pAdvSink,pdwConnection) (This)->lpVtbl->DAdvise(This,pformatetc,advf,pAdvSink,pdwConnection) +#define IDataObject_DUnadvise(This,dwConnection) (This)->lpVtbl->DUnadvise(This,dwConnection) +#define IDataObject_EnumDAdvise(This,ppenumAdvise) (This)->lpVtbl->EnumDAdvise(This,ppenumAdvise) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IDataObject_RemoteGetData_Proxy( + IDataObject* This, + FORMATETC *pformatetcIn, + STGMEDIUM *pRemoteMedium); +void __RPC_STUB IDataObject_RemoteGetData_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IDataObject_RemoteGetDataHere_Proxy( + IDataObject* This, + FORMATETC *pformatetc, + STGMEDIUM *pRemoteMedium); +void __RPC_STUB IDataObject_RemoteGetDataHere_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IDataObject_QueryGetData_Proxy( + IDataObject* This, + FORMATETC *pformatetc); +void __RPC_STUB IDataObject_QueryGetData_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IDataObject_GetCanonicalFormatEtc_Proxy( + IDataObject* This, + FORMATETC *pformatectIn, + FORMATETC *pformatetcOut); +void __RPC_STUB IDataObject_GetCanonicalFormatEtc_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IDataObject_RemoteSetData_Proxy( + IDataObject* This, + FORMATETC *pformatetc, + FLAG_STGMEDIUM *pmedium, + BOOL fRelease); +void __RPC_STUB IDataObject_RemoteSetData_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IDataObject_EnumFormatEtc_Proxy( + IDataObject* This, + DWORD dwDirection, + IEnumFORMATETC **ppenumFormatEtc); +void __RPC_STUB IDataObject_EnumFormatEtc_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IDataObject_DAdvise_Proxy( + IDataObject* This, + FORMATETC *pformatetc, + DWORD advf, + IAdviseSink *pAdvSink, + DWORD *pdwConnection); +void __RPC_STUB IDataObject_DAdvise_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IDataObject_DUnadvise_Proxy( + IDataObject* This, + DWORD dwConnection); +void __RPC_STUB IDataObject_DUnadvise_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IDataObject_EnumDAdvise_Proxy( + IDataObject* This, + IEnumSTATDATA **ppenumAdvise); +void __RPC_STUB IDataObject_EnumDAdvise_Stub( + IRpcStubBuffer* This, + 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_GetDataHere_Proxy( + IDataObject* This, + FORMATETC *pformatetc, + STGMEDIUM *pmedium); +HRESULT __RPC_STUB IDataObject_GetDataHere_Stub( + IDataObject* This, + FORMATETC *pformatetc, + STGMEDIUM *pRemoteMedium); +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); + +#endif /* __IDataObject_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IDataAdviseHolder interface + */ +#ifndef __IDataAdviseHolder_INTERFACE_DEFINED__ +#define __IDataAdviseHolder_INTERFACE_DEFINED__ + +typedef IDataAdviseHolder *LPDATAADVISEHOLDER; +DEFINE_GUID(IID_IDataAdviseHolder, 0x00000110, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IDataAdviseHolder : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Advise( + IDataObject *pDataObject, + FORMATETC *pFetc, + DWORD advf, + IAdviseSink *pAdvise, + DWORD *pdwConnection) = 0; + + virtual HRESULT STDMETHODCALLTYPE Unadvise( + DWORD dwConnection) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumAdvise( + IEnumSTATDATA **ppenumAdvise) = 0; + + virtual HRESULT STDMETHODCALLTYPE SendOnDataChange( + IDataObject *pDataObject, + DWORD dwReserved, + DWORD advf) = 0; + +}; +#else +typedef struct IDataAdviseHolderVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IDataAdviseHolder* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IDataAdviseHolder* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IDataAdviseHolder* This); + + /*** IDataAdviseHolder methods ***/ + HRESULT (STDMETHODCALLTYPE *Advise)( + IDataAdviseHolder* This, + IDataObject *pDataObject, + FORMATETC *pFetc, + DWORD advf, + IAdviseSink *pAdvise, + DWORD *pdwConnection); + + HRESULT (STDMETHODCALLTYPE *Unadvise)( + IDataAdviseHolder* This, + DWORD dwConnection); + + HRESULT (STDMETHODCALLTYPE *EnumAdvise)( + IDataAdviseHolder* This, + IEnumSTATDATA **ppenumAdvise); + + HRESULT (STDMETHODCALLTYPE *SendOnDataChange)( + IDataAdviseHolder* This, + IDataObject *pDataObject, + DWORD dwReserved, + DWORD advf); + + END_INTERFACE +} IDataAdviseHolderVtbl; +interface IDataAdviseHolder { + CONST_VTBL IDataAdviseHolderVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IDataAdviseHolder_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IDataAdviseHolder_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IDataAdviseHolder_Release(This) (This)->lpVtbl->Release(This) +/*** IDataAdviseHolder methods ***/ +#define IDataAdviseHolder_Advise(This,pDataObject,pFetc,advf,pAdvise,pdwConnection) (This)->lpVtbl->Advise(This,pDataObject,pFetc,advf,pAdvise,pdwConnection) +#define IDataAdviseHolder_Unadvise(This,dwConnection) (This)->lpVtbl->Unadvise(This,dwConnection) +#define IDataAdviseHolder_EnumAdvise(This,ppenumAdvise) (This)->lpVtbl->EnumAdvise(This,ppenumAdvise) +#define IDataAdviseHolder_SendOnDataChange(This,pDataObject,dwReserved,advf) (This)->lpVtbl->SendOnDataChange(This,pDataObject,dwReserved,advf) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IDataAdviseHolder_Advise_Proxy( + IDataAdviseHolder* This, + IDataObject *pDataObject, + FORMATETC *pFetc, + DWORD advf, + IAdviseSink *pAdvise, + DWORD *pdwConnection); +void __RPC_STUB IDataAdviseHolder_Advise_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IDataAdviseHolder_Unadvise_Proxy( + IDataAdviseHolder* This, + DWORD dwConnection); +void __RPC_STUB IDataAdviseHolder_Unadvise_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IDataAdviseHolder_EnumAdvise_Proxy( + IDataAdviseHolder* This, + IEnumSTATDATA **ppenumAdvise); +void __RPC_STUB IDataAdviseHolder_EnumAdvise_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IDataAdviseHolder_SendOnDataChange_Proxy( + IDataAdviseHolder* This, + IDataObject *pDataObject, + DWORD dwReserved, + DWORD advf); +void __RPC_STUB IDataAdviseHolder_SendOnDataChange_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IDataAdviseHolder_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IMessageFilter interface + */ +#ifndef __IMessageFilter_INTERFACE_DEFINED__ +#define __IMessageFilter_INTERFACE_DEFINED__ + +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; +typedef struct tagINTERFACEINFO *LPINTERFACEINFO; +DEFINE_GUID(IID_IMessageFilter, 0x00000016, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IMessageFilter : public IUnknown +{ + virtual DWORD STDMETHODCALLTYPE HandleInComingCall( + DWORD dwCallType, + HTASK htaskCaller, + DWORD dwTickCount, + LPINTERFACEINFO lpInterfaceInfo) = 0; + + virtual DWORD STDMETHODCALLTYPE RetryRejectedCall( + HTASK htaskCallee, + DWORD dwTickCount, + DWORD dwRejectType) = 0; + + virtual DWORD STDMETHODCALLTYPE MessagePending( + HTASK htaskCallee, + DWORD dwTickCount, + DWORD dwPendingType) = 0; + +}; +#else +typedef struct IMessageFilterVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IMessageFilter* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IMessageFilter* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IMessageFilter* This); + + /*** IMessageFilter methods ***/ + DWORD (STDMETHODCALLTYPE *HandleInComingCall)( + IMessageFilter* This, + DWORD dwCallType, + HTASK htaskCaller, + DWORD dwTickCount, + LPINTERFACEINFO lpInterfaceInfo); + + DWORD (STDMETHODCALLTYPE *RetryRejectedCall)( + IMessageFilter* This, + HTASK htaskCallee, + DWORD dwTickCount, + DWORD dwRejectType); + + DWORD (STDMETHODCALLTYPE *MessagePending)( + IMessageFilter* This, + HTASK htaskCallee, + DWORD dwTickCount, + DWORD dwPendingType); + + END_INTERFACE +} IMessageFilterVtbl; +interface IMessageFilter { + CONST_VTBL IMessageFilterVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IMessageFilter_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IMessageFilter_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IMessageFilter_Release(This) (This)->lpVtbl->Release(This) +/*** IMessageFilter methods ***/ +#define IMessageFilter_HandleInComingCall(This,dwCallType,htaskCaller,dwTickCount,lpInterfaceInfo) (This)->lpVtbl->HandleInComingCall(This,dwCallType,htaskCaller,dwTickCount,lpInterfaceInfo) +#define IMessageFilter_RetryRejectedCall(This,htaskCallee,dwTickCount,dwRejectType) (This)->lpVtbl->RetryRejectedCall(This,htaskCallee,dwTickCount,dwRejectType) +#define IMessageFilter_MessagePending(This,htaskCallee,dwTickCount,dwPendingType) (This)->lpVtbl->MessagePending(This,htaskCallee,dwTickCount,dwPendingType) +#endif + +#endif + +DWORD STDMETHODCALLTYPE IMessageFilter_HandleInComingCall_Proxy( + IMessageFilter* This, + DWORD dwCallType, + HTASK htaskCaller, + DWORD dwTickCount, + LPINTERFACEINFO lpInterfaceInfo); +void __RPC_STUB IMessageFilter_HandleInComingCall_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +DWORD STDMETHODCALLTYPE IMessageFilter_RetryRejectedCall_Proxy( + IMessageFilter* This, + HTASK htaskCallee, + DWORD dwTickCount, + DWORD dwRejectType); +void __RPC_STUB IMessageFilter_RetryRejectedCall_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +DWORD STDMETHODCALLTYPE IMessageFilter_MessagePending_Proxy( + IMessageFilter* This, + HTASK htaskCallee, + DWORD dwTickCount, + DWORD dwPendingType); +void __RPC_STUB IMessageFilter_MessagePending_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IMessageFilter_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IRpcChannelBuffer interface + */ +#ifndef __IRpcChannelBuffer_INTERFACE_DEFINED__ +#define __IRpcChannelBuffer_INTERFACE_DEFINED__ + +typedef IRpcChannelBuffer *LPRPCCHANNELBUFFER; +typedef ULONG RPCOLEDATAREP; +typedef struct tagRPCOLEMESSAGE { + void *reserved1; + RPCOLEDATAREP dataRepresentation; + void *Buffer; + ULONG cbBuffer; + ULONG iMethod; + void * reserved2[5]; + ULONG rpcFlags; +} RPCOLEMESSAGE; +typedef RPCOLEMESSAGE *PRPCOLEMESSAGE; +DEFINE_GUID(IID_IRpcChannelBuffer, 0xd5f56b60, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IRpcChannelBuffer : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetBuffer( + RPCOLEMESSAGE *pMessage, + REFIID riid) = 0; + + virtual HRESULT STDMETHODCALLTYPE SendReceive( + RPCOLEMESSAGE *pMessage, + ULONG *pStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE FreeBuffer( + RPCOLEMESSAGE *pMessage) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDestCtx( + DWORD *pdwDestContext, + void **ppvDestContext) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsConnected( + ) = 0; + +}; +#else +typedef struct IRpcChannelBufferVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IRpcChannelBuffer* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IRpcChannelBuffer* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IRpcChannelBuffer* This); + + /*** IRpcChannelBuffer methods ***/ + HRESULT (STDMETHODCALLTYPE *GetBuffer)( + IRpcChannelBuffer* This, + RPCOLEMESSAGE *pMessage, + REFIID riid); + + HRESULT (STDMETHODCALLTYPE *SendReceive)( + IRpcChannelBuffer* This, + RPCOLEMESSAGE *pMessage, + ULONG *pStatus); + + HRESULT (STDMETHODCALLTYPE *FreeBuffer)( + IRpcChannelBuffer* This, + RPCOLEMESSAGE *pMessage); + + HRESULT (STDMETHODCALLTYPE *GetDestCtx)( + IRpcChannelBuffer* This, + DWORD *pdwDestContext, + void **ppvDestContext); + + HRESULT (STDMETHODCALLTYPE *IsConnected)( + IRpcChannelBuffer* This); + + END_INTERFACE +} IRpcChannelBufferVtbl; +interface IRpcChannelBuffer { + CONST_VTBL IRpcChannelBufferVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IRpcChannelBuffer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IRpcChannelBuffer_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IRpcChannelBuffer_Release(This) (This)->lpVtbl->Release(This) +/*** IRpcChannelBuffer methods ***/ +#define IRpcChannelBuffer_GetBuffer(This,pMessage,riid) (This)->lpVtbl->GetBuffer(This,pMessage,riid) +#define IRpcChannelBuffer_SendReceive(This,pMessage,pStatus) (This)->lpVtbl->SendReceive(This,pMessage,pStatus) +#define IRpcChannelBuffer_FreeBuffer(This,pMessage) (This)->lpVtbl->FreeBuffer(This,pMessage) +#define IRpcChannelBuffer_GetDestCtx(This,pdwDestContext,ppvDestContext) (This)->lpVtbl->GetDestCtx(This,pdwDestContext,ppvDestContext) +#define IRpcChannelBuffer_IsConnected(This) (This)->lpVtbl->IsConnected(This) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IRpcChannelBuffer_GetBuffer_Proxy( + IRpcChannelBuffer* This, + RPCOLEMESSAGE *pMessage, + REFIID riid); +void __RPC_STUB IRpcChannelBuffer_GetBuffer_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRpcChannelBuffer_SendReceive_Proxy( + IRpcChannelBuffer* This, + RPCOLEMESSAGE *pMessage, + ULONG *pStatus); +void __RPC_STUB IRpcChannelBuffer_SendReceive_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRpcChannelBuffer_FreeBuffer_Proxy( + IRpcChannelBuffer* This, + RPCOLEMESSAGE *pMessage); +void __RPC_STUB IRpcChannelBuffer_FreeBuffer_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRpcChannelBuffer_GetDestCtx_Proxy( + IRpcChannelBuffer* This, + DWORD *pdwDestContext, + void **ppvDestContext); +void __RPC_STUB IRpcChannelBuffer_GetDestCtx_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRpcChannelBuffer_IsConnected_Proxy( + IRpcChannelBuffer* This); +void __RPC_STUB IRpcChannelBuffer_IsConnected_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IRpcChannelBuffer_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IRpcChannelBuffer2 interface + */ +#ifndef __IRpcChannelBuffer2_INTERFACE_DEFINED__ +#define __IRpcChannelBuffer2_INTERFACE_DEFINED__ + +typedef IRpcChannelBuffer2 *LPRPCCHANNELBUFFER2; +DEFINE_GUID(IID_IRpcChannelBuffer2, 0x594f31d0, 0x7f19, 0x11d0, 0xb1,0x94, 0x00,0xa0,0xc9,0x0d,0xc8,0xbf); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IRpcChannelBuffer2 : public IRpcChannelBuffer +{ + virtual HRESULT STDMETHODCALLTYPE GetProtocolVersion( + DWORD *pdwVersion) = 0; + +}; +#else +typedef struct IRpcChannelBuffer2Vtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IRpcChannelBuffer2* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IRpcChannelBuffer2* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IRpcChannelBuffer2* This); + + /*** IRpcChannelBuffer methods ***/ + HRESULT (STDMETHODCALLTYPE *GetBuffer)( + IRpcChannelBuffer2* This, + RPCOLEMESSAGE *pMessage, + REFIID riid); + + HRESULT (STDMETHODCALLTYPE *SendReceive)( + IRpcChannelBuffer2* This, + RPCOLEMESSAGE *pMessage, + ULONG *pStatus); + + HRESULT (STDMETHODCALLTYPE *FreeBuffer)( + IRpcChannelBuffer2* This, + RPCOLEMESSAGE *pMessage); + + HRESULT (STDMETHODCALLTYPE *GetDestCtx)( + IRpcChannelBuffer2* This, + DWORD *pdwDestContext, + void **ppvDestContext); + + HRESULT (STDMETHODCALLTYPE *IsConnected)( + IRpcChannelBuffer2* This); + + /*** IRpcChannelBuffer2 methods ***/ + HRESULT (STDMETHODCALLTYPE *GetProtocolVersion)( + IRpcChannelBuffer2* This, + DWORD *pdwVersion); + + END_INTERFACE +} IRpcChannelBuffer2Vtbl; +interface IRpcChannelBuffer2 { + CONST_VTBL IRpcChannelBuffer2Vtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IRpcChannelBuffer2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IRpcChannelBuffer2_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IRpcChannelBuffer2_Release(This) (This)->lpVtbl->Release(This) +/*** IRpcChannelBuffer methods ***/ +#define IRpcChannelBuffer2_GetBuffer(This,pMessage,riid) (This)->lpVtbl->GetBuffer(This,pMessage,riid) +#define IRpcChannelBuffer2_SendReceive(This,pMessage,pStatus) (This)->lpVtbl->SendReceive(This,pMessage,pStatus) +#define IRpcChannelBuffer2_FreeBuffer(This,pMessage) (This)->lpVtbl->FreeBuffer(This,pMessage) +#define IRpcChannelBuffer2_GetDestCtx(This,pdwDestContext,ppvDestContext) (This)->lpVtbl->GetDestCtx(This,pdwDestContext,ppvDestContext) +#define IRpcChannelBuffer2_IsConnected(This) (This)->lpVtbl->IsConnected(This) +/*** IRpcChannelBuffer2 methods ***/ +#define IRpcChannelBuffer2_GetProtocolVersion(This,pdwVersion) (This)->lpVtbl->GetProtocolVersion(This,pdwVersion) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IRpcChannelBuffer2_GetProtocolVersion_Proxy( + IRpcChannelBuffer2* This, + DWORD *pdwVersion); +void __RPC_STUB IRpcChannelBuffer2_GetProtocolVersion_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IRpcChannelBuffer2_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IRpcChannelBuffer3 interface + */ +#ifndef __IRpcChannelBuffer3_INTERFACE_DEFINED__ +#define __IRpcChannelBuffer3_INTERFACE_DEFINED__ + +typedef IRpcChannelBuffer3 *LPRPCCHANNELBUFFER3; +DEFINE_GUID(IID_IRpcChannelBuffer3, 0x25b15600, 0x0115, 0x11d0, 0xbf,0x0d, 0x00,0xaa,0x00,0xb8,0xdf,0xd2); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IRpcChannelBuffer3 : public IRpcChannelBuffer2 +{ + virtual HRESULT STDMETHODCALLTYPE Send( + RPCOLEMESSAGE *pMsg, + ULONG *pulStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE Receive( + RPCOLEMESSAGE *pMsg, + ULONG ulSize, + ULONG *pulStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE Cancel( + RPCOLEMESSAGE *pMsg) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCallContext( + RPCOLEMESSAGE *pMsg, + REFIID riid, + void **pInterface) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDestCtxEx( + RPCOLEMESSAGE *pMsg, + DWORD *pdwDestContext, + void **ppvDestContext) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetState( + RPCOLEMESSAGE *pMsg, + DWORD *pState) = 0; + + virtual HRESULT STDMETHODCALLTYPE RegisterAsync( + RPCOLEMESSAGE *pMsg, + IAsyncManager *pAsyncMgr) = 0; + +}; +#else +typedef struct IRpcChannelBuffer3Vtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IRpcChannelBuffer3* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IRpcChannelBuffer3* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IRpcChannelBuffer3* This); + + /*** IRpcChannelBuffer methods ***/ + HRESULT (STDMETHODCALLTYPE *GetBuffer)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE *pMessage, + REFIID riid); + + HRESULT (STDMETHODCALLTYPE *SendReceive)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE *pMessage, + ULONG *pStatus); + + HRESULT (STDMETHODCALLTYPE *FreeBuffer)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE *pMessage); + + HRESULT (STDMETHODCALLTYPE *GetDestCtx)( + IRpcChannelBuffer3* This, + DWORD *pdwDestContext, + void **ppvDestContext); + + HRESULT (STDMETHODCALLTYPE *IsConnected)( + IRpcChannelBuffer3* This); + + /*** IRpcChannelBuffer2 methods ***/ + HRESULT (STDMETHODCALLTYPE *GetProtocolVersion)( + IRpcChannelBuffer3* This, + DWORD *pdwVersion); + + /*** IRpcChannelBuffer3 methods ***/ + HRESULT (STDMETHODCALLTYPE *Send)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE *pMsg, + ULONG *pulStatus); + + HRESULT (STDMETHODCALLTYPE *Receive)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE *pMsg, + ULONG ulSize, + ULONG *pulStatus); + + HRESULT (STDMETHODCALLTYPE *Cancel)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE *pMsg); + + HRESULT (STDMETHODCALLTYPE *GetCallContext)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE *pMsg, + REFIID riid, + void **pInterface); + + HRESULT (STDMETHODCALLTYPE *GetDestCtxEx)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE *pMsg, + DWORD *pdwDestContext, + void **ppvDestContext); + + HRESULT (STDMETHODCALLTYPE *GetState)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE *pMsg, + DWORD *pState); + + HRESULT (STDMETHODCALLTYPE *RegisterAsync)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE *pMsg, + IAsyncManager *pAsyncMgr); + + END_INTERFACE +} IRpcChannelBuffer3Vtbl; +interface IRpcChannelBuffer3 { + CONST_VTBL IRpcChannelBuffer3Vtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IRpcChannelBuffer3_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IRpcChannelBuffer3_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IRpcChannelBuffer3_Release(This) (This)->lpVtbl->Release(This) +/*** IRpcChannelBuffer methods ***/ +#define IRpcChannelBuffer3_GetBuffer(This,pMessage,riid) (This)->lpVtbl->GetBuffer(This,pMessage,riid) +#define IRpcChannelBuffer3_SendReceive(This,pMessage,pStatus) (This)->lpVtbl->SendReceive(This,pMessage,pStatus) +#define IRpcChannelBuffer3_FreeBuffer(This,pMessage) (This)->lpVtbl->FreeBuffer(This,pMessage) +#define IRpcChannelBuffer3_GetDestCtx(This,pdwDestContext,ppvDestContext) (This)->lpVtbl->GetDestCtx(This,pdwDestContext,ppvDestContext) +#define IRpcChannelBuffer3_IsConnected(This) (This)->lpVtbl->IsConnected(This) +/*** IRpcChannelBuffer2 methods ***/ +#define IRpcChannelBuffer3_GetProtocolVersion(This,pdwVersion) (This)->lpVtbl->GetProtocolVersion(This,pdwVersion) +/*** IRpcChannelBuffer3 methods ***/ +#define IRpcChannelBuffer3_Send(This,pMsg,pulStatus) (This)->lpVtbl->Send(This,pMsg,pulStatus) +#define IRpcChannelBuffer3_Receive(This,pMsg,ulSize,pulStatus) (This)->lpVtbl->Receive(This,pMsg,ulSize,pulStatus) +#define IRpcChannelBuffer3_Cancel(This,pMsg) (This)->lpVtbl->Cancel(This,pMsg) +#define IRpcChannelBuffer3_GetCallContext(This,pMsg,riid,pInterface) (This)->lpVtbl->GetCallContext(This,pMsg,riid,pInterface) +#define IRpcChannelBuffer3_GetDestCtxEx(This,pMsg,pdwDestContext,ppvDestContext) (This)->lpVtbl->GetDestCtxEx(This,pMsg,pdwDestContext,ppvDestContext) +#define IRpcChannelBuffer3_GetState(This,pMsg,pState) (This)->lpVtbl->GetState(This,pMsg,pState) +#define IRpcChannelBuffer3_RegisterAsync(This,pMsg,pAsyncMgr) (This)->lpVtbl->RegisterAsync(This,pMsg,pAsyncMgr) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IRpcChannelBuffer3_Send_Proxy( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE *pMsg, + ULONG *pulStatus); +void __RPC_STUB IRpcChannelBuffer3_Send_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRpcChannelBuffer3_Receive_Proxy( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE *pMsg, + ULONG ulSize, + ULONG *pulStatus); +void __RPC_STUB IRpcChannelBuffer3_Receive_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRpcChannelBuffer3_Cancel_Proxy( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE *pMsg); +void __RPC_STUB IRpcChannelBuffer3_Cancel_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRpcChannelBuffer3_GetCallContext_Proxy( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE *pMsg, + REFIID riid, + void **pInterface); +void __RPC_STUB IRpcChannelBuffer3_GetCallContext_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRpcChannelBuffer3_GetDestCtxEx_Proxy( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE *pMsg, + DWORD *pdwDestContext, + void **ppvDestContext); +void __RPC_STUB IRpcChannelBuffer3_GetDestCtxEx_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRpcChannelBuffer3_GetState_Proxy( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE *pMsg, + DWORD *pState); +void __RPC_STUB IRpcChannelBuffer3_GetState_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRpcChannelBuffer3_RegisterAsync_Proxy( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE *pMsg, + IAsyncManager *pAsyncMgr); +void __RPC_STUB IRpcChannelBuffer3_RegisterAsync_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IRpcChannelBuffer3_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IAsyncRpcChannelBuffer interface + */ +#ifndef __IAsyncRpcChannelBuffer_INTERFACE_DEFINED__ +#define __IAsyncRpcChannelBuffer_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IAsyncRpcChannelBuffer, 0xa5029fb6, 0x3c34, 0x11d1, 0x9c,0x99, 0x00,0xc0,0x4f,0xb9,0x98,0xaa); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IAsyncRpcChannelBuffer : public IRpcChannelBuffer2 +{ + virtual HRESULT STDMETHODCALLTYPE Send( + RPCOLEMESSAGE *pMsg, + ISynchronize *pSync, + ULONG *pulStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE Receive( + RPCOLEMESSAGE *pMsg, + ULONG *pulStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDestCtxEx( + RPCOLEMESSAGE *pMsg, + DWORD *pdwDestContext, + void **ppvDestContext) = 0; + +}; +#else +typedef struct IAsyncRpcChannelBufferVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IAsyncRpcChannelBuffer* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IAsyncRpcChannelBuffer* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IAsyncRpcChannelBuffer* This); + + /*** IRpcChannelBuffer methods ***/ + HRESULT (STDMETHODCALLTYPE *GetBuffer)( + IAsyncRpcChannelBuffer* This, + RPCOLEMESSAGE *pMessage, + REFIID riid); + + HRESULT (STDMETHODCALLTYPE *SendReceive)( + IAsyncRpcChannelBuffer* This, + RPCOLEMESSAGE *pMessage, + ULONG *pStatus); + + HRESULT (STDMETHODCALLTYPE *FreeBuffer)( + IAsyncRpcChannelBuffer* This, + RPCOLEMESSAGE *pMessage); + + HRESULT (STDMETHODCALLTYPE *GetDestCtx)( + IAsyncRpcChannelBuffer* This, + DWORD *pdwDestContext, + void **ppvDestContext); + + HRESULT (STDMETHODCALLTYPE *IsConnected)( + IAsyncRpcChannelBuffer* This); + + /*** IRpcChannelBuffer2 methods ***/ + HRESULT (STDMETHODCALLTYPE *GetProtocolVersion)( + IAsyncRpcChannelBuffer* This, + DWORD *pdwVersion); + + /*** IAsyncRpcChannelBuffer methods ***/ + HRESULT (STDMETHODCALLTYPE *Send)( + IAsyncRpcChannelBuffer* This, + RPCOLEMESSAGE *pMsg, + ISynchronize *pSync, + ULONG *pulStatus); + + HRESULT (STDMETHODCALLTYPE *Receive)( + IAsyncRpcChannelBuffer* This, + RPCOLEMESSAGE *pMsg, + ULONG *pulStatus); + + HRESULT (STDMETHODCALLTYPE *GetDestCtxEx)( + IAsyncRpcChannelBuffer* This, + RPCOLEMESSAGE *pMsg, + DWORD *pdwDestContext, + void **ppvDestContext); + + END_INTERFACE +} IAsyncRpcChannelBufferVtbl; +interface IAsyncRpcChannelBuffer { + CONST_VTBL IAsyncRpcChannelBufferVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IAsyncRpcChannelBuffer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IAsyncRpcChannelBuffer_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IAsyncRpcChannelBuffer_Release(This) (This)->lpVtbl->Release(This) +/*** IRpcChannelBuffer methods ***/ +#define IAsyncRpcChannelBuffer_GetBuffer(This,pMessage,riid) (This)->lpVtbl->GetBuffer(This,pMessage,riid) +#define IAsyncRpcChannelBuffer_SendReceive(This,pMessage,pStatus) (This)->lpVtbl->SendReceive(This,pMessage,pStatus) +#define IAsyncRpcChannelBuffer_FreeBuffer(This,pMessage) (This)->lpVtbl->FreeBuffer(This,pMessage) +#define IAsyncRpcChannelBuffer_GetDestCtx(This,pdwDestContext,ppvDestContext) (This)->lpVtbl->GetDestCtx(This,pdwDestContext,ppvDestContext) +#define IAsyncRpcChannelBuffer_IsConnected(This) (This)->lpVtbl->IsConnected(This) +/*** IRpcChannelBuffer2 methods ***/ +#define IAsyncRpcChannelBuffer_GetProtocolVersion(This,pdwVersion) (This)->lpVtbl->GetProtocolVersion(This,pdwVersion) +/*** IAsyncRpcChannelBuffer methods ***/ +#define IAsyncRpcChannelBuffer_Send(This,pMsg,pSync,pulStatus) (This)->lpVtbl->Send(This,pMsg,pSync,pulStatus) +#define IAsyncRpcChannelBuffer_Receive(This,pMsg,pulStatus) (This)->lpVtbl->Receive(This,pMsg,pulStatus) +#define IAsyncRpcChannelBuffer_GetDestCtxEx(This,pMsg,pdwDestContext,ppvDestContext) (This)->lpVtbl->GetDestCtxEx(This,pMsg,pdwDestContext,ppvDestContext) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IAsyncRpcChannelBuffer_Send_Proxy( + IAsyncRpcChannelBuffer* This, + RPCOLEMESSAGE *pMsg, + ISynchronize *pSync, + ULONG *pulStatus); +void __RPC_STUB IAsyncRpcChannelBuffer_Send_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAsyncRpcChannelBuffer_Receive_Proxy( + IAsyncRpcChannelBuffer* This, + RPCOLEMESSAGE *pMsg, + ULONG *pulStatus); +void __RPC_STUB IAsyncRpcChannelBuffer_Receive_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAsyncRpcChannelBuffer_GetDestCtxEx_Proxy( + IAsyncRpcChannelBuffer* This, + RPCOLEMESSAGE *pMsg, + DWORD *pdwDestContext, + void **ppvDestContext); +void __RPC_STUB IAsyncRpcChannelBuffer_GetDestCtxEx_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IAsyncRpcChannelBuffer_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IRpcSyntaxNegotiate interface + */ +#ifndef __IRpcSyntaxNegotiate_INTERFACE_DEFINED__ +#define __IRpcSyntaxNegotiate_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IRpcSyntaxNegotiate, 0x58a08519, 0x24c8, 0x4935, 0xb4,0x82, 0x3f,0xd8,0x23,0x33,0x3a,0x4f); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IRpcSyntaxNegotiate : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE NegotiateSyntax( + RPCOLEMESSAGE *pMsg) = 0; + +}; +#else +typedef struct IRpcSyntaxNegotiateVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IRpcSyntaxNegotiate* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IRpcSyntaxNegotiate* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IRpcSyntaxNegotiate* This); + + /*** IRpcSyntaxNegotiate methods ***/ + HRESULT (STDMETHODCALLTYPE *NegotiateSyntax)( + IRpcSyntaxNegotiate* This, + RPCOLEMESSAGE *pMsg); + + END_INTERFACE +} IRpcSyntaxNegotiateVtbl; +interface IRpcSyntaxNegotiate { + CONST_VTBL IRpcSyntaxNegotiateVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IRpcSyntaxNegotiate_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IRpcSyntaxNegotiate_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IRpcSyntaxNegotiate_Release(This) (This)->lpVtbl->Release(This) +/*** IRpcSyntaxNegotiate methods ***/ +#define IRpcSyntaxNegotiate_NegotiateSyntax(This,pMsg) (This)->lpVtbl->NegotiateSyntax(This,pMsg) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IRpcSyntaxNegotiate_NegotiateSyntax_Proxy( + IRpcSyntaxNegotiate* This, + RPCOLEMESSAGE *pMsg); +void __RPC_STUB IRpcSyntaxNegotiate_NegotiateSyntax_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IRpcSyntaxNegotiate_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IRpcProxyBuffer interface + */ +#ifndef __IRpcProxyBuffer_INTERFACE_DEFINED__ +#define __IRpcProxyBuffer_INTERFACE_DEFINED__ + +typedef IRpcProxyBuffer *LPRPCPROXYBUFFER; +DEFINE_GUID(IID_IRpcProxyBuffer, 0xd5f56a34, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IRpcProxyBuffer : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Connect( + IRpcChannelBuffer *pRpcChannelBuffer) = 0; + + virtual void STDMETHODCALLTYPE Disconnect( + ) = 0; + +}; +#else +typedef struct IRpcProxyBufferVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IRpcProxyBuffer* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IRpcProxyBuffer* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IRpcProxyBuffer* This); + + /*** IRpcProxyBuffer methods ***/ + HRESULT (STDMETHODCALLTYPE *Connect)( + IRpcProxyBuffer* This, + IRpcChannelBuffer *pRpcChannelBuffer); + + void (STDMETHODCALLTYPE *Disconnect)( + IRpcProxyBuffer* This); + + END_INTERFACE +} IRpcProxyBufferVtbl; +interface IRpcProxyBuffer { + CONST_VTBL IRpcProxyBufferVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IRpcProxyBuffer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IRpcProxyBuffer_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IRpcProxyBuffer_Release(This) (This)->lpVtbl->Release(This) +/*** IRpcProxyBuffer methods ***/ +#define IRpcProxyBuffer_Connect(This,pRpcChannelBuffer) (This)->lpVtbl->Connect(This,pRpcChannelBuffer) +#define IRpcProxyBuffer_Disconnect(This) (This)->lpVtbl->Disconnect(This) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IRpcProxyBuffer_Connect_Proxy( + IRpcProxyBuffer* This, + IRpcChannelBuffer *pRpcChannelBuffer); +void __RPC_STUB IRpcProxyBuffer_Connect_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IRpcProxyBuffer_Disconnect_Proxy( + IRpcProxyBuffer* This); +void __RPC_STUB IRpcProxyBuffer_Disconnect_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IRpcProxyBuffer_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IRpcStubBuffer interface + */ +#ifndef __IRpcStubBuffer_INTERFACE_DEFINED__ +#define __IRpcStubBuffer_INTERFACE_DEFINED__ + +typedef IRpcStubBuffer *LPRPCSTUBBUFFER; +DEFINE_GUID(IID_IRpcStubBuffer, 0xd5f56afc, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IRpcStubBuffer : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Connect( + IUnknown *pUnkServer) = 0; + + virtual void STDMETHODCALLTYPE Disconnect( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Invoke( + RPCOLEMESSAGE *_prpcmsg, + IRpcChannelBuffer *_pRpcChannelBuffer) = 0; + + virtual IRpcStubBuffer * STDMETHODCALLTYPE IsIIDSupported( + REFIID riid) = 0; + + virtual ULONG STDMETHODCALLTYPE CountRefs( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE DebugServerQueryInterface( + void **ppv) = 0; + + virtual void STDMETHODCALLTYPE DebugServerRelease( + void *pv) = 0; + +}; +#else +typedef struct IRpcStubBufferVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IRpcStubBuffer* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IRpcStubBuffer* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IRpcStubBuffer* This); + + /*** IRpcStubBuffer methods ***/ + HRESULT (STDMETHODCALLTYPE *Connect)( + IRpcStubBuffer* This, + IUnknown *pUnkServer); + + void (STDMETHODCALLTYPE *Disconnect)( + IRpcStubBuffer* This); + + HRESULT (STDMETHODCALLTYPE *Invoke)( + IRpcStubBuffer* This, + RPCOLEMESSAGE *_prpcmsg, + IRpcChannelBuffer *_pRpcChannelBuffer); + + IRpcStubBuffer * (STDMETHODCALLTYPE *IsIIDSupported)( + IRpcStubBuffer* This, + REFIID riid); + + ULONG (STDMETHODCALLTYPE *CountRefs)( + IRpcStubBuffer* This); + + HRESULT (STDMETHODCALLTYPE *DebugServerQueryInterface)( + IRpcStubBuffer* This, + void **ppv); + + void (STDMETHODCALLTYPE *DebugServerRelease)( + IRpcStubBuffer* This, + void *pv); + + END_INTERFACE +} IRpcStubBufferVtbl; +interface IRpcStubBuffer { + CONST_VTBL IRpcStubBufferVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IRpcStubBuffer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IRpcStubBuffer_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IRpcStubBuffer_Release(This) (This)->lpVtbl->Release(This) +/*** IRpcStubBuffer methods ***/ +#define IRpcStubBuffer_Connect(This,pUnkServer) (This)->lpVtbl->Connect(This,pUnkServer) +#define IRpcStubBuffer_Disconnect(This) (This)->lpVtbl->Disconnect(This) +#define IRpcStubBuffer_Invoke(This,_prpcmsg,_pRpcChannelBuffer) (This)->lpVtbl->Invoke(This,_prpcmsg,_pRpcChannelBuffer) +#define IRpcStubBuffer_IsIIDSupported(This,riid) (This)->lpVtbl->IsIIDSupported(This,riid) +#define IRpcStubBuffer_CountRefs(This) (This)->lpVtbl->CountRefs(This) +#define IRpcStubBuffer_DebugServerQueryInterface(This,ppv) (This)->lpVtbl->DebugServerQueryInterface(This,ppv) +#define IRpcStubBuffer_DebugServerRelease(This,pv) (This)->lpVtbl->DebugServerRelease(This,pv) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IRpcStubBuffer_Connect_Proxy( + IRpcStubBuffer* This, + IUnknown *pUnkServer); +void __RPC_STUB IRpcStubBuffer_Connect_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IRpcStubBuffer_Disconnect_Proxy( + IRpcStubBuffer* This); +void __RPC_STUB IRpcStubBuffer_Disconnect_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRpcStubBuffer_Invoke_Proxy( + IRpcStubBuffer* This, + RPCOLEMESSAGE *_prpcmsg, + IRpcChannelBuffer *_pRpcChannelBuffer); +void __RPC_STUB IRpcStubBuffer_Invoke_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +IRpcStubBuffer * STDMETHODCALLTYPE IRpcStubBuffer_IsIIDSupported_Proxy( + IRpcStubBuffer* This, + REFIID riid); +void __RPC_STUB IRpcStubBuffer_IsIIDSupported_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +ULONG STDMETHODCALLTYPE IRpcStubBuffer_CountRefs_Proxy( + IRpcStubBuffer* This); +void __RPC_STUB IRpcStubBuffer_CountRefs_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRpcStubBuffer_DebugServerQueryInterface_Proxy( + IRpcStubBuffer* This, + void **ppv); +void __RPC_STUB IRpcStubBuffer_DebugServerQueryInterface_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IRpcStubBuffer_DebugServerRelease_Proxy( + IRpcStubBuffer* This, + void *pv); +void __RPC_STUB IRpcStubBuffer_DebugServerRelease_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IRpcStubBuffer_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IPSFactoryBuffer interface + */ +#ifndef __IPSFactoryBuffer_INTERFACE_DEFINED__ +#define __IPSFactoryBuffer_INTERFACE_DEFINED__ + +typedef IPSFactoryBuffer *LPPSFACTORYBUFFER; +DEFINE_GUID(IID_IPSFactoryBuffer, 0xd5f569d0, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IPSFactoryBuffer : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE CreateProxy( + IUnknown *pUnkOuter, + REFIID riid, + IRpcProxyBuffer **ppProxy, + void **ppv) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateStub( + REFIID riid, + IUnknown *pUnkServer, + IRpcStubBuffer **ppStub) = 0; + +}; +#else +typedef struct IPSFactoryBufferVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPSFactoryBuffer* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPSFactoryBuffer* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPSFactoryBuffer* This); + + /*** IPSFactoryBuffer methods ***/ + HRESULT (STDMETHODCALLTYPE *CreateProxy)( + IPSFactoryBuffer* This, + IUnknown *pUnkOuter, + REFIID riid, + IRpcProxyBuffer **ppProxy, + void **ppv); + + HRESULT (STDMETHODCALLTYPE *CreateStub)( + IPSFactoryBuffer* This, + REFIID riid, + IUnknown *pUnkServer, + IRpcStubBuffer **ppStub); + + END_INTERFACE +} IPSFactoryBufferVtbl; +interface IPSFactoryBuffer { + CONST_VTBL IPSFactoryBufferVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IPSFactoryBuffer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IPSFactoryBuffer_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IPSFactoryBuffer_Release(This) (This)->lpVtbl->Release(This) +/*** IPSFactoryBuffer methods ***/ +#define IPSFactoryBuffer_CreateProxy(This,pUnkOuter,riid,ppProxy,ppv) (This)->lpVtbl->CreateProxy(This,pUnkOuter,riid,ppProxy,ppv) +#define IPSFactoryBuffer_CreateStub(This,riid,pUnkServer,ppStub) (This)->lpVtbl->CreateStub(This,riid,pUnkServer,ppStub) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IPSFactoryBuffer_CreateProxy_Proxy( + IPSFactoryBuffer* This, + IUnknown *pUnkOuter, + REFIID riid, + IRpcProxyBuffer **ppProxy, + void **ppv); +void __RPC_STUB IPSFactoryBuffer_CreateProxy_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPSFactoryBuffer_CreateStub_Proxy( + IPSFactoryBuffer* This, + REFIID riid, + IUnknown *pUnkServer, + IRpcStubBuffer **ppStub); +void __RPC_STUB IPSFactoryBuffer_CreateStub_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPSFactoryBuffer_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IChannelHook interface + */ +#ifndef __IChannelHook_INTERFACE_DEFINED__ +#define __IChannelHook_INTERFACE_DEFINED__ + +typedef IChannelHook *LPCHANNELHOOK; +typedef struct SChannelHookCallInfo { + IID iid; + DWORD cbSize; + GUID uCausality; + DWORD dwServerPid; + DWORD iMethod; + void *pObject; +} SChannelHookCallInfo; +DEFINE_GUID(IID_IChannelHook, 0x1008c4a0, 0x7613, 0x11cf, 0x9a,0xf1, 0x00,0x20,0xaf,0x6e,0x72,0xf4); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IChannelHook : public IUnknown +{ + virtual void STDMETHODCALLTYPE ClientGetSize( + REFGUID uExtent, + REFIID riid, + ULONG *pDataSize) = 0; + + virtual void STDMETHODCALLTYPE ClientFillBuffer( + REFGUID uExtent, + REFIID riid, + ULONG *pDataSize, + void *pDataBuffer) = 0; + + virtual void STDMETHODCALLTYPE ClientNotify( + REFGUID uExtent, + REFIID riid, + ULONG cbDataSize, + void *pDataBuffer, + DWORD lDataRep, + HRESULT hrFault) = 0; + + virtual void STDMETHODCALLTYPE ServerNotify( + REFGUID uExtent, + REFIID riid, + ULONG cbDataSize, + void *pDataBuffer, + DWORD lDataRep) = 0; + + virtual void STDMETHODCALLTYPE ServerGetSize( + REFGUID uExtent, + REFIID riid, + HRESULT hrFault, + ULONG *pDataSize) = 0; + + virtual void STDMETHODCALLTYPE ServerFillBuffer( + REFGUID uExtent, + REFIID riid, + ULONG *pDataSize, + void *pDataBuffer, + HRESULT hrFault) = 0; + +}; +#else +typedef struct IChannelHookVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IChannelHook* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IChannelHook* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IChannelHook* This); + + /*** IChannelHook methods ***/ + void (STDMETHODCALLTYPE *ClientGetSize)( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG *pDataSize); + + void (STDMETHODCALLTYPE *ClientFillBuffer)( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG *pDataSize, + void *pDataBuffer); + + void (STDMETHODCALLTYPE *ClientNotify)( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG cbDataSize, + void *pDataBuffer, + DWORD lDataRep, + HRESULT hrFault); + + void (STDMETHODCALLTYPE *ServerNotify)( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG cbDataSize, + void *pDataBuffer, + DWORD lDataRep); + + void (STDMETHODCALLTYPE *ServerGetSize)( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + HRESULT hrFault, + ULONG *pDataSize); + + void (STDMETHODCALLTYPE *ServerFillBuffer)( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG *pDataSize, + void *pDataBuffer, + HRESULT hrFault); + + END_INTERFACE +} IChannelHookVtbl; +interface IChannelHook { + CONST_VTBL IChannelHookVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IChannelHook_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IChannelHook_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IChannelHook_Release(This) (This)->lpVtbl->Release(This) +/*** IChannelHook methods ***/ +#define IChannelHook_ClientGetSize(This,uExtent,riid,pDataSize) (This)->lpVtbl->ClientGetSize(This,uExtent,riid,pDataSize) +#define IChannelHook_ClientFillBuffer(This,uExtent,riid,pDataSize,pDataBuffer) (This)->lpVtbl->ClientFillBuffer(This,uExtent,riid,pDataSize,pDataBuffer) +#define IChannelHook_ClientNotify(This,uExtent,riid,cbDataSize,pDataBuffer,lDataRep,hrFault) (This)->lpVtbl->ClientNotify(This,uExtent,riid,cbDataSize,pDataBuffer,lDataRep,hrFault) +#define IChannelHook_ServerNotify(This,uExtent,riid,cbDataSize,pDataBuffer,lDataRep) (This)->lpVtbl->ServerNotify(This,uExtent,riid,cbDataSize,pDataBuffer,lDataRep) +#define IChannelHook_ServerGetSize(This,uExtent,riid,hrFault,pDataSize) (This)->lpVtbl->ServerGetSize(This,uExtent,riid,hrFault,pDataSize) +#define IChannelHook_ServerFillBuffer(This,uExtent,riid,pDataSize,pDataBuffer,hrFault) (This)->lpVtbl->ServerFillBuffer(This,uExtent,riid,pDataSize,pDataBuffer,hrFault) +#endif + +#endif + +void STDMETHODCALLTYPE IChannelHook_ClientGetSize_Proxy( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG *pDataSize); +void __RPC_STUB IChannelHook_ClientGetSize_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IChannelHook_ClientFillBuffer_Proxy( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG *pDataSize, + void *pDataBuffer); +void __RPC_STUB IChannelHook_ClientFillBuffer_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IChannelHook_ClientNotify_Proxy( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG cbDataSize, + void *pDataBuffer, + DWORD lDataRep, + HRESULT hrFault); +void __RPC_STUB IChannelHook_ClientNotify_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IChannelHook_ServerNotify_Proxy( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG cbDataSize, + void *pDataBuffer, + DWORD lDataRep); +void __RPC_STUB IChannelHook_ServerNotify_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IChannelHook_ServerGetSize_Proxy( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + HRESULT hrFault, + ULONG *pDataSize); +void __RPC_STUB IChannelHook_ServerGetSize_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IChannelHook_ServerFillBuffer_Proxy( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG *pDataSize, + void *pDataBuffer, + HRESULT hrFault); +void __RPC_STUB IChannelHook_ServerFillBuffer_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IChannelHook_INTERFACE_DEFINED__ */ + +extern const FMTID FMTID_SummaryInformation; + +extern const FMTID FMTID_DocSummaryInformation; + +extern const FMTID FMTID_UserDefinedProperties; + +/***************************************************************************** + * IClientSecurity interface + */ +#ifndef __IClientSecurity_INTERFACE_DEFINED__ +#define __IClientSecurity_INTERFACE_DEFINED__ + +typedef struct tagSOLE_AUTHENTICATION_SERVICE { + DWORD dwAuthnSvc; + DWORD dwAuthzSvc; + OLECHAR *pPrincipalName; + HRESULT hr; +} SOLE_AUTHENTICATION_SERVICE; +typedef SOLE_AUTHENTICATION_SERVICE *PSOLE_AUTHENTICATION_SERVICE; +typedef struct tagSOLE_AUTHENTICATION_INFO { + DWORD dwAuthnSvc; + DWORD dwAuthzSvc; + void *pAuthInfo; +} SOLE_AUTHENTICATION_INFO; +#define COLE_DEFAULT_PRINCIPAL ((OLECHAR *)-1) + +#define COLE_DEFAULT_AUTHINFO ((void *)-1) + +typedef struct tagSOLE_AUTHENTICATION_LIST { + DWORD cAuthInfo; + SOLE_AUTHENTICATION_INFO *aAuthInfo; +} SOLE_AUTHENTICATION_LIST; +typedef enum tagEOLE_AUTHENTICATION_CAPABILITIES { + EOAC_NONE = 0x0, + EOAC_MUTUAL_AUTH = 0x1, + EOAC_SECURE_REFS = 0x2, + EOAC_ACCESS_CONTROL = 0x4, + EOAC_APPID = 0x8, + EOAC_DYNAMIC = 0x10, + EOAC_STATIC_CLOAKING = 0x20, + EOAC_DYNAMIC_CLOAKING = 0x40, + EOAC_ANY_AUTHORITY = 0x80, + EOAC_MAKE_FULLSIC = 0x100, + EOAC_REQUIRE_FULLSIC = 0x200, + EOAC_AUTO_IMPERSONATE = 0x400, + EOAC_DEFAULT = 0x800, + EOAC_DISABLE_AAA = 0x1000, + EOAC_NO_CUSTOM_MARSHAL = 0x2000 +} EOLE_AUTHENTICATION_CAPABILITIES; +DEFINE_GUID(IID_IClientSecurity, 0x0000013d, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IClientSecurity : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE QueryBlanket( + IUnknown *pProxy, + DWORD *pAuthnSvc, + DWORD *pAuthzSvc, + OLECHAR **pServerPrincName, + DWORD *pAuthnLevel, + DWORD *pImpLevel, + void **pAuthInfo, + DWORD *pCapabilities) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetBlanket( + IUnknown *pProxy, + DWORD AuthnSvc, + DWORD AuthzSvc, + OLECHAR *pServerPrincName, + DWORD AuthnLevel, + DWORD ImpLevel, + void *pAuthInfo, + DWORD Capabilities) = 0; + + virtual HRESULT STDMETHODCALLTYPE CopyProxy( + IUnknown *pProxy, + IUnknown **ppCopy) = 0; + +}; +#else +typedef struct IClientSecurityVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IClientSecurity* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IClientSecurity* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IClientSecurity* This); + + /*** IClientSecurity methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryBlanket)( + IClientSecurity* This, + IUnknown *pProxy, + DWORD *pAuthnSvc, + DWORD *pAuthzSvc, + OLECHAR **pServerPrincName, + DWORD *pAuthnLevel, + DWORD *pImpLevel, + void **pAuthInfo, + DWORD *pCapabilities); + + HRESULT (STDMETHODCALLTYPE *SetBlanket)( + IClientSecurity* This, + IUnknown *pProxy, + DWORD AuthnSvc, + DWORD AuthzSvc, + OLECHAR *pServerPrincName, + DWORD AuthnLevel, + DWORD ImpLevel, + void *pAuthInfo, + DWORD Capabilities); + + HRESULT (STDMETHODCALLTYPE *CopyProxy)( + IClientSecurity* This, + IUnknown *pProxy, + IUnknown **ppCopy); + + END_INTERFACE +} IClientSecurityVtbl; +interface IClientSecurity { + CONST_VTBL IClientSecurityVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IClientSecurity_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IClientSecurity_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IClientSecurity_Release(This) (This)->lpVtbl->Release(This) +/*** IClientSecurity methods ***/ +#define IClientSecurity_QueryBlanket(This,pProxy,pAuthnSvc,pAuthzSvc,pServerPrincName,pAuthnLevel,pImpLevel,pAuthInfo,pCapabilities) (This)->lpVtbl->QueryBlanket(This,pProxy,pAuthnSvc,pAuthzSvc,pServerPrincName,pAuthnLevel,pImpLevel,pAuthInfo,pCapabilities) +#define IClientSecurity_SetBlanket(This,pProxy,AuthnSvc,AuthzSvc,pServerPrincName,AuthnLevel,ImpLevel,pAuthInfo,Capabilities) (This)->lpVtbl->SetBlanket(This,pProxy,AuthnSvc,AuthzSvc,pServerPrincName,AuthnLevel,ImpLevel,pAuthInfo,Capabilities) +#define IClientSecurity_CopyProxy(This,pProxy,ppCopy) (This)->lpVtbl->CopyProxy(This,pProxy,ppCopy) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IClientSecurity_QueryBlanket_Proxy( + IClientSecurity* This, + IUnknown *pProxy, + DWORD *pAuthnSvc, + DWORD *pAuthzSvc, + OLECHAR **pServerPrincName, + DWORD *pAuthnLevel, + DWORD *pImpLevel, + void **pAuthInfo, + DWORD *pCapabilities); +void __RPC_STUB IClientSecurity_QueryBlanket_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE 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( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IClientSecurity_CopyProxy_Proxy( + IClientSecurity* This, + IUnknown *pProxy, + IUnknown **ppCopy); +void __RPC_STUB IClientSecurity_CopyProxy_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IClientSecurity_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IServerSecurity interface + */ +#ifndef __IServerSecurity_INTERFACE_DEFINED__ +#define __IServerSecurity_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IServerSecurity, 0x0000013e, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IServerSecurity : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE QueryBlanket( + DWORD *pAuthnSvc, + DWORD *pAuthzSvc, + OLECHAR **pServerPrincName, + DWORD *pAuthnLevel, + DWORD *pImpLevel, + void **pPrivs, + DWORD *pCapabilities) = 0; + + virtual HRESULT STDMETHODCALLTYPE ImpersonateClient( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE RevertToSelf( + ) = 0; + + virtual BOOL STDMETHODCALLTYPE IsImpersonating( + ) = 0; + +}; +#else +typedef struct IServerSecurityVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IServerSecurity* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IServerSecurity* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IServerSecurity* This); + + /*** IServerSecurity methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryBlanket)( + IServerSecurity* This, + DWORD *pAuthnSvc, + DWORD *pAuthzSvc, + OLECHAR **pServerPrincName, + DWORD *pAuthnLevel, + DWORD *pImpLevel, + void **pPrivs, + DWORD *pCapabilities); + + HRESULT (STDMETHODCALLTYPE *ImpersonateClient)( + IServerSecurity* This); + + HRESULT (STDMETHODCALLTYPE *RevertToSelf)( + IServerSecurity* This); + + BOOL (STDMETHODCALLTYPE *IsImpersonating)( + IServerSecurity* This); + + END_INTERFACE +} IServerSecurityVtbl; +interface IServerSecurity { + CONST_VTBL IServerSecurityVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IServerSecurity_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IServerSecurity_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IServerSecurity_Release(This) (This)->lpVtbl->Release(This) +/*** IServerSecurity methods ***/ +#define IServerSecurity_QueryBlanket(This,pAuthnSvc,pAuthzSvc,pServerPrincName,pAuthnLevel,pImpLevel,pPrivs,pCapabilities) (This)->lpVtbl->QueryBlanket(This,pAuthnSvc,pAuthzSvc,pServerPrincName,pAuthnLevel,pImpLevel,pPrivs,pCapabilities) +#define IServerSecurity_ImpersonateClient(This) (This)->lpVtbl->ImpersonateClient(This) +#define IServerSecurity_RevertToSelf(This) (This)->lpVtbl->RevertToSelf(This) +#define IServerSecurity_IsImpersonating(This) (This)->lpVtbl->IsImpersonating(This) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE 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( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IServerSecurity_ImpersonateClient_Proxy( + IServerSecurity* This); +void __RPC_STUB IServerSecurity_ImpersonateClient_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IServerSecurity_RevertToSelf_Proxy( + IServerSecurity* This); +void __RPC_STUB IServerSecurity_RevertToSelf_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +BOOL STDMETHODCALLTYPE IServerSecurity_IsImpersonating_Proxy( + IServerSecurity* This); +void __RPC_STUB IServerSecurity_IsImpersonating_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IServerSecurity_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IAsyncSetup interface + */ +#ifndef __IAsyncSetup_INTERFACE_DEFINED__ +#define __IAsyncSetup_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IAsyncSetup, 0x00000024, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IAsyncSetup : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetAsyncManager( + REFIID riid, + IUnknown *pOuter, + DWORD dwFlags, + IUnknown **ppInner, + IAsyncManager **ppAsyncMgr) = 0; + +}; +#else +typedef struct IAsyncSetupVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IAsyncSetup* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IAsyncSetup* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IAsyncSetup* This); + + /*** IAsyncSetup methods ***/ + HRESULT (STDMETHODCALLTYPE *GetAsyncManager)( + IAsyncSetup* This, + REFIID riid, + IUnknown *pOuter, + DWORD dwFlags, + IUnknown **ppInner, + IAsyncManager **ppAsyncMgr); + + END_INTERFACE +} IAsyncSetupVtbl; +interface IAsyncSetup { + CONST_VTBL IAsyncSetupVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IAsyncSetup_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IAsyncSetup_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IAsyncSetup_Release(This) (This)->lpVtbl->Release(This) +/*** IAsyncSetup methods ***/ +#define IAsyncSetup_GetAsyncManager(This,riid,pOuter,dwFlags,ppInner,ppAsyncMgr) (This)->lpVtbl->GetAsyncManager(This,riid,pOuter,dwFlags,ppInner,ppAsyncMgr) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IAsyncSetup_GetAsyncManager_Proxy( + IAsyncSetup* This, + REFIID riid, + IUnknown *pOuter, + DWORD dwFlags, + IUnknown **ppInner, + IAsyncManager **ppAsyncMgr); +void __RPC_STUB IAsyncSetup_GetAsyncManager_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IAsyncSetup_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IDirectWriterLock interface + */ +#ifndef __IDirectWriterLock_INTERFACE_DEFINED__ +#define __IDirectWriterLock_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IDirectWriterLock, 0x0e6d4d92, 0x6738, 0x11cf, 0x96,0x08, 0x00,0xaa,0x00,0x68,0x0d,0xb4); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IDirectWriterLock : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE WaitForWriteAccess( + DWORD dwTimeout) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReleaseWriteAccess( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE HaveWriteAccess( + ) = 0; + +}; +#else +typedef struct IDirectWriterLockVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IDirectWriterLock* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IDirectWriterLock* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IDirectWriterLock* This); + + /*** IDirectWriterLock methods ***/ + HRESULT (STDMETHODCALLTYPE *WaitForWriteAccess)( + IDirectWriterLock* This, + DWORD dwTimeout); + + HRESULT (STDMETHODCALLTYPE *ReleaseWriteAccess)( + IDirectWriterLock* This); + + HRESULT (STDMETHODCALLTYPE *HaveWriteAccess)( + IDirectWriterLock* This); + + END_INTERFACE +} IDirectWriterLockVtbl; +interface IDirectWriterLock { + CONST_VTBL IDirectWriterLockVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IDirectWriterLock_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IDirectWriterLock_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IDirectWriterLock_Release(This) (This)->lpVtbl->Release(This) +/*** IDirectWriterLock methods ***/ +#define IDirectWriterLock_WaitForWriteAccess(This,dwTimeout) (This)->lpVtbl->WaitForWriteAccess(This,dwTimeout) +#define IDirectWriterLock_ReleaseWriteAccess(This) (This)->lpVtbl->ReleaseWriteAccess(This) +#define IDirectWriterLock_HaveWriteAccess(This) (This)->lpVtbl->HaveWriteAccess(This) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IDirectWriterLock_WaitForWriteAccess_Proxy( + IDirectWriterLock* This, + DWORD dwTimeout); +void __RPC_STUB IDirectWriterLock_WaitForWriteAccess_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IDirectWriterLock_ReleaseWriteAccess_Proxy( + IDirectWriterLock* This); +void __RPC_STUB IDirectWriterLock_ReleaseWriteAccess_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IDirectWriterLock_HaveWriteAccess_Proxy( + IDirectWriterLock* This); +void __RPC_STUB IDirectWriterLock_HaveWriteAccess_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IDirectWriterLock_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * ISynchronize interface + */ +#ifndef __ISynchronize_INTERFACE_DEFINED__ +#define __ISynchronize_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_ISynchronize, 0x00000030, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface ISynchronize : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Wait( + DWORD dwFlags, + DWORD dwMilliseconds) = 0; + + virtual HRESULT STDMETHODCALLTYPE Signal( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( + ) = 0; + +}; +#else +typedef struct ISynchronizeVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ISynchronize* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ISynchronize* This); + + ULONG (STDMETHODCALLTYPE *Release)( + ISynchronize* This); + + /*** ISynchronize methods ***/ + HRESULT (STDMETHODCALLTYPE *Wait)( + ISynchronize* This, + DWORD dwFlags, + DWORD dwMilliseconds); + + HRESULT (STDMETHODCALLTYPE *Signal)( + ISynchronize* This); + + HRESULT (STDMETHODCALLTYPE *Reset)( + ISynchronize* This); + + END_INTERFACE +} ISynchronizeVtbl; +interface ISynchronize { + CONST_VTBL ISynchronizeVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define ISynchronize_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define ISynchronize_AddRef(This) (This)->lpVtbl->AddRef(This) +#define ISynchronize_Release(This) (This)->lpVtbl->Release(This) +/*** ISynchronize methods ***/ +#define ISynchronize_Wait(This,dwFlags,dwMilliseconds) (This)->lpVtbl->Wait(This,dwFlags,dwMilliseconds) +#define ISynchronize_Signal(This) (This)->lpVtbl->Signal(This) +#define ISynchronize_Reset(This) (This)->lpVtbl->Reset(This) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE ISynchronize_Wait_Proxy( + ISynchronize* This, + DWORD dwFlags, + DWORD dwMilliseconds); +void __RPC_STUB ISynchronize_Wait_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE ISynchronize_Signal_Proxy( + ISynchronize* This); +void __RPC_STUB ISynchronize_Signal_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE ISynchronize_Reset_Proxy( + ISynchronize* This); +void __RPC_STUB ISynchronize_Reset_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __ISynchronize_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * ISynchronizeHandle interface + */ +#ifndef __ISynchronizeHandle_INTERFACE_DEFINED__ +#define __ISynchronizeHandle_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_ISynchronizeHandle, 0x00000031, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface ISynchronizeHandle : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetHandle( + HANDLE *ph) = 0; + +}; +#else +typedef struct ISynchronizeHandleVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ISynchronizeHandle* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ISynchronizeHandle* This); + + ULONG (STDMETHODCALLTYPE *Release)( + ISynchronizeHandle* This); + + /*** ISynchronizeHandle methods ***/ + HRESULT (STDMETHODCALLTYPE *GetHandle)( + ISynchronizeHandle* This, + HANDLE *ph); + + END_INTERFACE +} ISynchronizeHandleVtbl; +interface ISynchronizeHandle { + CONST_VTBL ISynchronizeHandleVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define ISynchronizeHandle_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define ISynchronizeHandle_AddRef(This) (This)->lpVtbl->AddRef(This) +#define ISynchronizeHandle_Release(This) (This)->lpVtbl->Release(This) +/*** ISynchronizeHandle methods ***/ +#define ISynchronizeHandle_GetHandle(This,ph) (This)->lpVtbl->GetHandle(This,ph) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE ISynchronizeHandle_GetHandle_Proxy( + ISynchronizeHandle* This, + HANDLE *ph); +void __RPC_STUB ISynchronizeHandle_GetHandle_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __ISynchronizeHandle_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * ISynchronizeEvent interface + */ +#ifndef __ISynchronizeEvent_INTERFACE_DEFINED__ +#define __ISynchronizeEvent_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_ISynchronizeEvent, 0x00000032, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface ISynchronizeEvent : public ISynchronizeHandle +{ + virtual HRESULT STDMETHODCALLTYPE SetEventHandle( + HANDLE *ph) = 0; + +}; +#else +typedef struct ISynchronizeEventVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ISynchronizeEvent* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ISynchronizeEvent* This); + + ULONG (STDMETHODCALLTYPE *Release)( + ISynchronizeEvent* This); + + /*** ISynchronizeHandle methods ***/ + HRESULT (STDMETHODCALLTYPE *GetHandle)( + ISynchronizeEvent* This, + HANDLE *ph); + + /*** ISynchronizeEvent methods ***/ + HRESULT (STDMETHODCALLTYPE *SetEventHandle)( + ISynchronizeEvent* This, + HANDLE *ph); + + END_INTERFACE +} ISynchronizeEventVtbl; +interface ISynchronizeEvent { + CONST_VTBL ISynchronizeEventVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define ISynchronizeEvent_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define ISynchronizeEvent_AddRef(This) (This)->lpVtbl->AddRef(This) +#define ISynchronizeEvent_Release(This) (This)->lpVtbl->Release(This) +/*** ISynchronizeHandle methods ***/ +#define ISynchronizeEvent_GetHandle(This,ph) (This)->lpVtbl->GetHandle(This,ph) +/*** ISynchronizeEvent methods ***/ +#define ISynchronizeEvent_SetEventHandle(This,ph) (This)->lpVtbl->SetEventHandle(This,ph) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE ISynchronizeEvent_SetEventHandle_Proxy( + ISynchronizeEvent* This, + HANDLE *ph); +void __RPC_STUB ISynchronizeEvent_SetEventHandle_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __ISynchronizeEvent_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * ISynchronizeContainer interface + */ +#ifndef __ISynchronizeContainer_INTERFACE_DEFINED__ +#define __ISynchronizeContainer_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_ISynchronizeContainer, 0x00000033, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface ISynchronizeContainer : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE AddSynchronize( + ISynchronize *pSync) = 0; + + virtual HRESULT STDMETHODCALLTYPE WaitMultiple( + DWORD dwFlags, + DWORD dwTimeOut, + ISynchronize **ppSync) = 0; + +}; +#else +typedef struct ISynchronizeContainerVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ISynchronizeContainer* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ISynchronizeContainer* This); + + ULONG (STDMETHODCALLTYPE *Release)( + ISynchronizeContainer* This); + + /*** ISynchronizeContainer methods ***/ + HRESULT (STDMETHODCALLTYPE *AddSynchronize)( + ISynchronizeContainer* This, + ISynchronize *pSync); + + HRESULT (STDMETHODCALLTYPE *WaitMultiple)( + ISynchronizeContainer* This, + DWORD dwFlags, + DWORD dwTimeOut, + ISynchronize **ppSync); + + END_INTERFACE +} ISynchronizeContainerVtbl; +interface ISynchronizeContainer { + CONST_VTBL ISynchronizeContainerVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define ISynchronizeContainer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define ISynchronizeContainer_AddRef(This) (This)->lpVtbl->AddRef(This) +#define ISynchronizeContainer_Release(This) (This)->lpVtbl->Release(This) +/*** ISynchronizeContainer methods ***/ +#define ISynchronizeContainer_AddSynchronize(This,pSync) (This)->lpVtbl->AddSynchronize(This,pSync) +#define ISynchronizeContainer_WaitMultiple(This,dwFlags,dwTimeOut,ppSync) (This)->lpVtbl->WaitMultiple(This,dwFlags,dwTimeOut,ppSync) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE ISynchronizeContainer_AddSynchronize_Proxy( + ISynchronizeContainer* This, + ISynchronize *pSync); +void __RPC_STUB ISynchronizeContainer_AddSynchronize_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE ISynchronizeContainer_WaitMultiple_Proxy( + ISynchronizeContainer* This, + DWORD dwFlags, + DWORD dwTimeOut, + ISynchronize **ppSync); +void __RPC_STUB ISynchronizeContainer_WaitMultiple_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __ISynchronizeContainer_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * ISynchronizeMutex interface + */ +#ifndef __ISynchronizeMutex_INTERFACE_DEFINED__ +#define __ISynchronizeMutex_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_ISynchronizeMutex, 0x00000025, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface ISynchronizeMutex : public ISynchronize +{ + virtual HRESULT STDMETHODCALLTYPE ReleaseMutex( + ) = 0; + +}; +#else +typedef struct ISynchronizeMutexVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ISynchronizeMutex* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ISynchronizeMutex* This); + + ULONG (STDMETHODCALLTYPE *Release)( + ISynchronizeMutex* This); + + /*** ISynchronize methods ***/ + HRESULT (STDMETHODCALLTYPE *Wait)( + ISynchronizeMutex* This, + DWORD dwFlags, + DWORD dwMilliseconds); + + HRESULT (STDMETHODCALLTYPE *Signal)( + ISynchronizeMutex* This); + + HRESULT (STDMETHODCALLTYPE *Reset)( + ISynchronizeMutex* This); + + /*** ISynchronizeMutex methods ***/ + HRESULT (STDMETHODCALLTYPE *ReleaseMutex)( + ISynchronizeMutex* This); + + END_INTERFACE +} ISynchronizeMutexVtbl; +interface ISynchronizeMutex { + CONST_VTBL ISynchronizeMutexVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define ISynchronizeMutex_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define ISynchronizeMutex_AddRef(This) (This)->lpVtbl->AddRef(This) +#define ISynchronizeMutex_Release(This) (This)->lpVtbl->Release(This) +/*** ISynchronize methods ***/ +#define ISynchronizeMutex_Wait(This,dwFlags,dwMilliseconds) (This)->lpVtbl->Wait(This,dwFlags,dwMilliseconds) +#define ISynchronizeMutex_Signal(This) (This)->lpVtbl->Signal(This) +#define ISynchronizeMutex_Reset(This) (This)->lpVtbl->Reset(This) +/*** ISynchronizeMutex methods ***/ +#define ISynchronizeMutex_ReleaseMutex(This) (This)->lpVtbl->ReleaseMutex(This) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE ISynchronizeMutex_ReleaseMutex_Proxy( + ISynchronizeMutex* This); +void __RPC_STUB ISynchronizeMutex_ReleaseMutex_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __ISynchronizeMutex_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * ICancelMethodCalls interface + */ +#ifndef __ICancelMethodCalls_INTERFACE_DEFINED__ +#define __ICancelMethodCalls_INTERFACE_DEFINED__ + +typedef ICancelMethodCalls *LPCANCELMETHODCALLS; +DEFINE_GUID(IID_ICancelMethodCalls, 0x00000029, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface ICancelMethodCalls : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Cancel( + ULONG ulSeconds) = 0; + + virtual HRESULT STDMETHODCALLTYPE TestCancel( + ) = 0; + +}; +#else +typedef struct ICancelMethodCallsVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ICancelMethodCalls* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ICancelMethodCalls* This); + + ULONG (STDMETHODCALLTYPE *Release)( + ICancelMethodCalls* This); + + /*** ICancelMethodCalls methods ***/ + HRESULT (STDMETHODCALLTYPE *Cancel)( + ICancelMethodCalls* This, + ULONG ulSeconds); + + HRESULT (STDMETHODCALLTYPE *TestCancel)( + ICancelMethodCalls* This); + + END_INTERFACE +} ICancelMethodCallsVtbl; +interface ICancelMethodCalls { + CONST_VTBL ICancelMethodCallsVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define ICancelMethodCalls_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define ICancelMethodCalls_AddRef(This) (This)->lpVtbl->AddRef(This) +#define ICancelMethodCalls_Release(This) (This)->lpVtbl->Release(This) +/*** ICancelMethodCalls methods ***/ +#define ICancelMethodCalls_Cancel(This,ulSeconds) (This)->lpVtbl->Cancel(This,ulSeconds) +#define ICancelMethodCalls_TestCancel(This) (This)->lpVtbl->TestCancel(This) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE ICancelMethodCalls_Cancel_Proxy( + ICancelMethodCalls* This, + ULONG ulSeconds); +void __RPC_STUB ICancelMethodCalls_Cancel_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE ICancelMethodCalls_TestCancel_Proxy( + ICancelMethodCalls* This); +void __RPC_STUB ICancelMethodCalls_TestCancel_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __ICancelMethodCalls_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IAsyncManager interface + */ +#ifndef __IAsyncManager_INTERFACE_DEFINED__ +#define __IAsyncManager_INTERFACE_DEFINED__ + +typedef enum tagDCOM_CALL_STATE { + DCOM_NONE = 0, + DCOM_CALL_COMPLETE = 1, + DCOM_CALL_CANCELED = 2 +} DCOM_CALL_STATE; +DEFINE_GUID(IID_IAsyncManager, 0x0000002a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IAsyncManager : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE CompleteCall( + HRESULT Result) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCallContext( + REFIID riid, + void **pInterface) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetState( + ULONG *pulStateFlags) = 0; + +}; +#else +typedef struct IAsyncManagerVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IAsyncManager* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IAsyncManager* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IAsyncManager* This); + + /*** IAsyncManager methods ***/ + HRESULT (STDMETHODCALLTYPE *CompleteCall)( + IAsyncManager* This, + HRESULT Result); + + HRESULT (STDMETHODCALLTYPE *GetCallContext)( + IAsyncManager* This, + REFIID riid, + void **pInterface); + + HRESULT (STDMETHODCALLTYPE *GetState)( + IAsyncManager* This, + ULONG *pulStateFlags); + + END_INTERFACE +} IAsyncManagerVtbl; +interface IAsyncManager { + CONST_VTBL IAsyncManagerVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IAsyncManager_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IAsyncManager_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IAsyncManager_Release(This) (This)->lpVtbl->Release(This) +/*** IAsyncManager methods ***/ +#define IAsyncManager_CompleteCall(This,Result) (This)->lpVtbl->CompleteCall(This,Result) +#define IAsyncManager_GetCallContext(This,riid,pInterface) (This)->lpVtbl->GetCallContext(This,riid,pInterface) +#define IAsyncManager_GetState(This,pulStateFlags) (This)->lpVtbl->GetState(This,pulStateFlags) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IAsyncManager_CompleteCall_Proxy( + IAsyncManager* This, + HRESULT Result); +void __RPC_STUB IAsyncManager_CompleteCall_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAsyncManager_GetCallContext_Proxy( + IAsyncManager* This, + REFIID riid, + void **pInterface); +void __RPC_STUB IAsyncManager_GetCallContext_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAsyncManager_GetState_Proxy( + IAsyncManager* This, + ULONG *pulStateFlags); +void __RPC_STUB IAsyncManager_GetState_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IAsyncManager_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * ICallFactory interface + */ +#ifndef __ICallFactory_INTERFACE_DEFINED__ +#define __ICallFactory_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_ICallFactory, 0x1c733a30, 0x2a1c, 0x11ce, 0xad,0xe5, 0x00,0xaa,0x00,0x44,0x77,0x3d); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface ICallFactory : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE CreateCall( + REFIID riid, + IUnknown *pCtrlUnk, + REFIID riid2, + IUnknown **ppv) = 0; + +}; +#else +typedef struct ICallFactoryVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ICallFactory* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ICallFactory* This); + + ULONG (STDMETHODCALLTYPE *Release)( + ICallFactory* This); + + /*** ICallFactory methods ***/ + HRESULT (STDMETHODCALLTYPE *CreateCall)( + ICallFactory* This, + REFIID riid, + IUnknown *pCtrlUnk, + REFIID riid2, + IUnknown **ppv); + + END_INTERFACE +} ICallFactoryVtbl; +interface ICallFactory { + CONST_VTBL ICallFactoryVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define ICallFactory_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define ICallFactory_AddRef(This) (This)->lpVtbl->AddRef(This) +#define ICallFactory_Release(This) (This)->lpVtbl->Release(This) +/*** ICallFactory methods ***/ +#define ICallFactory_CreateCall(This,riid,pCtrlUnk,riid2,ppv) (This)->lpVtbl->CreateCall(This,riid,pCtrlUnk,riid2,ppv) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE ICallFactory_CreateCall_Proxy( + ICallFactory* This, + REFIID riid, + IUnknown *pCtrlUnk, + REFIID riid2, + IUnknown **ppv); +void __RPC_STUB ICallFactory_CreateCall_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __ICallFactory_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IRpcOptions interface + */ +#ifndef __IRpcOptions_INTERFACE_DEFINED__ +#define __IRpcOptions_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IRpcOptions, 0x00000144, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IRpcOptions : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Set( + IUnknown *pPrx, + DWORD dwProperty, + ULONG_PTR dwValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE Query( + IUnknown *pPrx, + DWORD dwProperty, + ULONG_PTR *pdwValue) = 0; + +}; +#else +typedef struct IRpcOptionsVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IRpcOptions* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IRpcOptions* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IRpcOptions* This); + + /*** IRpcOptions methods ***/ + HRESULT (STDMETHODCALLTYPE *Set)( + IRpcOptions* This, + IUnknown *pPrx, + DWORD dwProperty, + ULONG_PTR dwValue); + + HRESULT (STDMETHODCALLTYPE *Query)( + IRpcOptions* This, + IUnknown *pPrx, + DWORD dwProperty, + ULONG_PTR *pdwValue); + + END_INTERFACE +} IRpcOptionsVtbl; +interface IRpcOptions { + CONST_VTBL IRpcOptionsVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IRpcOptions_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IRpcOptions_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IRpcOptions_Release(This) (This)->lpVtbl->Release(This) +/*** IRpcOptions methods ***/ +#define IRpcOptions_Set(This,pPrx,dwProperty,dwValue) (This)->lpVtbl->Set(This,pPrx,dwProperty,dwValue) +#define IRpcOptions_Query(This,pPrx,dwProperty,pdwValue) (This)->lpVtbl->Query(This,pPrx,dwProperty,pdwValue) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IRpcOptions_Set_Proxy( + IRpcOptions* This, + IUnknown *pPrx, + DWORD dwProperty, + ULONG_PTR dwValue); +void __RPC_STUB IRpcOptions_Set_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRpcOptions_Query_Proxy( + IRpcOptions* This, + IUnknown *pPrx, + DWORD dwProperty, + ULONG_PTR *pdwValue); +void __RPC_STUB IRpcOptions_Query_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IRpcOptions_INTERFACE_DEFINED__ */ + +enum { + COMBND_RPCTIMEOUT = 1, + COMBND_SERVER_LOCALITY = 2 +}; + +enum { + SERVER_LOCALITY_PROCESS_LOCAL = 0, + SERVER_LOCALITY_MACHINE_LOCAL = 1, + SERVER_LOCALITY_REMOTE = 2 +}; + +/***************************************************************************** + * IRpcHelper interface + */ +#ifndef __IRpcHelper_INTERFACE_DEFINED__ +#define __IRpcHelper_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IRpcHelper, 0x00000149, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IRpcHelper : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetDCOMProtocolVersion( + DWORD *pComVersion) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetIIDFromOBJREF( + void *pObjRef, + IID **piid) = 0; + +}; +#else +typedef struct IRpcHelperVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IRpcHelper* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IRpcHelper* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IRpcHelper* This); + + /*** IRpcHelper methods ***/ + HRESULT (STDMETHODCALLTYPE *GetDCOMProtocolVersion)( + IRpcHelper* This, + DWORD *pComVersion); + + HRESULT (STDMETHODCALLTYPE *GetIIDFromOBJREF)( + IRpcHelper* This, + void *pObjRef, + IID **piid); + + END_INTERFACE +} IRpcHelperVtbl; +interface IRpcHelper { + CONST_VTBL IRpcHelperVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IRpcHelper_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IRpcHelper_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IRpcHelper_Release(This) (This)->lpVtbl->Release(This) +/*** IRpcHelper methods ***/ +#define IRpcHelper_GetDCOMProtocolVersion(This,pComVersion) (This)->lpVtbl->GetDCOMProtocolVersion(This,pComVersion) +#define IRpcHelper_GetIIDFromOBJREF(This,pObjRef,piid) (This)->lpVtbl->GetIIDFromOBJREF(This,pObjRef,piid) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IRpcHelper_GetDCOMProtocolVersion_Proxy( + IRpcHelper* This, + DWORD *pComVersion); +void __RPC_STUB IRpcHelper_GetDCOMProtocolVersion_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IRpcHelper_GetIIDFromOBJREF_Proxy( + IRpcHelper* This, + void *pObjRef, + IID **piid); +void __RPC_STUB IRpcHelper_GetIIDFromOBJREF_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IRpcHelper_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IReleaseMarshalBuffers interface + */ +#ifndef __IReleaseMarshalBuffers_INTERFACE_DEFINED__ +#define __IReleaseMarshalBuffers_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IReleaseMarshalBuffers, 0xeb0cb9e8, 0x7996, 0x11d2, 0x87,0x2e, 0x00,0x00,0xf8,0x08,0x08,0x59); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IReleaseMarshalBuffers : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE ReleaseMarshalBuffer( + RPCOLEMESSAGE *pMsg, + DWORD dwFlags, + IUnknown *pChnl) = 0; + +}; +#else +typedef struct IReleaseMarshalBuffersVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IReleaseMarshalBuffers* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IReleaseMarshalBuffers* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IReleaseMarshalBuffers* This); + + /*** IReleaseMarshalBuffers methods ***/ + HRESULT (STDMETHODCALLTYPE *ReleaseMarshalBuffer)( + IReleaseMarshalBuffers* This, + RPCOLEMESSAGE *pMsg, + DWORD dwFlags, + IUnknown *pChnl); + + END_INTERFACE +} IReleaseMarshalBuffersVtbl; +interface IReleaseMarshalBuffers { + CONST_VTBL IReleaseMarshalBuffersVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IReleaseMarshalBuffers_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IReleaseMarshalBuffers_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IReleaseMarshalBuffers_Release(This) (This)->lpVtbl->Release(This) +/*** IReleaseMarshalBuffers methods ***/ +#define IReleaseMarshalBuffers_ReleaseMarshalBuffer(This,pMsg,dwFlags,pChnl) (This)->lpVtbl->ReleaseMarshalBuffer(This,pMsg,dwFlags,pChnl) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IReleaseMarshalBuffers_ReleaseMarshalBuffer_Proxy( + IReleaseMarshalBuffers* This, + RPCOLEMESSAGE *pMsg, + DWORD dwFlags, + IUnknown *pChnl); +void __RPC_STUB IReleaseMarshalBuffers_ReleaseMarshalBuffer_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IReleaseMarshalBuffers_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IWaitMultiple interface + */ +#ifndef __IWaitMultiple_INTERFACE_DEFINED__ +#define __IWaitMultiple_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IWaitMultiple, 0x0000002b, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IWaitMultiple : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE WaitMultiple( + DWORD timeout, + ISynchronize **pSync) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddSynchronize( + ISynchronize *pSync) = 0; + +}; +#else +typedef struct IWaitMultipleVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IWaitMultiple* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IWaitMultiple* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IWaitMultiple* This); + + /*** IWaitMultiple methods ***/ + HRESULT (STDMETHODCALLTYPE *WaitMultiple)( + IWaitMultiple* This, + DWORD timeout, + ISynchronize **pSync); + + HRESULT (STDMETHODCALLTYPE *AddSynchronize)( + IWaitMultiple* This, + ISynchronize *pSync); + + END_INTERFACE +} IWaitMultipleVtbl; +interface IWaitMultiple { + CONST_VTBL IWaitMultipleVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IWaitMultiple_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IWaitMultiple_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IWaitMultiple_Release(This) (This)->lpVtbl->Release(This) +/*** IWaitMultiple methods ***/ +#define IWaitMultiple_WaitMultiple(This,timeout,pSync) (This)->lpVtbl->WaitMultiple(This,timeout,pSync) +#define IWaitMultiple_AddSynchronize(This,pSync) (This)->lpVtbl->AddSynchronize(This,pSync) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IWaitMultiple_WaitMultiple_Proxy( + IWaitMultiple* This, + DWORD timeout, + ISynchronize **pSync); +void __RPC_STUB IWaitMultiple_WaitMultiple_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IWaitMultiple_AddSynchronize_Proxy( + IWaitMultiple* This, + ISynchronize *pSync); +void __RPC_STUB IWaitMultiple_AddSynchronize_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IWaitMultiple_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IUrlMon interface + */ +#ifndef __IUrlMon_INTERFACE_DEFINED__ +#define __IUrlMon_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IUrlMon, 0x00000026, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IUrlMon : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE AsyncGetClassBits( + REFCLSID rclsid, + LPCWSTR pszTYPE, + LPCWSTR pszExt, + DWORD dwFileVersionMS, + DWORD dwFileVersionLS, + LPCWSTR pszCodeBase, + IBindCtx *pbc, + DWORD dwClassContext, + REFIID riid, + DWORD flags) = 0; + +}; +#else +typedef struct IUrlMonVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IUrlMon* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IUrlMon* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IUrlMon* This); + + /*** IUrlMon methods ***/ + HRESULT (STDMETHODCALLTYPE *AsyncGetClassBits)( + IUrlMon* This, + REFCLSID rclsid, + LPCWSTR pszTYPE, + LPCWSTR pszExt, + DWORD dwFileVersionMS, + DWORD dwFileVersionLS, + LPCWSTR pszCodeBase, + IBindCtx *pbc, + DWORD dwClassContext, + REFIID riid, + DWORD flags); + + END_INTERFACE +} IUrlMonVtbl; +interface IUrlMon { + CONST_VTBL IUrlMonVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IUrlMon_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IUrlMon_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IUrlMon_Release(This) (This)->lpVtbl->Release(This) +/*** IUrlMon methods ***/ +#define IUrlMon_AsyncGetClassBits(This,rclsid,pszTYPE,pszExt,dwFileVersionMS,dwFileVersionLS,pszCodeBase,pbc,dwClassContext,riid,flags) (This)->lpVtbl->AsyncGetClassBits(This,rclsid,pszTYPE,pszExt,dwFileVersionMS,dwFileVersionLS,pszCodeBase,pbc,dwClassContext,riid,flags) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IUrlMon_AsyncGetClassBits_Proxy( + IUrlMon* This, + REFCLSID rclsid, + LPCWSTR pszTYPE, + LPCWSTR pszExt, + DWORD dwFileVersionMS, + DWORD dwFileVersionLS, + LPCWSTR pszCodeBase, + IBindCtx *pbc, + DWORD dwClassContext, + REFIID riid, + DWORD flags); +void __RPC_STUB IUrlMon_AsyncGetClassBits_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IUrlMon_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IForegroundTransfer interface + */ +#ifndef __IForegroundTransfer_INTERFACE_DEFINED__ +#define __IForegroundTransfer_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IForegroundTransfer, 0x00000145, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IForegroundTransfer : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE AllowForegroundTransfer( + void *lpvReserved) = 0; + +}; +#else +typedef struct IForegroundTransferVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IForegroundTransfer* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IForegroundTransfer* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IForegroundTransfer* This); + + /*** IForegroundTransfer methods ***/ + HRESULT (STDMETHODCALLTYPE *AllowForegroundTransfer)( + IForegroundTransfer* This, + void *lpvReserved); + + END_INTERFACE +} IForegroundTransferVtbl; +interface IForegroundTransfer { + CONST_VTBL IForegroundTransferVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IForegroundTransfer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IForegroundTransfer_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IForegroundTransfer_Release(This) (This)->lpVtbl->Release(This) +/*** IForegroundTransfer methods ***/ +#define IForegroundTransfer_AllowForegroundTransfer(This,lpvReserved) (This)->lpVtbl->AllowForegroundTransfer(This,lpvReserved) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IForegroundTransfer_AllowForegroundTransfer_Proxy( + IForegroundTransfer* This, + void *lpvReserved); +void __RPC_STUB IForegroundTransfer_AllowForegroundTransfer_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IForegroundTransfer_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IAddrTrackingControl interface + */ +#ifndef __IAddrTrackingControl_INTERFACE_DEFINED__ +#define __IAddrTrackingControl_INTERFACE_DEFINED__ + +typedef IAddrTrackingControl *LPADDRTRACKINGCONTROL; +DEFINE_GUID(IID_IAddrTrackingControl, 0x00000147, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IAddrTrackingControl : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE EnableCOMDynamicAddrTracking( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisableCOMDynamicAddrTracking( + ) = 0; + +}; +#else +typedef struct IAddrTrackingControlVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IAddrTrackingControl* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IAddrTrackingControl* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IAddrTrackingControl* This); + + /*** IAddrTrackingControl methods ***/ + HRESULT (STDMETHODCALLTYPE *EnableCOMDynamicAddrTracking)( + IAddrTrackingControl* This); + + HRESULT (STDMETHODCALLTYPE *DisableCOMDynamicAddrTracking)( + IAddrTrackingControl* This); + + END_INTERFACE +} IAddrTrackingControlVtbl; +interface IAddrTrackingControl { + CONST_VTBL IAddrTrackingControlVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IAddrTrackingControl_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IAddrTrackingControl_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IAddrTrackingControl_Release(This) (This)->lpVtbl->Release(This) +/*** IAddrTrackingControl methods ***/ +#define IAddrTrackingControl_EnableCOMDynamicAddrTracking(This) (This)->lpVtbl->EnableCOMDynamicAddrTracking(This) +#define IAddrTrackingControl_DisableCOMDynamicAddrTracking(This) (This)->lpVtbl->DisableCOMDynamicAddrTracking(This) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IAddrTrackingControl_EnableCOMDynamicAddrTracking_Proxy( + IAddrTrackingControl* This); +void __RPC_STUB IAddrTrackingControl_EnableCOMDynamicAddrTracking_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAddrTrackingControl_DisableCOMDynamicAddrTracking_Proxy( + IAddrTrackingControl* This); +void __RPC_STUB IAddrTrackingControl_DisableCOMDynamicAddrTracking_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IAddrTrackingControl_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IAddrExclusionControl interface + */ +#ifndef __IAddrExclusionControl_INTERFACE_DEFINED__ +#define __IAddrExclusionControl_INTERFACE_DEFINED__ + +typedef IAddrExclusionControl *LPADDREXCLUSIONCONTROL; +DEFINE_GUID(IID_IAddrExclusionControl, 0x00000148, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IAddrExclusionControl : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetCurrentAddrExclusionList( + REFIID riid, + void **ppEnumerator) = 0; + + virtual HRESULT STDMETHODCALLTYPE UpdateAddrExclusionList( + IUnknown *pEnumerator) = 0; + +}; +#else +typedef struct IAddrExclusionControlVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IAddrExclusionControl* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IAddrExclusionControl* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IAddrExclusionControl* This); + + /*** IAddrExclusionControl methods ***/ + HRESULT (STDMETHODCALLTYPE *GetCurrentAddrExclusionList)( + IAddrExclusionControl* This, + REFIID riid, + void **ppEnumerator); + + HRESULT (STDMETHODCALLTYPE *UpdateAddrExclusionList)( + IAddrExclusionControl* This, + IUnknown *pEnumerator); + + END_INTERFACE +} IAddrExclusionControlVtbl; +interface IAddrExclusionControl { + CONST_VTBL IAddrExclusionControlVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IAddrExclusionControl_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IAddrExclusionControl_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IAddrExclusionControl_Release(This) (This)->lpVtbl->Release(This) +/*** IAddrExclusionControl methods ***/ +#define IAddrExclusionControl_GetCurrentAddrExclusionList(This,riid,ppEnumerator) (This)->lpVtbl->GetCurrentAddrExclusionList(This,riid,ppEnumerator) +#define IAddrExclusionControl_UpdateAddrExclusionList(This,pEnumerator) (This)->lpVtbl->UpdateAddrExclusionList(This,pEnumerator) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IAddrExclusionControl_GetCurrentAddrExclusionList_Proxy( + IAddrExclusionControl* This, + REFIID riid, + void **ppEnumerator); +void __RPC_STUB IAddrExclusionControl_GetCurrentAddrExclusionList_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAddrExclusionControl_UpdateAddrExclusionList_Proxy( + IAddrExclusionControl* This, + IUnknown *pEnumerator); +void __RPC_STUB IAddrExclusionControl_UpdateAddrExclusionList_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IAddrExclusionControl_INTERFACE_DEFINED__ */ + +typedef enum _APTTYPE { + APTTYPE_CURRENT = -1, + APTTYPE_STA = 0, + APTTYPE_MTA = 1, + APTTYPE_NA = 2, + APTTYPE_MAINSTA = 3 +} APTTYPE; +typedef enum _THDTYPE { + THDTYPE_BLOCKMESSAGES = 0, + THDTYPE_PROCESSMESSAGES = 1 +} THDTYPE; +/***************************************************************************** + * IComThreadingInfo interface + */ +#ifndef __IComThreadingInfo_INTERFACE_DEFINED__ +#define __IComThreadingInfo_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IComThreadingInfo, 0x000001ce, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IComThreadingInfo : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetCurrentApartmentType( + APTTYPE *pAptType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCurrentThreadType( + THDTYPE *pThreadType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCurrentLogicalThreadId( + GUID *pguidLogicalThreadId) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCurrentLogicalThreadId( + REFGUID rguid) = 0; + +}; +#else +typedef struct IComThreadingInfoVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IComThreadingInfo* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IComThreadingInfo* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IComThreadingInfo* This); + + /*** IComThreadingInfo methods ***/ + HRESULT (STDMETHODCALLTYPE *GetCurrentApartmentType)( + IComThreadingInfo* This, + APTTYPE *pAptType); + + HRESULT (STDMETHODCALLTYPE *GetCurrentThreadType)( + IComThreadingInfo* This, + THDTYPE *pThreadType); + + HRESULT (STDMETHODCALLTYPE *GetCurrentLogicalThreadId)( + IComThreadingInfo* This, + GUID *pguidLogicalThreadId); + + HRESULT (STDMETHODCALLTYPE *SetCurrentLogicalThreadId)( + IComThreadingInfo* This, + REFGUID rguid); + + END_INTERFACE +} IComThreadingInfoVtbl; +interface IComThreadingInfo { + CONST_VTBL IComThreadingInfoVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IComThreadingInfo_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IComThreadingInfo_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IComThreadingInfo_Release(This) (This)->lpVtbl->Release(This) +/*** IComThreadingInfo methods ***/ +#define IComThreadingInfo_GetCurrentApartmentType(This,pAptType) (This)->lpVtbl->GetCurrentApartmentType(This,pAptType) +#define IComThreadingInfo_GetCurrentThreadType(This,pThreadType) (This)->lpVtbl->GetCurrentThreadType(This,pThreadType) +#define IComThreadingInfo_GetCurrentLogicalThreadId(This,pguidLogicalThreadId) (This)->lpVtbl->GetCurrentLogicalThreadId(This,pguidLogicalThreadId) +#define IComThreadingInfo_SetCurrentLogicalThreadId(This,rguid) (This)->lpVtbl->SetCurrentLogicalThreadId(This,rguid) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IComThreadingInfo_GetCurrentApartmentType_Proxy( + IComThreadingInfo* This, + APTTYPE *pAptType); +void __RPC_STUB IComThreadingInfo_GetCurrentApartmentType_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IComThreadingInfo_GetCurrentThreadType_Proxy( + IComThreadingInfo* This, + THDTYPE *pThreadType); +void __RPC_STUB IComThreadingInfo_GetCurrentThreadType_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IComThreadingInfo_GetCurrentLogicalThreadId_Proxy( + IComThreadingInfo* This, + GUID *pguidLogicalThreadId); +void __RPC_STUB IComThreadingInfo_GetCurrentLogicalThreadId_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IComThreadingInfo_SetCurrentLogicalThreadId_Proxy( + IComThreadingInfo* This, + REFGUID rguid); +void __RPC_STUB IComThreadingInfo_SetCurrentLogicalThreadId_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IComThreadingInfo_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IProcessInitControl interface + */ +#ifndef __IProcessInitControl_INTERFACE_DEFINED__ +#define __IProcessInitControl_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IProcessInitControl, 0x72380d55, 0x8d2b, 0x43a3, 0x85,0x13, 0x2b,0x6e,0xf3,0x14,0x34,0xe9); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IProcessInitControl : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE ResetInitializerTimeout( + DWORD dwSecondsRemaining) = 0; + +}; +#else +typedef struct IProcessInitControlVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IProcessInitControl* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IProcessInitControl* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IProcessInitControl* This); + + /*** IProcessInitControl methods ***/ + HRESULT (STDMETHODCALLTYPE *ResetInitializerTimeout)( + IProcessInitControl* This, + DWORD dwSecondsRemaining); + + END_INTERFACE +} IProcessInitControlVtbl; +interface IProcessInitControl { + CONST_VTBL IProcessInitControlVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IProcessInitControl_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IProcessInitControl_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IProcessInitControl_Release(This) (This)->lpVtbl->Release(This) +/*** IProcessInitControl methods ***/ +#define IProcessInitControl_ResetInitializerTimeout(This,dwSecondsRemaining) (This)->lpVtbl->ResetInitializerTimeout(This,dwSecondsRemaining) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IProcessInitControl_ResetInitializerTimeout_Proxy( + IProcessInitControl* This, + DWORD dwSecondsRemaining); +void __RPC_STUB IProcessInitControl_ResetInitializerTimeout_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IProcessInitControl_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IInitializeSpy interface + */ +#ifndef __IInitializeSpy_INTERFACE_DEFINED__ +#define __IInitializeSpy_INTERFACE_DEFINED__ + +typedef IInitializeSpy *LPINITIALIZESPY; +DEFINE_GUID(IID_IInitializeSpy, 0x00000034, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IInitializeSpy : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE PreInitialize( + DWORD dwCoInit, + DWORD dwCurThreadAptRefs) = 0; + + virtual HRESULT STDMETHODCALLTYPE PostInitialize( + HRESULT hrCoInit, + DWORD dwCoInit, + DWORD dwNewThreadAptRefs) = 0; + + virtual HRESULT STDMETHODCALLTYPE PreUninitialize( + DWORD dwCurThreadAptRefs) = 0; + + virtual HRESULT STDMETHODCALLTYPE PostUninitialize( + DWORD dwNewThreadAptRefs) = 0; + +}; +#else +typedef struct IInitializeSpyVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IInitializeSpy* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IInitializeSpy* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IInitializeSpy* This); + + /*** IInitializeSpy methods ***/ + HRESULT (STDMETHODCALLTYPE *PreInitialize)( + IInitializeSpy* This, + DWORD dwCoInit, + DWORD dwCurThreadAptRefs); + + HRESULT (STDMETHODCALLTYPE *PostInitialize)( + IInitializeSpy* This, + HRESULT hrCoInit, + DWORD dwCoInit, + DWORD dwNewThreadAptRefs); + + HRESULT (STDMETHODCALLTYPE *PreUninitialize)( + IInitializeSpy* This, + DWORD dwCurThreadAptRefs); + + HRESULT (STDMETHODCALLTYPE *PostUninitialize)( + IInitializeSpy* This, + DWORD dwNewThreadAptRefs); + + END_INTERFACE +} IInitializeSpyVtbl; +interface IInitializeSpy { + CONST_VTBL IInitializeSpyVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IInitializeSpy_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IInitializeSpy_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IInitializeSpy_Release(This) (This)->lpVtbl->Release(This) +/*** IInitializeSpy methods ***/ +#define IInitializeSpy_PreInitialize(This,dwCoInit,dwCurThreadAptRefs) (This)->lpVtbl->PreInitialize(This,dwCoInit,dwCurThreadAptRefs) +#define IInitializeSpy_PostInitialize(This,hrCoInit,dwCoInit,dwNewThreadAptRefs) (This)->lpVtbl->PostInitialize(This,hrCoInit,dwCoInit,dwNewThreadAptRefs) +#define IInitializeSpy_PreUninitialize(This,dwCurThreadAptRefs) (This)->lpVtbl->PreUninitialize(This,dwCurThreadAptRefs) +#define IInitializeSpy_PostUninitialize(This,dwNewThreadAptRefs) (This)->lpVtbl->PostUninitialize(This,dwNewThreadAptRefs) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IInitializeSpy_PreInitialize_Proxy( + IInitializeSpy* This, + DWORD dwCoInit, + DWORD dwCurThreadAptRefs); +void __RPC_STUB IInitializeSpy_PreInitialize_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IInitializeSpy_PostInitialize_Proxy( + IInitializeSpy* This, + HRESULT hrCoInit, + DWORD dwCoInit, + DWORD dwNewThreadAptRefs); +void __RPC_STUB IInitializeSpy_PostInitialize_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IInitializeSpy_PreUninitialize_Proxy( + IInitializeSpy* This, + DWORD dwCurThreadAptRefs); +void __RPC_STUB IInitializeSpy_PreUninitialize_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IInitializeSpy_PostUninitialize_Proxy( + IInitializeSpy* This, + DWORD dwNewThreadAptRefs); +void __RPC_STUB IInitializeSpy_PostUninitialize_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IInitializeSpy_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IThumbnailExtractor interface + */ +#ifndef __IThumbnailExtractor_INTERFACE_DEFINED__ +#define __IThumbnailExtractor_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IThumbnailExtractor, 0x969dc708, 0x5c76, 0x11d1, 0x8d,0x86, 0x00,0x00,0xf8,0x04,0xb0,0x57); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IThumbnailExtractor : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE ExtractThumbnail( + IStorage *pStg, + ULONG ulLength, + ULONG ulHeight, + ULONG *pulOutputLength, + ULONG *pulOutputHeight, + HBITMAP *phOutputBitmap) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnFileUpdated( + IStorage *pStg) = 0; + +}; +#else +typedef struct IThumbnailExtractorVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IThumbnailExtractor* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IThumbnailExtractor* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IThumbnailExtractor* This); + + /*** IThumbnailExtractor methods ***/ + HRESULT (STDMETHODCALLTYPE *ExtractThumbnail)( + IThumbnailExtractor* This, + IStorage *pStg, + ULONG ulLength, + ULONG ulHeight, + ULONG *pulOutputLength, + ULONG *pulOutputHeight, + HBITMAP *phOutputBitmap); + + HRESULT (STDMETHODCALLTYPE *OnFileUpdated)( + IThumbnailExtractor* This, + IStorage *pStg); + + END_INTERFACE +} IThumbnailExtractorVtbl; +interface IThumbnailExtractor { + CONST_VTBL IThumbnailExtractorVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IThumbnailExtractor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IThumbnailExtractor_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IThumbnailExtractor_Release(This) (This)->lpVtbl->Release(This) +/*** IThumbnailExtractor methods ***/ +#define IThumbnailExtractor_ExtractThumbnail(This,pStg,ulLength,ulHeight,pulOutputLength,pulOutputHeight,phOutputBitmap) (This)->lpVtbl->ExtractThumbnail(This,pStg,ulLength,ulHeight,pulOutputLength,pulOutputHeight,phOutputBitmap) +#define IThumbnailExtractor_OnFileUpdated(This,pStg) (This)->lpVtbl->OnFileUpdated(This,pStg) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IThumbnailExtractor_ExtractThumbnail_Proxy( + IThumbnailExtractor* This, + IStorage *pStg, + ULONG ulLength, + ULONG ulHeight, + ULONG *pulOutputLength, + ULONG *pulOutputHeight, + HBITMAP *phOutputBitmap); +void __RPC_STUB IThumbnailExtractor_ExtractThumbnail_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IThumbnailExtractor_OnFileUpdated_Proxy( + IThumbnailExtractor* This, + IStorage *pStg); +void __RPC_STUB IThumbnailExtractor_OnFileUpdated_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IThumbnailExtractor_INTERFACE_DEFINED__ */ + +#ifdef USE_COM_CONTEXT_DEF +typedef DWORD CPFLAGS; +typedef struct tagContextProperty { + GUID policyId; + CPFLAGS flags; + IUnknown *pUnk; +} ContextProperty; +/***************************************************************************** + * IEnumContextProps interface + */ +#ifndef __IEnumContextProps_INTERFACE_DEFINED__ +#define __IEnumContextProps_INTERFACE_DEFINED__ + +typedef IEnumContextProps *LPENUMCONTEXTPROPS; +DEFINE_GUID(IID_IEnumContextProps, 0x000001c1, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IEnumContextProps : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Next( + ULONG celt, + ContextProperty *pContextProperties, + ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + IEnumContextProps **ppEnumContextProps) = 0; + + virtual HRESULT STDMETHODCALLTYPE Count( + ULONG *pcelt) = 0; + +}; +#else +typedef struct IEnumContextPropsVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IEnumContextProps* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IEnumContextProps* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IEnumContextProps* This); + + /*** IEnumContextProps methods ***/ + HRESULT (STDMETHODCALLTYPE *Next)( + IEnumContextProps* This, + ULONG celt, + ContextProperty *pContextProperties, + ULONG *pceltFetched); + + HRESULT (STDMETHODCALLTYPE *Skip)( + IEnumContextProps* This, + ULONG celt); + + HRESULT (STDMETHODCALLTYPE *Reset)( + IEnumContextProps* This); + + HRESULT (STDMETHODCALLTYPE *Clone)( + IEnumContextProps* This, + IEnumContextProps **ppEnumContextProps); + + HRESULT (STDMETHODCALLTYPE *Count)( + IEnumContextProps* This, + ULONG *pcelt); + + END_INTERFACE +} IEnumContextPropsVtbl; +interface IEnumContextProps { + CONST_VTBL IEnumContextPropsVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IEnumContextProps_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IEnumContextProps_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IEnumContextProps_Release(This) (This)->lpVtbl->Release(This) +/*** IEnumContextProps methods ***/ +#define IEnumContextProps_Next(This,celt,pContextProperties,pceltFetched) (This)->lpVtbl->Next(This,celt,pContextProperties,pceltFetched) +#define IEnumContextProps_Skip(This,celt) (This)->lpVtbl->Skip(This,celt) +#define IEnumContextProps_Reset(This) (This)->lpVtbl->Reset(This) +#define IEnumContextProps_Clone(This,ppEnumContextProps) (This)->lpVtbl->Clone(This,ppEnumContextProps) +#define IEnumContextProps_Count(This,pcelt) (This)->lpVtbl->Count(This,pcelt) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IEnumContextProps_Next_Proxy( + IEnumContextProps* This, + ULONG celt, + ContextProperty *pContextProperties, + ULONG *pceltFetched); +void __RPC_STUB IEnumContextProps_Next_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumContextProps_Skip_Proxy( + IEnumContextProps* This, + ULONG celt); +void __RPC_STUB IEnumContextProps_Skip_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumContextProps_Reset_Proxy( + IEnumContextProps* This); +void __RPC_STUB IEnumContextProps_Reset_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumContextProps_Clone_Proxy( + IEnumContextProps* This, + IEnumContextProps **ppEnumContextProps); +void __RPC_STUB IEnumContextProps_Clone_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IEnumContextProps_Count_Proxy( + IEnumContextProps* This, + ULONG *pcelt); +void __RPC_STUB IEnumContextProps_Count_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IEnumContextProps_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IContext interface + */ +#ifndef __IContext_INTERFACE_DEFINED__ +#define __IContext_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IContext, 0x000001c0, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IContext : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE SetProperty( + REFGUID policyId, + CPFLAGS flags, + IUnknown *pUnk) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveProperty( + REFGUID policyId) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetProperty( + REFGUID guid, + CPFLAGS *pFlags, + IUnknown **ppUnk) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumContextProps( + IEnumContextProps **ppEnumContextProps) = 0; + +}; +#else +typedef struct IContextVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IContext* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IContext* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IContext* This); + + /*** IContext methods ***/ + HRESULT (STDMETHODCALLTYPE *SetProperty)( + IContext* This, + REFGUID policyId, + CPFLAGS flags, + IUnknown *pUnk); + + HRESULT (STDMETHODCALLTYPE *RemoveProperty)( + IContext* This, + REFGUID policyId); + + HRESULT (STDMETHODCALLTYPE *GetProperty)( + IContext* This, + REFGUID guid, + CPFLAGS *pFlags, + IUnknown **ppUnk); + + HRESULT (STDMETHODCALLTYPE *EnumContextProps)( + IContext* This, + IEnumContextProps **ppEnumContextProps); + + END_INTERFACE +} IContextVtbl; +interface IContext { + CONST_VTBL IContextVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IContext_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IContext_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IContext_Release(This) (This)->lpVtbl->Release(This) +/*** IContext methods ***/ +#define IContext_SetProperty(This,policyId,flags,pUnk) (This)->lpVtbl->SetProperty(This,policyId,flags,pUnk) +#define IContext_RemoveProperty(This,policyId) (This)->lpVtbl->RemoveProperty(This,policyId) +#define IContext_GetProperty(This,guid,pFlags,ppUnk) (This)->lpVtbl->GetProperty(This,guid,pFlags,ppUnk) +#define IContext_EnumContextProps(This,ppEnumContextProps) (This)->lpVtbl->EnumContextProps(This,ppEnumContextProps) +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IContext_SetProperty_Proxy( + IContext* This, + REFGUID policyId, + CPFLAGS flags, + IUnknown *pUnk); +void __RPC_STUB IContext_SetProperty_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IContext_RemoveProperty_Proxy( + IContext* This, + REFGUID policyId); +void __RPC_STUB IContext_RemoveProperty_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IContext_GetProperty_Proxy( + IContext* This, + REFGUID guid, + CPFLAGS *pFlags, + IUnknown **ppUnk); +void __RPC_STUB IContext_GetProperty_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IContext_EnumContextProps_Proxy( + IContext* This, + IEnumContextProps **ppEnumContextProps); +void __RPC_STUB IContext_EnumContextProps_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IContext_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IObjContext interface + */ +#ifndef __IObjContext_INTERFACE_DEFINED__ +#define __IObjContext_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IObjContext, 0x000001c6, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +interface IObjContext : public IContext +{ + virtual void STDMETHODCALLTYPE Reserved1( + ) = 0; + + virtual void STDMETHODCALLTYPE Reserved2( + ) = 0; + + virtual void STDMETHODCALLTYPE Reserved3( + ) = 0; + + virtual void STDMETHODCALLTYPE Reserved4( + ) = 0; + + virtual void STDMETHODCALLTYPE Reserved5( + ) = 0; + + virtual void STDMETHODCALLTYPE Reserved6( + ) = 0; + + virtual void STDMETHODCALLTYPE Reserved7( + ) = 0; + +}; +#else +typedef struct IObjContextVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IObjContext* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IObjContext* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IObjContext* This); + + /*** IContext methods ***/ + HRESULT (STDMETHODCALLTYPE *SetProperty)( + IObjContext* This, + REFGUID policyId, + CPFLAGS flags, + IUnknown *pUnk); + + HRESULT (STDMETHODCALLTYPE *RemoveProperty)( + IObjContext* This, + REFGUID policyId); + + HRESULT (STDMETHODCALLTYPE *GetProperty)( + IObjContext* This, + REFGUID guid, + CPFLAGS *pFlags, + IUnknown **ppUnk); + + HRESULT (STDMETHODCALLTYPE *EnumContextProps)( + IObjContext* This, + IEnumContextProps **ppEnumContextProps); + + /*** IObjContext methods ***/ + void (STDMETHODCALLTYPE *Reserved1)( + IObjContext* This); + + void (STDMETHODCALLTYPE *Reserved2)( + IObjContext* This); + + void (STDMETHODCALLTYPE *Reserved3)( + IObjContext* This); + + void (STDMETHODCALLTYPE *Reserved4)( + IObjContext* This); + + void (STDMETHODCALLTYPE *Reserved5)( + IObjContext* This); + + void (STDMETHODCALLTYPE *Reserved6)( + IObjContext* This); + + void (STDMETHODCALLTYPE *Reserved7)( + IObjContext* This); + + END_INTERFACE +} IObjContextVtbl; +interface IObjContext { + CONST_VTBL IObjContextVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IObjContext_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IObjContext_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IObjContext_Release(This) (This)->lpVtbl->Release(This) +/*** IContext methods ***/ +#define IObjContext_SetProperty(This,policyId,flags,pUnk) (This)->lpVtbl->SetProperty(This,policyId,flags,pUnk) +#define IObjContext_RemoveProperty(This,policyId) (This)->lpVtbl->RemoveProperty(This,policyId) +#define IObjContext_GetProperty(This,guid,pFlags,ppUnk) (This)->lpVtbl->GetProperty(This,guid,pFlags,ppUnk) +#define IObjContext_EnumContextProps(This,ppEnumContextProps) (This)->lpVtbl->EnumContextProps(This,ppEnumContextProps) +/*** IObjContext methods ***/ +#define IObjContext_Reserved1(This) (This)->lpVtbl->Reserved1(This) +#define IObjContext_Reserved2(This) (This)->lpVtbl->Reserved2(This) +#define IObjContext_Reserved3(This) (This)->lpVtbl->Reserved3(This) +#define IObjContext_Reserved4(This) (This)->lpVtbl->Reserved4(This) +#define IObjContext_Reserved5(This) (This)->lpVtbl->Reserved5(This) +#define IObjContext_Reserved6(This) (This)->lpVtbl->Reserved6(This) +#define IObjContext_Reserved7(This) (This)->lpVtbl->Reserved7(This) +#endif + +#endif + +void STDMETHODCALLTYPE IObjContext_Reserved1_Proxy( + IObjContext* This); +void __RPC_STUB IObjContext_Reserved1_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IObjContext_Reserved2_Proxy( + IObjContext* This); +void __RPC_STUB IObjContext_Reserved2_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IObjContext_Reserved3_Proxy( + IObjContext* This); +void __RPC_STUB IObjContext_Reserved3_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IObjContext_Reserved4_Proxy( + IObjContext* This); +void __RPC_STUB IObjContext_Reserved4_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IObjContext_Reserved5_Proxy( + IObjContext* This); +void __RPC_STUB IObjContext_Reserved5_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IObjContext_Reserved6_Proxy( + IObjContext* This); +void __RPC_STUB IObjContext_Reserved6_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void STDMETHODCALLTYPE IObjContext_Reserved7_Proxy( + IObjContext* This); +void __RPC_STUB IObjContext_Reserved7_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IObjContext_INTERFACE_DEFINED__ */ + +#endif /* defined USE_COM_CONTEXT_DEF */ +/* Begin additional prototypes for all interfaces */ + +ULONG __RPC_USER SNB_UserSize (ULONG *, ULONG, SNB *); +unsigned char * __RPC_USER SNB_UserMarshal (ULONG *, unsigned char *, SNB *); +unsigned char * __RPC_USER SNB_UserUnmarshal(ULONG *, unsigned char *, SNB *); +void __RPC_USER SNB_UserFree (ULONG *, SNB *); +ULONG __RPC_USER CLIPFORMAT_UserSize (ULONG *, ULONG, CLIPFORMAT *); +unsigned char * __RPC_USER CLIPFORMAT_UserMarshal (ULONG *, unsigned char *, CLIPFORMAT *); +unsigned char * __RPC_USER CLIPFORMAT_UserUnmarshal(ULONG *, unsigned char *, CLIPFORMAT *); +void __RPC_USER CLIPFORMAT_UserFree (ULONG *, CLIPFORMAT *); +ULONG __RPC_USER STGMEDIUM_UserSize (ULONG *, ULONG, STGMEDIUM *); +unsigned char * __RPC_USER STGMEDIUM_UserMarshal (ULONG *, unsigned char *, STGMEDIUM *); +unsigned char * __RPC_USER STGMEDIUM_UserUnmarshal(ULONG *, unsigned char *, STGMEDIUM *); +void __RPC_USER STGMEDIUM_UserFree (ULONG *, STGMEDIUM *); +ULONG __RPC_USER ASYNC_STGMEDIUM_UserSize (ULONG *, ULONG, ASYNC_STGMEDIUM *); +unsigned char * __RPC_USER ASYNC_STGMEDIUM_UserMarshal (ULONG *, unsigned char *, ASYNC_STGMEDIUM *); +unsigned char * __RPC_USER ASYNC_STGMEDIUM_UserUnmarshal(ULONG *, unsigned char *, ASYNC_STGMEDIUM *); +void __RPC_USER ASYNC_STGMEDIUM_UserFree (ULONG *, ASYNC_STGMEDIUM *); +ULONG __RPC_USER FLAG_STGMEDIUM_UserSize (ULONG *, ULONG, FLAG_STGMEDIUM *); +unsigned char * __RPC_USER FLAG_STGMEDIUM_UserMarshal (ULONG *, unsigned char *, FLAG_STGMEDIUM *); +unsigned char * __RPC_USER FLAG_STGMEDIUM_UserUnmarshal(ULONG *, unsigned char *, FLAG_STGMEDIUM *); +void __RPC_USER FLAG_STGMEDIUM_UserFree (ULONG *, FLAG_STGMEDIUM *); +ULONG __RPC_USER HBITMAP_UserSize (ULONG *, ULONG, HBITMAP *); +unsigned char * __RPC_USER HBITMAP_UserMarshal (ULONG *, unsigned char *, HBITMAP *); +unsigned char * __RPC_USER HBITMAP_UserUnmarshal(ULONG *, unsigned char *, HBITMAP *); +void __RPC_USER HBITMAP_UserFree (ULONG *, HBITMAP *); + +/* End additional prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif /* __WIDL_OBJIDL_H */ |