diff --git a/include/Makefile.in b/include/Makefile.in index 89d1760df43..3ccf35680fa 100644 --- a/include/Makefile.in +++ b/include/Makefile.in @@ -5,6 +5,7 @@ VPATH = @srcdir@ MODULE = none IDL_SRCS = \ + objidl.idl \ unknwn.idl \ wtypes.idl @@ -89,7 +90,6 @@ WINDOWS_INCLUDES = \ ntstatus.h \ oaidl.h \ objbase.h \ - objidl.h \ ocidl.h \ ole2.h \ ole2ver.h \ @@ -205,14 +205,11 @@ WINE_INCLUDES = \ library.h \ obj_base.h \ obj_cache.h \ - obj_channel.h \ - obj_clientserver.h \ obj_comcat.h \ obj_commdlgbrowser.h \ obj_connection.h \ obj_contextmenu.h \ obj_control.h \ - obj_dataobject.h \ obj_dockingwindowframe.h \ obj_dragdrop.h \ obj_dragdrophelper.h \ @@ -221,9 +218,6 @@ WINE_INCLUDES = \ obj_errorinfo.h \ obj_extracticon.h \ obj_inplace.h \ - obj_marshal.h \ - obj_misc.h \ - obj_moniker.h \ obj_oleaut.h \ obj_olefont.h \ obj_oleobj.h \ @@ -231,14 +225,12 @@ WINE_INCLUDES = \ obj_oleview.h \ obj_picture.h \ obj_property.h \ - obj_propertystorage.h \ obj_serviceprovider.h \ obj_shellbrowser.h \ obj_shellextinit.h \ obj_shellfolder.h \ obj_shelllink.h \ obj_shellview.h \ - obj_storage.h \ obj_webbrowser.h \ unicode.h diff --git a/include/objidl.h b/include/objidl.h index 062bea0dbc6..657250ace41 100644 --- a/include/objidl.h +++ b/include/objidl.h @@ -1,52 +1,8966 @@ -/* - * Copyright (C) the Wine project - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __WINE__ +/*** Autogenerated by WIDL 0.1 from objidl.idl - Do not edit ***/ #include "rpc.h" #include "rpcndr.h" -#ifndef COM_NO_WINDOWS_H -#include "windows.h" -#include "ole2.h" -#endif -#endif -#ifndef __WINE_OBJIDL_H -#define __WINE_OBJIDL_H - -#if defined(__WINE__) && !defined(INITGUID) && !defined(__WINE_INCLUDE_OBJIDL) -#error DO NOT INCLUDE DIRECTLY +#ifndef __WIDL_OBJIDL_H +#define __WIDL_OBJIDL_H +#ifdef __cplusplus +extern "C" { #endif - #include "unknwn.h" +typedef struct IStream IStream; +typedef struct IStream16 IStream16; +typedef struct IEnumString IEnumString; +typedef struct IRunningObjectTable IRunningObjectTable; +typedef struct IMoniker IMoniker; +typedef struct IAdviseSink IAdviseSink; +typedef struct IAsyncManager IAsyncManager; +typedef struct IMarshal IMarshal; +typedef IMarshal *LPMARSHAL; -/* the following depend only on obj_base.h */ -#include "wine/obj_misc.h" -#include "wine/obj_channel.h" -#include "wine/obj_clientserver.h" -#include "wine/obj_storage.h" +/***************************************************************************** + * IMarshal interface + */ +DEFINE_GUID(IID_IMarshal, 0x00000003, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IMarshal: IUnknown { -/* the following depend on obj_storage.h */ -#include "wine/obj_marshal.h" -#include "wine/obj_moniker.h" -#include "wine/obj_propertystorage.h" + virtual HRESULT CALLBACK GetUnmarshalClass( + REFIID riid, + void* pv, + DWORD dwDestContext, + void* pvDestContext, + DWORD mshlflags, + CLSID* pCid) = 0; -/* the following depend on obj_moniker.h */ -#include "wine/obj_dataobject.h" + virtual HRESULT CALLBACK GetMarshalSizeMax( + REFIID riid, + void* pv, + DWORD dwDestContext, + void* pvDestContext, + DWORD mshlflags, + DWORD* pSize) = 0; + virtual HRESULT CALLBACK MarshalInterface( + IStream* pStm, + REFIID riid, + void* pv, + DWORD dwDestContext, + void* pvDestContext, + DWORD mshlflags) = 0; -#endif /* __WINE_OBJIDL_H */ + virtual HRESULT CALLBACK UnmarshalInterface( + IStream* pStm, + REFIID riid, + void** ppv) = 0; + + virtual HRESULT CALLBACK ReleaseMarshalData( + IStream* pStm) = 0; + + virtual HRESULT CALLBACK DisconnectObject( + DWORD dwReserved) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IMarshalVtbl IMarshalVtbl; +struct IMarshal { + const IMarshalVtbl* lpVtbl; +}; +struct IMarshalVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IMarshal* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IMarshal* This); + + ULONG (CALLBACK *Release)( + IMarshal* This); + + /*** IMarshal methods ***/ + HRESULT (CALLBACK *GetUnmarshalClass)( + IMarshal* This, + REFIID riid, + void* pv, + DWORD dwDestContext, + void* pvDestContext, + DWORD mshlflags, + CLSID* pCid); + + HRESULT (CALLBACK *GetMarshalSizeMax)( + IMarshal* This, + REFIID riid, + void* pv, + DWORD dwDestContext, + void* pvDestContext, + DWORD mshlflags, + DWORD* pSize); + + HRESULT (CALLBACK *MarshalInterface)( + IMarshal* This, + IStream* pStm, + REFIID riid, + void* pv, + DWORD dwDestContext, + void* pvDestContext, + DWORD mshlflags); + + HRESULT (CALLBACK *UnmarshalInterface)( + IMarshal* This, + IStream* pStm, + REFIID riid, + void** ppv); + + HRESULT (CALLBACK *ReleaseMarshalData)( + IMarshal* This, + IStream* pStm); + + HRESULT (CALLBACK *DisconnectObject)( + IMarshal* This, + DWORD dwReserved); + +}; + +#define IMarshal_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD6 (HRESULT,GetUnmarshalClass,REFIID,riid,void*,pv,DWORD,dwDestContext,void*,pvDestContext,DWORD,mshlflags,CLSID*,pCid) \ + ICOM_METHOD6 (HRESULT,GetMarshalSizeMax,REFIID,riid,void*,pv,DWORD,dwDestContext,void*,pvDestContext,DWORD,mshlflags,DWORD*,pSize) \ + ICOM_METHOD6 (HRESULT,MarshalInterface,IStream*,pStm,REFIID,riid,void*,pv,DWORD,dwDestContext,void*,pvDestContext,DWORD,mshlflags) \ + ICOM_METHOD3 (HRESULT,UnmarshalInterface,IStream*,pStm,REFIID,riid,void**,ppv) \ + ICOM_METHOD1 (HRESULT,ReleaseMarshalData,IStream*,pStm) \ + ICOM_METHOD1 (HRESULT,DisconnectObject,DWORD,dwReserved) + +/*** IUnknown methods ***/ +#define IMarshal_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMarshal_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMarshal_Release(p) (p)->lpVtbl->Release(p) +/*** IMarshal methods ***/ +#define IMarshal_GetUnmarshalClass(p,a,b,c,d,e,f) (p)->lpVtbl->GetUnmarshalClass(p,a,b,c,d,e,f) +#define IMarshal_GetMarshalSizeMax(p,a,b,c,d,e,f) (p)->lpVtbl->GetMarshalSizeMax(p,a,b,c,d,e,f) +#define IMarshal_MarshalInterface(p,a,b,c,d,e,f) (p)->lpVtbl->MarshalInterface(p,a,b,c,d,e,f) +#define IMarshal_UnmarshalInterface(p,a,b,c) (p)->lpVtbl->UnmarshalInterface(p,a,b,c) +#define IMarshal_ReleaseMarshalData(p,a) (p)->lpVtbl->ReleaseMarshalData(p,a) +#define IMarshal_DisconnectObject(p,a) (p)->lpVtbl->DisconnectObject(p,a) + +#endif + +HRESULT CALLBACK IMarshal_GetUnmarshalClass_Proxy( + IMarshal* This, + REFIID riid, + void* pv, + DWORD dwDestContext, + void* pvDestContext, + DWORD mshlflags, + CLSID* pCid); +void __RPC_STUB IMarshal_GetUnmarshalClass_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMarshal_GetMarshalSizeMax_Proxy( + IMarshal* This, + REFIID riid, + void* pv, + DWORD dwDestContext, + void* pvDestContext, + DWORD mshlflags, + DWORD* pSize); +void __RPC_STUB IMarshal_GetMarshalSizeMax_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMarshal_MarshalInterface_Proxy( + IMarshal* This, + IStream* pStm, + REFIID riid, + void* pv, + DWORD dwDestContext, + void* pvDestContext, + DWORD mshlflags); +void __RPC_STUB IMarshal_MarshalInterface_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMarshal_UnmarshalInterface_Proxy( + IMarshal* This, + IStream* pStm, + REFIID riid, + void** ppv); +void __RPC_STUB IMarshal_UnmarshalInterface_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMarshal_ReleaseMarshalData_Proxy( + IMarshal* This, + IStream* pStm); +void __RPC_STUB IMarshal_ReleaseMarshalData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMarshal_DisconnectObject_Proxy( + IMarshal* This, + DWORD dwReserved); +void __RPC_STUB IMarshal_DisconnectObject_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IStdMarshalInfo IStdMarshalInfo; +typedef IStdMarshalInfo *LPSTDMARSHALINFO; + +/***************************************************************************** + * IStdMarshalInfo interface + */ +DEFINE_GUID(IID_IStdMarshalInfo, 0x00000018, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IStdMarshalInfo: IUnknown { + + virtual HRESULT CALLBACK GetClassForHandler( + DWORD dwDestContext, + void* pvDestContext, + CLSID* pClsid) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IStdMarshalInfoVtbl IStdMarshalInfoVtbl; +struct IStdMarshalInfo { + const IStdMarshalInfoVtbl* lpVtbl; +}; +struct IStdMarshalInfoVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IStdMarshalInfo* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IStdMarshalInfo* This); + + ULONG (CALLBACK *Release)( + IStdMarshalInfo* This); + + /*** IStdMarshalInfo methods ***/ + HRESULT (CALLBACK *GetClassForHandler)( + IStdMarshalInfo* This, + DWORD dwDestContext, + void* pvDestContext, + CLSID* pClsid); + +}; + +#define IStdMarshalInfo_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD3 (HRESULT,GetClassForHandler,DWORD,dwDestContext,void*,pvDestContext,CLSID*,pClsid) + +/*** IUnknown methods ***/ +#define IStdMarshalInfo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IStdMarshalInfo_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IStdMarshalInfo_Release(p) (p)->lpVtbl->Release(p) +/*** IStdMarshalInfo methods ***/ +#define IStdMarshalInfo_GetClassForHandler(p,a,b,c) (p)->lpVtbl->GetClassForHandler(p,a,b,c) + +#endif + +HRESULT CALLBACK IStdMarshalInfo_GetClassForHandler_Proxy( + IStdMarshalInfo* This, + DWORD dwDestContext, + void* pvDestContext, + CLSID* pClsid); +void __RPC_STUB IStdMarshalInfo_GetClassForHandler_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IExternalConnection IExternalConnection; +typedef IExternalConnection *LPEXTERNALCONNECTION; + +typedef enum tagEXTCONN { + EXTCONN_STRONG = 0x1, + EXTCONN_WEAK = 0x2, + EXTCONN_CALLABLE = 0x4 +} EXTCONN; + +/***************************************************************************** + * IExternalConnection interface + */ +DEFINE_GUID(IID_IExternalConnection, 0x00000019, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IExternalConnection: IUnknown { + + virtual DWORD CALLBACK AddConnection( + DWORD extconn, + DWORD reserved) = 0; + + virtual DWORD CALLBACK ReleaseConnection( + DWORD extconn, + DWORD reserved, + BOOL fLastReleaseCloses) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IExternalConnectionVtbl IExternalConnectionVtbl; +struct IExternalConnection { + const IExternalConnectionVtbl* lpVtbl; +}; +struct IExternalConnectionVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IExternalConnection* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IExternalConnection* This); + + ULONG (CALLBACK *Release)( + IExternalConnection* This); + + /*** IExternalConnection methods ***/ + DWORD (CALLBACK *AddConnection)( + IExternalConnection* This, + DWORD extconn, + DWORD reserved); + + DWORD (CALLBACK *ReleaseConnection)( + IExternalConnection* This, + DWORD extconn, + DWORD reserved, + BOOL fLastReleaseCloses); + +}; + +#define IExternalConnection_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD2 (DWORD,AddConnection,DWORD,extconn,DWORD,reserved) \ + ICOM_METHOD3 (DWORD,ReleaseConnection,DWORD,extconn,DWORD,reserved,BOOL,fLastReleaseCloses) + +/*** IUnknown methods ***/ +#define IExternalConnection_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IExternalConnection_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IExternalConnection_Release(p) (p)->lpVtbl->Release(p) +/*** IExternalConnection methods ***/ +#define IExternalConnection_AddConnection(p,a,b) (p)->lpVtbl->AddConnection(p,a,b) +#define IExternalConnection_ReleaseConnection(p,a,b,c) (p)->lpVtbl->ReleaseConnection(p,a,b,c) + +#endif + +DWORD CALLBACK IExternalConnection_AddConnection_Proxy( + IExternalConnection* This, + DWORD extconn, + DWORD reserved); +void __RPC_STUB IExternalConnection_AddConnection_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +DWORD CALLBACK IExternalConnection_ReleaseConnection_Proxy( + IExternalConnection* This, + DWORD extconn, + DWORD reserved, + BOOL fLastReleaseCloses); +void __RPC_STUB IExternalConnection_ReleaseConnection_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IMultiQI IMultiQI; +typedef IMultiQI *LPMULTIQI; + +typedef struct tagMULTI_QI { + const IID *pIID; + IUnknown *pItf; + HRESULT hr; +} MULTI_QI; + +/***************************************************************************** + * IMultiQI interface + */ +DEFINE_GUID(IID_IMultiQI, 0x00000020, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IMultiQI: IUnknown { + + virtual HRESULT CALLBACK QueryMultipleInterfaces( + ULONG cMQIs, + MULTI_QI* pMQIs) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IMultiQIVtbl IMultiQIVtbl; +struct IMultiQI { + const IMultiQIVtbl* lpVtbl; +}; +struct IMultiQIVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IMultiQI* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IMultiQI* This); + + ULONG (CALLBACK *Release)( + IMultiQI* This); + + /*** IMultiQI methods ***/ + HRESULT (CALLBACK *QueryMultipleInterfaces)( + IMultiQI* This, + ULONG cMQIs, + MULTI_QI* pMQIs); + +}; + +#define IMultiQI_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD2 (HRESULT,QueryMultipleInterfaces,ULONG,cMQIs,MULTI_QI*,pMQIs) + +/*** IUnknown methods ***/ +#define IMultiQI_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMultiQI_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMultiQI_Release(p) (p)->lpVtbl->Release(p) +/*** IMultiQI methods ***/ +#define IMultiQI_QueryMultipleInterfaces(p,a,b) (p)->lpVtbl->QueryMultipleInterfaces(p,a,b) + +#endif + +HRESULT CALLBACK IMultiQI_QueryMultipleInterfaces_Proxy( + IMultiQI* This, + ULONG cMQIs, + MULTI_QI* pMQIs); +void __RPC_STUB IMultiQI_QueryMultipleInterfaces_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IMalloc IMalloc; +typedef IMalloc *LPMALLOC; + +/***************************************************************************** + * IMalloc interface + */ +DEFINE_GUID(IID_IMalloc, 0x00000002, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IMalloc: IUnknown { + + virtual LPVOID CALLBACK Alloc( + ULONG cb) = 0; + + virtual LPVOID CALLBACK Realloc( + LPVOID pv, + ULONG cb) = 0; + + virtual void CALLBACK Free( + LPVOID pv) = 0; + + virtual ULONG CALLBACK GetSize( + LPVOID pv) = 0; + + virtual int CALLBACK DidAlloc( + LPVOID pv) = 0; + + virtual void CALLBACK HeapMinimize( + ) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IMallocVtbl IMallocVtbl; +struct IMalloc { + const IMallocVtbl* lpVtbl; +}; +struct IMallocVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IMalloc* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IMalloc* This); + + ULONG (CALLBACK *Release)( + IMalloc* This); + + /*** IMalloc methods ***/ + LPVOID (CALLBACK *Alloc)( + IMalloc* This, + ULONG cb); + + LPVOID (CALLBACK *Realloc)( + IMalloc* This, + LPVOID pv, + ULONG cb); + + void (CALLBACK *Free)( + IMalloc* This, + LPVOID pv); + + ULONG (CALLBACK *GetSize)( + IMalloc* This, + LPVOID pv); + + int (CALLBACK *DidAlloc)( + IMalloc* This, + LPVOID pv); + + void (CALLBACK *HeapMinimize)( + IMalloc* This); + +}; + +#define IMalloc_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD1 (LPVOID,Alloc,ULONG,cb) \ + ICOM_METHOD2 (LPVOID,Realloc,LPVOID,pv,ULONG,cb) \ + ICOM_VMETHOD1(Free,LPVOID,pv) \ + ICOM_METHOD1 (ULONG,GetSize,LPVOID,pv) \ + ICOM_METHOD1 (int,DidAlloc,LPVOID,pv) \ + ICOM_VMETHOD (HeapMinimize) + +/*** IUnknown methods ***/ +#define IMalloc_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMalloc_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMalloc_Release(p) (p)->lpVtbl->Release(p) +/*** IMalloc methods ***/ +#define IMalloc_Alloc(p,a) (p)->lpVtbl->Alloc(p,a) +#define IMalloc_Realloc(p,a,b) (p)->lpVtbl->Realloc(p,a,b) +#define IMalloc_Free(p,a) (p)->lpVtbl->Free(p,a) +#define IMalloc_GetSize(p,a) (p)->lpVtbl->GetSize(p,a) +#define IMalloc_DidAlloc(p,a) (p)->lpVtbl->DidAlloc(p,a) +#define IMalloc_HeapMinimize(p) (p)->lpVtbl->HeapMinimize(p) + +#endif + +LPVOID CALLBACK IMalloc_Alloc_Proxy( + IMalloc* This, + ULONG cb); +void __RPC_STUB IMalloc_Alloc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +LPVOID CALLBACK IMalloc_Realloc_Proxy( + IMalloc* This, + LPVOID pv, + ULONG cb); +void __RPC_STUB IMalloc_Realloc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IMalloc_Free_Proxy( + IMalloc* This, + LPVOID pv); +void __RPC_STUB IMalloc_Free_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +ULONG CALLBACK IMalloc_GetSize_Proxy( + IMalloc* This, + LPVOID pv); +void __RPC_STUB IMalloc_GetSize_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +int CALLBACK IMalloc_DidAlloc_Proxy( + IMalloc* This, + LPVOID pv); +void __RPC_STUB IMalloc_DidAlloc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IMalloc_HeapMinimize_Proxy( + IMalloc* This); +void __RPC_STUB IMalloc_HeapMinimize_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IMallocSpy IMallocSpy; +typedef IMallocSpy *LPMALLOCSPY; + +/***************************************************************************** + * IMallocSpy interface + */ +DEFINE_GUID(IID_IMallocSpy, 0x0000001d, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IMallocSpy: IUnknown { + + virtual ULONG CALLBACK PreAlloc( + ULONG cbRequest) = 0; + + virtual LPVOID CALLBACK PostAlloc( + LPVOID pActual) = 0; + + virtual LPVOID CALLBACK PreFree( + LPVOID pRequest, + BOOL fSpyed) = 0; + + virtual void CALLBACK PostFree( + BOOL fSpyed) = 0; + + virtual ULONG CALLBACK PreRealloc( + LPVOID pRequest, + ULONG cbRequest, + LPVOID* ppNewRequest, + BOOL fSpyed) = 0; + + virtual LPVOID CALLBACK PostRealloc( + LPVOID pActual, + BOOL fSpyed) = 0; + + virtual LPVOID CALLBACK PreGetSize( + LPVOID pRequest, + BOOL fSpyed) = 0; + + virtual ULONG CALLBACK PostGetSize( + ULONG cbActual, + BOOL fSpyed) = 0; + + virtual LPVOID CALLBACK PreDidAlloc( + LPVOID pRequest, + BOOL fSpyed) = 0; + + virtual int CALLBACK PostDidAlloc( + LPVOID pRequest, + BOOL fSpyed, + int fActual) = 0; + + virtual void CALLBACK PreHeapMinimize( + ) = 0; + + virtual void CALLBACK PostHeapMinimize( + ) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IMallocSpyVtbl IMallocSpyVtbl; +struct IMallocSpy { + const IMallocSpyVtbl* lpVtbl; +}; +struct IMallocSpyVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IMallocSpy* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IMallocSpy* This); + + ULONG (CALLBACK *Release)( + IMallocSpy* This); + + /*** IMallocSpy methods ***/ + ULONG (CALLBACK *PreAlloc)( + IMallocSpy* This, + ULONG cbRequest); + + LPVOID (CALLBACK *PostAlloc)( + IMallocSpy* This, + LPVOID pActual); + + LPVOID (CALLBACK *PreFree)( + IMallocSpy* This, + LPVOID pRequest, + BOOL fSpyed); + + void (CALLBACK *PostFree)( + IMallocSpy* This, + BOOL fSpyed); + + ULONG (CALLBACK *PreRealloc)( + IMallocSpy* This, + LPVOID pRequest, + ULONG cbRequest, + LPVOID* ppNewRequest, + BOOL fSpyed); + + LPVOID (CALLBACK *PostRealloc)( + IMallocSpy* This, + LPVOID pActual, + BOOL fSpyed); + + LPVOID (CALLBACK *PreGetSize)( + IMallocSpy* This, + LPVOID pRequest, + BOOL fSpyed); + + ULONG (CALLBACK *PostGetSize)( + IMallocSpy* This, + ULONG cbActual, + BOOL fSpyed); + + LPVOID (CALLBACK *PreDidAlloc)( + IMallocSpy* This, + LPVOID pRequest, + BOOL fSpyed); + + int (CALLBACK *PostDidAlloc)( + IMallocSpy* This, + LPVOID pRequest, + BOOL fSpyed, + int fActual); + + void (CALLBACK *PreHeapMinimize)( + IMallocSpy* This); + + void (CALLBACK *PostHeapMinimize)( + IMallocSpy* This); + +}; + +#define IMallocSpy_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD1 (ULONG,PreAlloc,ULONG,cbRequest) \ + ICOM_METHOD1 (LPVOID,PostAlloc,LPVOID,pActual) \ + ICOM_METHOD2 (LPVOID,PreFree,LPVOID,pRequest,BOOL,fSpyed) \ + ICOM_VMETHOD1(PostFree,BOOL,fSpyed) \ + ICOM_METHOD4 (ULONG,PreRealloc,LPVOID,pRequest,ULONG,cbRequest,LPVOID*,ppNewRequest,BOOL,fSpyed) \ + ICOM_METHOD2 (LPVOID,PostRealloc,LPVOID,pActual,BOOL,fSpyed) \ + ICOM_METHOD2 (LPVOID,PreGetSize,LPVOID,pRequest,BOOL,fSpyed) \ + ICOM_METHOD2 (ULONG,PostGetSize,ULONG,cbActual,BOOL,fSpyed) \ + ICOM_METHOD2 (LPVOID,PreDidAlloc,LPVOID,pRequest,BOOL,fSpyed) \ + ICOM_METHOD3 (int,PostDidAlloc,LPVOID,pRequest,BOOL,fSpyed,int,fActual) \ + ICOM_VMETHOD (PreHeapMinimize) \ + ICOM_VMETHOD (PostHeapMinimize) + +/*** IUnknown methods ***/ +#define IMallocSpy_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMallocSpy_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMallocSpy_Release(p) (p)->lpVtbl->Release(p) +/*** IMallocSpy methods ***/ +#define IMallocSpy_PreAlloc(p,a) (p)->lpVtbl->PreAlloc(p,a) +#define IMallocSpy_PostAlloc(p,a) (p)->lpVtbl->PostAlloc(p,a) +#define IMallocSpy_PreFree(p,a,b) (p)->lpVtbl->PreFree(p,a,b) +#define IMallocSpy_PostFree(p,a) (p)->lpVtbl->PostFree(p,a) +#define IMallocSpy_PreRealloc(p,a,b,c,d) (p)->lpVtbl->PreRealloc(p,a,b,c,d) +#define IMallocSpy_PostRealloc(p,a,b) (p)->lpVtbl->PostRealloc(p,a,b) +#define IMallocSpy_PreGetSize(p,a,b) (p)->lpVtbl->PreGetSize(p,a,b) +#define IMallocSpy_PostGetSize(p,a,b) (p)->lpVtbl->PostGetSize(p,a,b) +#define IMallocSpy_PreDidAlloc(p,a,b) (p)->lpVtbl->PreDidAlloc(p,a,b) +#define IMallocSpy_PostDidAlloc(p,a,b,c) (p)->lpVtbl->PostDidAlloc(p,a,b,c) +#define IMallocSpy_PreHeapMinimize(p) (p)->lpVtbl->PreHeapMinimize(p) +#define IMallocSpy_PostHeapMinimize(p) (p)->lpVtbl->PostHeapMinimize(p) + +#endif + +ULONG CALLBACK IMallocSpy_PreAlloc_Proxy( + IMallocSpy* This, + ULONG cbRequest); +void __RPC_STUB IMallocSpy_PreAlloc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +LPVOID CALLBACK IMallocSpy_PostAlloc_Proxy( + IMallocSpy* This, + LPVOID pActual); +void __RPC_STUB IMallocSpy_PostAlloc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +LPVOID CALLBACK IMallocSpy_PreFree_Proxy( + IMallocSpy* This, + LPVOID pRequest, + BOOL fSpyed); +void __RPC_STUB IMallocSpy_PreFree_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IMallocSpy_PostFree_Proxy( + IMallocSpy* This, + BOOL fSpyed); +void __RPC_STUB IMallocSpy_PostFree_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +ULONG CALLBACK IMallocSpy_PreRealloc_Proxy( + IMallocSpy* This, + LPVOID pRequest, + ULONG cbRequest, + LPVOID* ppNewRequest, + BOOL fSpyed); +void __RPC_STUB IMallocSpy_PreRealloc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +LPVOID CALLBACK IMallocSpy_PostRealloc_Proxy( + IMallocSpy* This, + LPVOID pActual, + BOOL fSpyed); +void __RPC_STUB IMallocSpy_PostRealloc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +LPVOID CALLBACK IMallocSpy_PreGetSize_Proxy( + IMallocSpy* This, + LPVOID pRequest, + BOOL fSpyed); +void __RPC_STUB IMallocSpy_PreGetSize_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +ULONG CALLBACK IMallocSpy_PostGetSize_Proxy( + IMallocSpy* This, + ULONG cbActual, + BOOL fSpyed); +void __RPC_STUB IMallocSpy_PostGetSize_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +LPVOID CALLBACK IMallocSpy_PreDidAlloc_Proxy( + IMallocSpy* This, + LPVOID pRequest, + BOOL fSpyed); +void __RPC_STUB IMallocSpy_PreDidAlloc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +int CALLBACK IMallocSpy_PostDidAlloc_Proxy( + IMallocSpy* This, + LPVOID pRequest, + BOOL fSpyed, + int fActual); +void __RPC_STUB IMallocSpy_PostDidAlloc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IMallocSpy_PreHeapMinimize_Proxy( + IMallocSpy* This); +void __RPC_STUB IMallocSpy_PreHeapMinimize_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IMallocSpy_PostHeapMinimize_Proxy( + IMallocSpy* This); +void __RPC_STUB IMallocSpy_PostHeapMinimize_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IEnumUnknown IEnumUnknown; +typedef IEnumUnknown *LPENUMUNKNOWN; + +/***************************************************************************** + * IEnumUnknown interface + */ +DEFINE_GUID(IID_IEnumUnknown, 0x00000100, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IEnumUnknown: IUnknown { + + virtual HRESULT CALLBACK Next( + ULONG celt, + IUnknown** rgelt, + ULONG* pceltFetched) = 0; + + virtual HRESULT CALLBACK Skip( + ULONG celt) = 0; + + virtual HRESULT CALLBACK Reset( + ) = 0; + + virtual HRESULT CALLBACK Clone( + IEnumUnknown** ppenum) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IEnumUnknownVtbl IEnumUnknownVtbl; +struct IEnumUnknown { + const IEnumUnknownVtbl* lpVtbl; +}; +struct IEnumUnknownVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IEnumUnknown* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IEnumUnknown* This); + + ULONG (CALLBACK *Release)( + IEnumUnknown* This); + + /*** IEnumUnknown methods ***/ + HRESULT (CALLBACK *Next)( + IEnumUnknown* This, + ULONG celt, + IUnknown** rgelt, + ULONG* pceltFetched); + + HRESULT (CALLBACK *Skip)( + IEnumUnknown* This, + ULONG celt); + + HRESULT (CALLBACK *Reset)( + IEnumUnknown* This); + + HRESULT (CALLBACK *Clone)( + IEnumUnknown* This, + IEnumUnknown** ppenum); + +}; + +#define IEnumUnknown_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD3 (HRESULT,Next,ULONG,celt,IUnknown**,rgelt,ULONG*,pceltFetched) \ + ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \ + ICOM_METHOD (HRESULT,Reset) \ + ICOM_METHOD1 (HRESULT,Clone,IEnumUnknown**,ppenum) + +/*** IUnknown methods ***/ +#define IEnumUnknown_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumUnknown_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumUnknown_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumUnknown methods ***/ +#define IEnumUnknown_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumUnknown_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumUnknown_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumUnknown_Clone(p,a) (p)->lpVtbl->Clone(p,a) + +#endif + +HRESULT CALLBACK IEnumUnknown_RemoteNext_Proxy( + IEnumUnknown* This, + ULONG celt, + IUnknown** rgelt, + ULONG* pceltFetched); +void __RPC_STUB IEnumUnknown_RemoteNext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumUnknown_Next_Proxy( + IEnumUnknown* This, + ULONG celt, + IUnknown** rgelt, + ULONG* pceltFetched); +HRESULT __RPC_STUB IEnumUnknown_Next_Stub( + IEnumUnknown* This, + ULONG celt, + IUnknown** rgelt, + ULONG* pceltFetched); +HRESULT CALLBACK IEnumUnknown_Skip_Proxy( + IEnumUnknown* This, + ULONG celt); +void __RPC_STUB IEnumUnknown_Skip_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumUnknown_Reset_Proxy( + IEnumUnknown* This); +void __RPC_STUB IEnumUnknown_Reset_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumUnknown_Clone_Proxy( + IEnumUnknown* This, + IEnumUnknown** ppenum); +void __RPC_STUB IEnumUnknown_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct ISurrogate ISurrogate; +typedef ISurrogate *LPSURROGATE; + +/***************************************************************************** + * ISurrogate interface + */ +DEFINE_GUID(IID_ISurrogate, 0x00000022, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ISurrogate: IUnknown { + + virtual HRESULT CALLBACK LoadDllServer( + REFCLSID Clsid) = 0; + + virtual HRESULT CALLBACK FreeSurrogate( + ) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct ISurrogateVtbl ISurrogateVtbl; +struct ISurrogate { + const ISurrogateVtbl* lpVtbl; +}; +struct ISurrogateVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + ISurrogate* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + ISurrogate* This); + + ULONG (CALLBACK *Release)( + ISurrogate* This); + + /*** ISurrogate methods ***/ + HRESULT (CALLBACK *LoadDllServer)( + ISurrogate* This, + REFCLSID Clsid); + + HRESULT (CALLBACK *FreeSurrogate)( + ISurrogate* This); + +}; + +#define ISurrogate_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD1 (HRESULT,LoadDllServer,REFCLSID,Clsid) \ + ICOM_METHOD (HRESULT,FreeSurrogate) + +/*** IUnknown methods ***/ +#define ISurrogate_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ISurrogate_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ISurrogate_Release(p) (p)->lpVtbl->Release(p) +/*** ISurrogate methods ***/ +#define ISurrogate_LoadDllServer(p,a) (p)->lpVtbl->LoadDllServer(p,a) +#define ISurrogate_FreeSurrogate(p) (p)->lpVtbl->FreeSurrogate(p) + +#endif + +HRESULT CALLBACK ISurrogate_LoadDllServer_Proxy( + ISurrogate* This, + REFCLSID Clsid); +void __RPC_STUB ISurrogate_LoadDllServer_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ISurrogate_FreeSurrogate_Proxy( + ISurrogate* This); +void __RPC_STUB ISurrogate_FreeSurrogate_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IGlobalInterfaceTable IGlobalInterfaceTable; +typedef IGlobalInterfaceTable *LPGLOBALINTERFACETABLE; + +/***************************************************************************** + * IGlobalInterfaceTable interface + */ +DEFINE_GUID(IID_IGlobalInterfaceTable, 0x00000146, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IGlobalInterfaceTable: IUnknown { + + virtual HRESULT CALLBACK RegisterInterfaceInGlobal( + IUnknown* pUnk, + REFIID riid, + DWORD* pdwCookie) = 0; + + virtual HRESULT CALLBACK RevokeInterfaceFromGlobal( + DWORD dwCookie) = 0; + + virtual HRESULT CALLBACK GetInterfaceFromGlobal( + DWORD dwCookie, + REFIID riid, + void** ppv) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IGlobalInterfaceTableVtbl IGlobalInterfaceTableVtbl; +struct IGlobalInterfaceTable { + const IGlobalInterfaceTableVtbl* lpVtbl; +}; +struct IGlobalInterfaceTableVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IGlobalInterfaceTable* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IGlobalInterfaceTable* This); + + ULONG (CALLBACK *Release)( + IGlobalInterfaceTable* This); + + /*** IGlobalInterfaceTable methods ***/ + HRESULT (CALLBACK *RegisterInterfaceInGlobal)( + IGlobalInterfaceTable* This, + IUnknown* pUnk, + REFIID riid, + DWORD* pdwCookie); + + HRESULT (CALLBACK *RevokeInterfaceFromGlobal)( + IGlobalInterfaceTable* This, + DWORD dwCookie); + + HRESULT (CALLBACK *GetInterfaceFromGlobal)( + IGlobalInterfaceTable* This, + DWORD dwCookie, + REFIID riid, + void** ppv); + +}; + +#define IGlobalInterfaceTable_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD3 (HRESULT,RegisterInterfaceInGlobal,IUnknown*,pUnk,REFIID,riid,DWORD*,pdwCookie) \ + ICOM_METHOD1 (HRESULT,RevokeInterfaceFromGlobal,DWORD,dwCookie) \ + ICOM_METHOD3 (HRESULT,GetInterfaceFromGlobal,DWORD,dwCookie,REFIID,riid,void**,ppv) + +/*** IUnknown methods ***/ +#define IGlobalInterfaceTable_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IGlobalInterfaceTable_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IGlobalInterfaceTable_Release(p) (p)->lpVtbl->Release(p) +/*** IGlobalInterfaceTable methods ***/ +#define IGlobalInterfaceTable_RegisterInterfaceInGlobal(p,a,b,c) (p)->lpVtbl->RegisterInterfaceInGlobal(p,a,b,c) +#define IGlobalInterfaceTable_RevokeInterfaceFromGlobal(p,a) (p)->lpVtbl->RevokeInterfaceFromGlobal(p,a) +#define IGlobalInterfaceTable_GetInterfaceFromGlobal(p,a,b,c) (p)->lpVtbl->GetInterfaceFromGlobal(p,a,b,c) + +#endif + +HRESULT CALLBACK IGlobalInterfaceTable_RegisterInterfaceInGlobal_Proxy( + IGlobalInterfaceTable* This, + IUnknown* pUnk, + REFIID riid, + DWORD* pdwCookie); +void __RPC_STUB IGlobalInterfaceTable_RegisterInterfaceInGlobal_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IGlobalInterfaceTable_RevokeInterfaceFromGlobal_Proxy( + IGlobalInterfaceTable* This, + DWORD dwCookie); +void __RPC_STUB IGlobalInterfaceTable_RevokeInterfaceFromGlobal_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IGlobalInterfaceTable_GetInterfaceFromGlobal_Proxy( + IGlobalInterfaceTable* This, + DWORD dwCookie, + REFIID riid, + void** ppv); +void __RPC_STUB IGlobalInterfaceTable_GetInterfaceFromGlobal_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IBindCtx IBindCtx; +typedef IBindCtx *LPBINDCTX; + +typedef IBindCtx *LPBC; + +typedef struct tagBIND_OPTS { + DWORD cbStruct; + DWORD grfFlags; + DWORD grfMode; + DWORD dwTickCountDeadline; +} BIND_OPTS, *LPBIND_OPTS; + +typedef struct tagBIND_OPTS2 { + DWORD cbStruct; + DWORD grfFlags; + DWORD grfMode; + DWORD dwTickCountDeadline; + DWORD dwTrackFlags; + DWORD dwClassContext; + LCID locale; + COSERVERINFO *pServerInfo; +} BIND_OPTS2, *LPBIND_OPTS2; + +typedef enum tagBIND_FLAGS { + BIND_MAYBOTHERUSER = 1, + BIND_JUSTTESTEXISTENCE = 2 +} BIND_FLAGS; + +/***************************************************************************** + * IBindCtx interface + */ +DEFINE_GUID(IID_IBindCtx, 0x0000000e, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IBindCtx: IUnknown { + + virtual HRESULT CALLBACK RegisterObjectBound( + IUnknown* punk) = 0; + + virtual HRESULT CALLBACK RevokeObjectBound( + IUnknown* punk) = 0; + + virtual HRESULT CALLBACK ReleaseBoundObjects( + ) = 0; + + virtual HRESULT CALLBACK SetBindOptions( + BIND_OPTS* pbindopts) = 0; + + virtual HRESULT CALLBACK GetBindOptions( + BIND_OPTS* pbindopts) = 0; + + virtual HRESULT CALLBACK GetRunningObjectTable( + IRunningObjectTable** pprot) = 0; + + virtual HRESULT CALLBACK RegisterObjectParam( + LPOLESTR pszKey, + IUnknown* punk) = 0; + + virtual HRESULT CALLBACK GetObjectParam( + LPOLESTR pszKey, + IUnknown** ppunk) = 0; + + virtual HRESULT CALLBACK EnumObjectParam( + IEnumString** ppenum) = 0; + + virtual HRESULT CALLBACK RevokeObjectParam( + LPOLESTR pszKey) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IBindCtxVtbl IBindCtxVtbl; +struct IBindCtx { + const IBindCtxVtbl* lpVtbl; +}; +struct IBindCtxVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IBindCtx* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IBindCtx* This); + + ULONG (CALLBACK *Release)( + IBindCtx* This); + + /*** IBindCtx methods ***/ + HRESULT (CALLBACK *RegisterObjectBound)( + IBindCtx* This, + IUnknown* punk); + + HRESULT (CALLBACK *RevokeObjectBound)( + IBindCtx* This, + IUnknown* punk); + + HRESULT (CALLBACK *ReleaseBoundObjects)( + IBindCtx* This); + + HRESULT (CALLBACK *SetBindOptions)( + IBindCtx* This, + BIND_OPTS* pbindopts); + + HRESULT (CALLBACK *GetBindOptions)( + IBindCtx* This, + BIND_OPTS* pbindopts); + + HRESULT (CALLBACK *GetRunningObjectTable)( + IBindCtx* This, + IRunningObjectTable** pprot); + + HRESULT (CALLBACK *RegisterObjectParam)( + IBindCtx* This, + LPOLESTR pszKey, + IUnknown* punk); + + HRESULT (CALLBACK *GetObjectParam)( + IBindCtx* This, + LPOLESTR pszKey, + IUnknown** ppunk); + + HRESULT (CALLBACK *EnumObjectParam)( + IBindCtx* This, + IEnumString** ppenum); + + HRESULT (CALLBACK *RevokeObjectParam)( + IBindCtx* This, + LPOLESTR pszKey); + +}; + +#define IBindCtx_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD1 (HRESULT,RegisterObjectBound,IUnknown*,punk) \ + ICOM_METHOD1 (HRESULT,RevokeObjectBound,IUnknown*,punk) \ + ICOM_METHOD (HRESULT,ReleaseBoundObjects) \ + ICOM_METHOD1 (HRESULT,SetBindOptions,BIND_OPTS*,pbindopts) \ + ICOM_METHOD1 (HRESULT,GetBindOptions,BIND_OPTS*,pbindopts) \ + ICOM_METHOD1 (HRESULT,GetRunningObjectTable,IRunningObjectTable**,pprot) \ + ICOM_METHOD2 (HRESULT,RegisterObjectParam,LPOLESTR,pszKey,IUnknown*,punk) \ + ICOM_METHOD2 (HRESULT,GetObjectParam,LPOLESTR,pszKey,IUnknown**,ppunk) \ + ICOM_METHOD1 (HRESULT,EnumObjectParam,IEnumString**,ppenum) \ + ICOM_METHOD1 (HRESULT,RevokeObjectParam,LPOLESTR,pszKey) + +/*** IUnknown methods ***/ +#define IBindCtx_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IBindCtx_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IBindCtx_Release(p) (p)->lpVtbl->Release(p) +/*** IBindCtx methods ***/ +#define IBindCtx_RegisterObjectBound(p,a) (p)->lpVtbl->RegisterObjectBound(p,a) +#define IBindCtx_RevokeObjectBound(p,a) (p)->lpVtbl->RevokeObjectBound(p,a) +#define IBindCtx_ReleaseBoundObjects(p) (p)->lpVtbl->ReleaseBoundObjects(p) +#define IBindCtx_SetBindOptions(p,a) (p)->lpVtbl->SetBindOptions(p,a) +#define IBindCtx_GetBindOptions(p,a) (p)->lpVtbl->GetBindOptions(p,a) +#define IBindCtx_GetRunningObjectTable(p,a) (p)->lpVtbl->GetRunningObjectTable(p,a) +#define IBindCtx_RegisterObjectParam(p,a,b) (p)->lpVtbl->RegisterObjectParam(p,a,b) +#define IBindCtx_GetObjectParam(p,a,b) (p)->lpVtbl->GetObjectParam(p,a,b) +#define IBindCtx_EnumObjectParam(p,a) (p)->lpVtbl->EnumObjectParam(p,a) +#define IBindCtx_RevokeObjectParam(p,a) (p)->lpVtbl->RevokeObjectParam(p,a) + +#endif + +HRESULT CALLBACK IBindCtx_RegisterObjectBound_Proxy( + IBindCtx* This, + IUnknown* punk); +void __RPC_STUB IBindCtx_RegisterObjectBound_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IBindCtx_RevokeObjectBound_Proxy( + IBindCtx* This, + IUnknown* punk); +void __RPC_STUB IBindCtx_RevokeObjectBound_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IBindCtx_ReleaseBoundObjects_Proxy( + IBindCtx* This); +void __RPC_STUB IBindCtx_ReleaseBoundObjects_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IBindCtx_RemoteSetBindOptions_Proxy( + IBindCtx* This, + BIND_OPTS2* pbindopts); +void __RPC_STUB IBindCtx_RemoteSetBindOptions_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IBindCtx_SetBindOptions_Proxy( + IBindCtx* This, + BIND_OPTS* pbindopts); +HRESULT __RPC_STUB IBindCtx_SetBindOptions_Stub( + IBindCtx* This, + BIND_OPTS2* pbindopts); +HRESULT CALLBACK IBindCtx_RemoteGetBindOptions_Proxy( + IBindCtx* This, + BIND_OPTS2* pbindopts); +void __RPC_STUB IBindCtx_RemoteGetBindOptions_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IBindCtx_GetBindOptions_Proxy( + IBindCtx* This, + BIND_OPTS* pbindopts); +HRESULT __RPC_STUB IBindCtx_GetBindOptions_Stub( + IBindCtx* This, + BIND_OPTS2* pbindopts); +HRESULT CALLBACK IBindCtx_GetRunningObjectTable_Proxy( + IBindCtx* This, + IRunningObjectTable** pprot); +void __RPC_STUB IBindCtx_GetRunningObjectTable_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IBindCtx_RegisterObjectParam_Proxy( + IBindCtx* This, + LPOLESTR pszKey, + IUnknown* punk); +void __RPC_STUB IBindCtx_RegisterObjectParam_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IBindCtx_GetObjectParam_Proxy( + IBindCtx* This, + LPOLESTR pszKey, + IUnknown** ppunk); +void __RPC_STUB IBindCtx_GetObjectParam_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IBindCtx_EnumObjectParam_Proxy( + IBindCtx* This, + IEnumString** ppenum); +void __RPC_STUB IBindCtx_EnumObjectParam_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IBindCtx_RevokeObjectParam_Proxy( + IBindCtx* This, + LPOLESTR pszKey); +void __RPC_STUB IBindCtx_RevokeObjectParam_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IEnumMoniker IEnumMoniker; +typedef IEnumMoniker *LPENUMMONIKER; + +/***************************************************************************** + * IEnumMoniker interface + */ +DEFINE_GUID(IID_IEnumMoniker, 0x00000102, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IEnumMoniker: IUnknown { + + virtual HRESULT CALLBACK Next( + ULONG celt, + IMoniker** rgelt, + ULONG* pceltFetched) = 0; + + virtual HRESULT CALLBACK Skip( + ULONG celt) = 0; + + virtual HRESULT CALLBACK Reset( + ) = 0; + + virtual HRESULT CALLBACK Clone( + IEnumMoniker** ppenum) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IEnumMonikerVtbl IEnumMonikerVtbl; +struct IEnumMoniker { + const IEnumMonikerVtbl* lpVtbl; +}; +struct IEnumMonikerVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IEnumMoniker* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IEnumMoniker* This); + + ULONG (CALLBACK *Release)( + IEnumMoniker* This); + + /*** IEnumMoniker methods ***/ + HRESULT (CALLBACK *Next)( + IEnumMoniker* This, + ULONG celt, + IMoniker** rgelt, + ULONG* pceltFetched); + + HRESULT (CALLBACK *Skip)( + IEnumMoniker* This, + ULONG celt); + + HRESULT (CALLBACK *Reset)( + IEnumMoniker* This); + + HRESULT (CALLBACK *Clone)( + IEnumMoniker* This, + IEnumMoniker** ppenum); + +}; + +#define IEnumMoniker_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD3 (HRESULT,Next,ULONG,celt,IMoniker**,rgelt,ULONG*,pceltFetched) \ + ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \ + ICOM_METHOD (HRESULT,Reset) \ + ICOM_METHOD1 (HRESULT,Clone,IEnumMoniker**,ppenum) + +/*** IUnknown methods ***/ +#define IEnumMoniker_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumMoniker_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumMoniker_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumMoniker methods ***/ +#define IEnumMoniker_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumMoniker_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumMoniker_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumMoniker_Clone(p,a) (p)->lpVtbl->Clone(p,a) + +#endif + +HRESULT CALLBACK IEnumMoniker_RemoteNext_Proxy( + IEnumMoniker* This, + ULONG celt, + IMoniker** rgelt, + ULONG* pceltFetched); +void __RPC_STUB IEnumMoniker_RemoteNext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumMoniker_Next_Proxy( + IEnumMoniker* This, + ULONG celt, + IMoniker** rgelt, + ULONG* pceltFetched); +HRESULT __RPC_STUB IEnumMoniker_Next_Stub( + IEnumMoniker* This, + ULONG celt, + IMoniker** rgelt, + ULONG* pceltFetched); +HRESULT CALLBACK IEnumMoniker_Skip_Proxy( + IEnumMoniker* This, + ULONG celt); +void __RPC_STUB IEnumMoniker_Skip_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumMoniker_Reset_Proxy( + IEnumMoniker* This); +void __RPC_STUB IEnumMoniker_Reset_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumMoniker_Clone_Proxy( + IEnumMoniker* This, + IEnumMoniker** ppenum); +void __RPC_STUB IEnumMoniker_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IRunnableObject IRunnableObject; +typedef IRunnableObject *LPRUNNABLEOBJECT; + +/***************************************************************************** + * IRunnableObject interface + */ +DEFINE_GUID(IID_IRunnableObject, 0x00000126, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IRunnableObject: IUnknown { + + virtual HRESULT CALLBACK GetRunningClass( + LPCLSID lpClsid) = 0; + + virtual HRESULT CALLBACK Run( + LPBINDCTX pbc) = 0; + + virtual BOOL CALLBACK IsRunning( + ) = 0; + + virtual HRESULT CALLBACK LockRunning( + BOOL fLock, + BOOL fLastUnlockCloses) = 0; + + virtual HRESULT CALLBACK SetContainedObject( + BOOL fContained) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IRunnableObjectVtbl IRunnableObjectVtbl; +struct IRunnableObject { + const IRunnableObjectVtbl* lpVtbl; +}; +struct IRunnableObjectVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IRunnableObject* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IRunnableObject* This); + + ULONG (CALLBACK *Release)( + IRunnableObject* This); + + /*** IRunnableObject methods ***/ + HRESULT (CALLBACK *GetRunningClass)( + IRunnableObject* This, + LPCLSID lpClsid); + + HRESULT (CALLBACK *Run)( + IRunnableObject* This, + LPBINDCTX pbc); + + BOOL (CALLBACK *IsRunning)( + IRunnableObject* This); + + HRESULT (CALLBACK *LockRunning)( + IRunnableObject* This, + BOOL fLock, + BOOL fLastUnlockCloses); + + HRESULT (CALLBACK *SetContainedObject)( + IRunnableObject* This, + BOOL fContained); + +}; + +#define IRunnableObject_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD1 (HRESULT,GetRunningClass,LPCLSID,lpClsid) \ + ICOM_METHOD1 (HRESULT,Run,LPBINDCTX,pbc) \ + ICOM_METHOD (BOOL,IsRunning) \ + ICOM_METHOD2 (HRESULT,LockRunning,BOOL,fLock,BOOL,fLastUnlockCloses) \ + ICOM_METHOD1 (HRESULT,SetContainedObject,BOOL,fContained) + +/*** IUnknown methods ***/ +#define IRunnableObject_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IRunnableObject_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IRunnableObject_Release(p) (p)->lpVtbl->Release(p) +/*** IRunnableObject methods ***/ +#define IRunnableObject_GetRunningClass(p,a) (p)->lpVtbl->GetRunningClass(p,a) +#define IRunnableObject_Run(p,a) (p)->lpVtbl->Run(p,a) +#define IRunnableObject_IsRunning(p) (p)->lpVtbl->IsRunning(p) +#define IRunnableObject_LockRunning(p,a,b) (p)->lpVtbl->LockRunning(p,a,b) +#define IRunnableObject_SetContainedObject(p,a) (p)->lpVtbl->SetContainedObject(p,a) + +#endif + +HRESULT CALLBACK IRunnableObject_GetRunningClass_Proxy( + IRunnableObject* This, + LPCLSID lpClsid); +void __RPC_STUB IRunnableObject_GetRunningClass_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRunnableObject_Run_Proxy( + IRunnableObject* This, + LPBINDCTX pbc); +void __RPC_STUB IRunnableObject_Run_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRunnableObject_RemoteIsRunning_Proxy( + IRunnableObject* This); +void __RPC_STUB IRunnableObject_RemoteIsRunning_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +BOOL CALLBACK IRunnableObject_IsRunning_Proxy( + IRunnableObject* This); +HRESULT __RPC_STUB IRunnableObject_IsRunning_Stub( + IRunnableObject* This); +HRESULT CALLBACK IRunnableObject_LockRunning_Proxy( + IRunnableObject* This, + BOOL fLock, + BOOL fLastUnlockCloses); +void __RPC_STUB IRunnableObject_LockRunning_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRunnableObject_SetContainedObject_Proxy( + IRunnableObject* This, + BOOL fContained); +void __RPC_STUB IRunnableObject_SetContainedObject_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#ifdef __WINE__ +#undef GetObject +#endif +typedef IRunningObjectTable *LPRUNNINGOBJECTTABLE; + +/***************************************************************************** + * IRunningObjectTable interface + */ +DEFINE_GUID(IID_IRunningObjectTable, 0x00000010, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IRunningObjectTable: IUnknown { + + virtual HRESULT CALLBACK Register( + DWORD grfFlags, + IUnknown* punkObject, + IMoniker* pmkObjectName, + DWORD* pdwRegister) = 0; + + virtual HRESULT CALLBACK Revoke( + DWORD dwRegister) = 0; + + virtual HRESULT CALLBACK IsRunning( + IMoniker* pmkObjectName) = 0; + + virtual HRESULT CALLBACK GetObject( + IMoniker* pmkObjectName, + IUnknown** ppunkObject) = 0; + + virtual HRESULT CALLBACK NoteChangeTime( + DWORD dwRegister, + FILETIME* pfiletime) = 0; + + virtual HRESULT CALLBACK GetTimeOfLastChange( + IMoniker* pmkObjectName, + FILETIME* pfiletime) = 0; + + virtual HRESULT CALLBACK EnumRunning( + IEnumMoniker** ppenumMoniker) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IRunningObjectTableVtbl IRunningObjectTableVtbl; +struct IRunningObjectTable { + const IRunningObjectTableVtbl* lpVtbl; +}; +struct IRunningObjectTableVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IRunningObjectTable* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IRunningObjectTable* This); + + ULONG (CALLBACK *Release)( + IRunningObjectTable* This); + + /*** IRunningObjectTable methods ***/ + HRESULT (CALLBACK *Register)( + IRunningObjectTable* This, + DWORD grfFlags, + IUnknown* punkObject, + IMoniker* pmkObjectName, + DWORD* pdwRegister); + + HRESULT (CALLBACK *Revoke)( + IRunningObjectTable* This, + DWORD dwRegister); + + HRESULT (CALLBACK *IsRunning)( + IRunningObjectTable* This, + IMoniker* pmkObjectName); + + HRESULT (CALLBACK *GetObject)( + IRunningObjectTable* This, + IMoniker* pmkObjectName, + IUnknown** ppunkObject); + + HRESULT (CALLBACK *NoteChangeTime)( + IRunningObjectTable* This, + DWORD dwRegister, + FILETIME* pfiletime); + + HRESULT (CALLBACK *GetTimeOfLastChange)( + IRunningObjectTable* This, + IMoniker* pmkObjectName, + FILETIME* pfiletime); + + HRESULT (CALLBACK *EnumRunning)( + IRunningObjectTable* This, + IEnumMoniker** ppenumMoniker); + +}; + +#define IRunningObjectTable_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD4 (HRESULT,Register,DWORD,grfFlags,IUnknown*,punkObject,IMoniker*,pmkObjectName,DWORD*,pdwRegister) \ + ICOM_METHOD1 (HRESULT,Revoke,DWORD,dwRegister) \ + ICOM_METHOD1 (HRESULT,IsRunning,IMoniker*,pmkObjectName) \ + ICOM_METHOD2 (HRESULT,GetObject,IMoniker*,pmkObjectName,IUnknown**,ppunkObject) \ + ICOM_METHOD2 (HRESULT,NoteChangeTime,DWORD,dwRegister,FILETIME*,pfiletime) \ + ICOM_METHOD2 (HRESULT,GetTimeOfLastChange,IMoniker*,pmkObjectName,FILETIME*,pfiletime) \ + ICOM_METHOD1 (HRESULT,EnumRunning,IEnumMoniker**,ppenumMoniker) + +/*** IUnknown methods ***/ +#define IRunningObjectTable_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IRunningObjectTable_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IRunningObjectTable_Release(p) (p)->lpVtbl->Release(p) +/*** IRunningObjectTable methods ***/ +#define IRunningObjectTable_Register(p,a,b,c,d) (p)->lpVtbl->Register(p,a,b,c,d) +#define IRunningObjectTable_Revoke(p,a) (p)->lpVtbl->Revoke(p,a) +#define IRunningObjectTable_IsRunning(p,a) (p)->lpVtbl->IsRunning(p,a) +#define IRunningObjectTable_GetObject(p,a,b) (p)->lpVtbl->GetObject(p,a,b) +#define IRunningObjectTable_NoteChangeTime(p,a,b) (p)->lpVtbl->NoteChangeTime(p,a,b) +#define IRunningObjectTable_GetTimeOfLastChange(p,a,b) (p)->lpVtbl->GetTimeOfLastChange(p,a,b) +#define IRunningObjectTable_EnumRunning(p,a) (p)->lpVtbl->EnumRunning(p,a) + +#endif + +HRESULT CALLBACK IRunningObjectTable_Register_Proxy( + IRunningObjectTable* This, + DWORD grfFlags, + IUnknown* punkObject, + IMoniker* pmkObjectName, + DWORD* pdwRegister); +void __RPC_STUB IRunningObjectTable_Register_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRunningObjectTable_Revoke_Proxy( + IRunningObjectTable* This, + DWORD dwRegister); +void __RPC_STUB IRunningObjectTable_Revoke_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRunningObjectTable_IsRunning_Proxy( + IRunningObjectTable* This, + IMoniker* pmkObjectName); +void __RPC_STUB IRunningObjectTable_IsRunning_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRunningObjectTable_GetObject_Proxy( + IRunningObjectTable* This, + IMoniker* pmkObjectName, + IUnknown** ppunkObject); +void __RPC_STUB IRunningObjectTable_GetObject_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRunningObjectTable_NoteChangeTime_Proxy( + IRunningObjectTable* This, + DWORD dwRegister, + FILETIME* pfiletime); +void __RPC_STUB IRunningObjectTable_NoteChangeTime_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRunningObjectTable_GetTimeOfLastChange_Proxy( + IRunningObjectTable* This, + IMoniker* pmkObjectName, + FILETIME* pfiletime); +void __RPC_STUB IRunningObjectTable_GetTimeOfLastChange_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRunningObjectTable_EnumRunning_Proxy( + IRunningObjectTable* This, + IEnumMoniker** ppenumMoniker); +void __RPC_STUB IRunningObjectTable_EnumRunning_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IPersist IPersist; +typedef IPersist *LPPERSIST; + +/***************************************************************************** + * IPersist interface + */ +DEFINE_GUID(IID_IPersist, 0x0000010c, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPersist: IUnknown { + + virtual HRESULT CALLBACK GetClassID( + CLSID* pClassID) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IPersistVtbl IPersistVtbl; +struct IPersist { + const IPersistVtbl* lpVtbl; +}; +struct IPersistVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IPersist* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IPersist* This); + + ULONG (CALLBACK *Release)( + IPersist* This); + + /*** IPersist methods ***/ + HRESULT (CALLBACK *GetClassID)( + IPersist* This, + CLSID* pClassID); + +}; + +#define IPersist_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD1 (HRESULT,GetClassID,CLSID*,pClassID) + +/*** IUnknown methods ***/ +#define IPersist_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPersist_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPersist_Release(p) (p)->lpVtbl->Release(p) +/*** IPersist methods ***/ +#define IPersist_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a) + +#endif + +HRESULT CALLBACK IPersist_GetClassID_Proxy( + IPersist* This, + CLSID* pClassID); +void __RPC_STUB IPersist_GetClassID_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IPersistStream IPersistStream; +typedef IPersistStream *LPPERSISTSTREAM; + +/***************************************************************************** + * IPersistStream interface + */ +DEFINE_GUID(IID_IPersistStream, 0x00000109, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPersistStream: IPersist { + + virtual HRESULT CALLBACK IsDirty( + ) = 0; + + virtual HRESULT CALLBACK Load( + IStream* pStm) = 0; + + virtual HRESULT CALLBACK Save( + IStream* pStm, + BOOL fClearDirty) = 0; + + virtual HRESULT CALLBACK GetSizeMax( + ULARGE_INTEGER* pcbSize) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IPersistStreamVtbl IPersistStreamVtbl; +struct IPersistStream { + const IPersistStreamVtbl* lpVtbl; +}; +struct IPersistStreamVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IPersistStream* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IPersistStream* This); + + ULONG (CALLBACK *Release)( + IPersistStream* This); + + /*** IPersist methods ***/ + HRESULT (CALLBACK *GetClassID)( + IPersistStream* This, + CLSID* pClassID); + + /*** IPersistStream methods ***/ + HRESULT (CALLBACK *IsDirty)( + IPersistStream* This); + + HRESULT (CALLBACK *Load)( + IPersistStream* This, + IStream* pStm); + + HRESULT (CALLBACK *Save)( + IPersistStream* This, + IStream* pStm, + BOOL fClearDirty); + + HRESULT (CALLBACK *GetSizeMax)( + IPersistStream* This, + ULARGE_INTEGER* pcbSize); + +}; + +#define IPersistStream_IMETHODS \ + IPersist_IMETHODS \ + ICOM_METHOD (HRESULT,IsDirty) \ + ICOM_METHOD1 (HRESULT,Load,IStream*,pStm) \ + ICOM_METHOD2 (HRESULT,Save,IStream*,pStm,BOOL,fClearDirty) \ + ICOM_METHOD1 (HRESULT,GetSizeMax,ULARGE_INTEGER*,pcbSize) + +/*** IUnknown methods ***/ +#define IPersistStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPersistStream_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPersistStream_Release(p) (p)->lpVtbl->Release(p) +/*** IPersist methods ***/ +#define IPersistStream_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a) +/*** IPersistStream methods ***/ +#define IPersistStream_IsDirty(p) (p)->lpVtbl->IsDirty(p) +#define IPersistStream_Load(p,a) (p)->lpVtbl->Load(p,a) +#define IPersistStream_Save(p,a,b) (p)->lpVtbl->Save(p,a,b) +#define IPersistStream_GetSizeMax(p,a) (p)->lpVtbl->GetSizeMax(p,a) + +#endif + +HRESULT CALLBACK IPersistStream_IsDirty_Proxy( + IPersistStream* This); +void __RPC_STUB IPersistStream_IsDirty_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistStream_Load_Proxy( + IPersistStream* This, + IStream* pStm); +void __RPC_STUB IPersistStream_Load_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistStream_Save_Proxy( + IPersistStream* This, + IStream* pStm, + BOOL fClearDirty); +void __RPC_STUB IPersistStream_Save_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistStream_GetSizeMax_Proxy( + IPersistStream* This, + ULARGE_INTEGER* pcbSize); +void __RPC_STUB IPersistStream_GetSizeMax_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef IMoniker *LPMONIKER; + +typedef enum tagMKSYS { + MKSYS_NONE = 0, + MKSYS_GENERICCOMPOSITE = 1, + MKSYS_FILEMONIKER = 2, + MKSYS_ANTIMONIKER = 3, + MKSYS_ITEMMONIKER = 4, + MKSYS_POINTERMONIKER = 5, + MKSYS_CLASSMONIKER = 7 +} MKSYS; + +typedef enum tagMKREDUCE { + MKRREDUCE_ONE = 3 << 16, + MKRREDUCE_TOUSER = 2 << 16, + MKRREDUCE_THROUGHUSER = 1 << 16, + MKRREDUCE_ALL = 0 +} MKRREDUCE; + +/***************************************************************************** + * IMoniker interface + */ +DEFINE_GUID(IID_IMoniker, 0x0000000f, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IMoniker: IPersistStream { + + virtual HRESULT CALLBACK BindToObject( + IBindCtx* pbc, + IMoniker* pmkToLeft, + REFIID riidResult, + void** ppvResult) = 0; + + virtual HRESULT CALLBACK BindToStorage( + IBindCtx* pbc, + IMoniker* pmkToLeft, + REFIID riid, + void** ppvObj) = 0; + + virtual HRESULT CALLBACK Reduce( + IBindCtx* pbc, + DWORD dwReduceHowFar, + IMoniker** ppmkToLeft, + IMoniker** ppmkReduced) = 0; + + virtual HRESULT CALLBACK ComposeWith( + IMoniker* pmkRight, + BOOL fOnlyIfNotGeneric, + IMoniker** ppmkComposite) = 0; + + virtual HRESULT CALLBACK Enum( + BOOL fForward, + IEnumMoniker** ppenumMoniker) = 0; + + virtual HRESULT CALLBACK IsEqual( + IMoniker* pmkOtherMoniker) = 0; + + virtual HRESULT CALLBACK Hash( + DWORD* pdwHash) = 0; + + virtual HRESULT CALLBACK IsRunning( + IBindCtx* pbc, + IMoniker* pmkToLeft, + IMoniker* pmkNewlyRunning) = 0; + + virtual HRESULT CALLBACK GetTimeOfLastChange( + IBindCtx* pbc, + IMoniker* pmkToLeft, + FILETIME* pFileTime) = 0; + + virtual HRESULT CALLBACK Inverse( + IMoniker** ppmk) = 0; + + virtual HRESULT CALLBACK CommonPrefixWith( + IMoniker* pmkOther, + IMoniker** ppmkPrefix) = 0; + + virtual HRESULT CALLBACK RelativePathTo( + IMoniker* pmkOther, + IMoniker** ppmkRelPath) = 0; + + virtual HRESULT CALLBACK GetDisplayName( + IBindCtx* pbc, + IMoniker* pmkToLeft, + LPOLESTR* ppszDisplayName) = 0; + + virtual HRESULT CALLBACK ParseDisplayName( + IBindCtx* pbc, + IMoniker* pmkToLeft, + LPOLESTR pszDisplayName, + ULONG* pchEaten, + IMoniker** ppmkOut) = 0; + + virtual HRESULT CALLBACK IsSystemMoniker( + DWORD* pdwMksys) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IMonikerVtbl IMonikerVtbl; +struct IMoniker { + const IMonikerVtbl* lpVtbl; +}; +struct IMonikerVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IMoniker* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IMoniker* This); + + ULONG (CALLBACK *Release)( + IMoniker* This); + + /*** IPersist methods ***/ + HRESULT (CALLBACK *GetClassID)( + IMoniker* This, + CLSID* pClassID); + + /*** IPersistStream methods ***/ + HRESULT (CALLBACK *IsDirty)( + IMoniker* This); + + HRESULT (CALLBACK *Load)( + IMoniker* This, + IStream* pStm); + + HRESULT (CALLBACK *Save)( + IMoniker* This, + IStream* pStm, + BOOL fClearDirty); + + HRESULT (CALLBACK *GetSizeMax)( + IMoniker* This, + ULARGE_INTEGER* pcbSize); + + /*** IMoniker methods ***/ + HRESULT (CALLBACK *BindToObject)( + IMoniker* This, + IBindCtx* pbc, + IMoniker* pmkToLeft, + REFIID riidResult, + void** ppvResult); + + HRESULT (CALLBACK *BindToStorage)( + IMoniker* This, + IBindCtx* pbc, + IMoniker* pmkToLeft, + REFIID riid, + void** ppvObj); + + HRESULT (CALLBACK *Reduce)( + IMoniker* This, + IBindCtx* pbc, + DWORD dwReduceHowFar, + IMoniker** ppmkToLeft, + IMoniker** ppmkReduced); + + HRESULT (CALLBACK *ComposeWith)( + IMoniker* This, + IMoniker* pmkRight, + BOOL fOnlyIfNotGeneric, + IMoniker** ppmkComposite); + + HRESULT (CALLBACK *Enum)( + IMoniker* This, + BOOL fForward, + IEnumMoniker** ppenumMoniker); + + HRESULT (CALLBACK *IsEqual)( + IMoniker* This, + IMoniker* pmkOtherMoniker); + + HRESULT (CALLBACK *Hash)( + IMoniker* This, + DWORD* pdwHash); + + HRESULT (CALLBACK *IsRunning)( + IMoniker* This, + IBindCtx* pbc, + IMoniker* pmkToLeft, + IMoniker* pmkNewlyRunning); + + HRESULT (CALLBACK *GetTimeOfLastChange)( + IMoniker* This, + IBindCtx* pbc, + IMoniker* pmkToLeft, + FILETIME* pFileTime); + + HRESULT (CALLBACK *Inverse)( + IMoniker* This, + IMoniker** ppmk); + + HRESULT (CALLBACK *CommonPrefixWith)( + IMoniker* This, + IMoniker* pmkOther, + IMoniker** ppmkPrefix); + + HRESULT (CALLBACK *RelativePathTo)( + IMoniker* This, + IMoniker* pmkOther, + IMoniker** ppmkRelPath); + + HRESULT (CALLBACK *GetDisplayName)( + IMoniker* This, + IBindCtx* pbc, + IMoniker* pmkToLeft, + LPOLESTR* ppszDisplayName); + + HRESULT (CALLBACK *ParseDisplayName)( + IMoniker* This, + IBindCtx* pbc, + IMoniker* pmkToLeft, + LPOLESTR pszDisplayName, + ULONG* pchEaten, + IMoniker** ppmkOut); + + HRESULT (CALLBACK *IsSystemMoniker)( + IMoniker* This, + DWORD* pdwMksys); + +}; + +#define IMoniker_IMETHODS \ + IPersistStream_IMETHODS \ + ICOM_METHOD4 (HRESULT,BindToObject,IBindCtx*,pbc,IMoniker*,pmkToLeft,REFIID,riidResult,void**,ppvResult) \ + ICOM_METHOD4 (HRESULT,BindToStorage,IBindCtx*,pbc,IMoniker*,pmkToLeft,REFIID,riid,void**,ppvObj) \ + ICOM_METHOD4 (HRESULT,Reduce,IBindCtx*,pbc,DWORD,dwReduceHowFar,IMoniker**,ppmkToLeft,IMoniker**,ppmkReduced) \ + ICOM_METHOD3 (HRESULT,ComposeWith,IMoniker*,pmkRight,BOOL,fOnlyIfNotGeneric,IMoniker**,ppmkComposite) \ + ICOM_METHOD2 (HRESULT,Enum,BOOL,fForward,IEnumMoniker**,ppenumMoniker) \ + ICOM_METHOD1 (HRESULT,IsEqual,IMoniker*,pmkOtherMoniker) \ + ICOM_METHOD1 (HRESULT,Hash,DWORD*,pdwHash) \ + ICOM_METHOD3 (HRESULT,IsRunning,IBindCtx*,pbc,IMoniker*,pmkToLeft,IMoniker*,pmkNewlyRunning) \ + ICOM_METHOD3 (HRESULT,GetTimeOfLastChange,IBindCtx*,pbc,IMoniker*,pmkToLeft,FILETIME*,pFileTime) \ + ICOM_METHOD1 (HRESULT,Inverse,IMoniker**,ppmk) \ + ICOM_METHOD2 (HRESULT,CommonPrefixWith,IMoniker*,pmkOther,IMoniker**,ppmkPrefix) \ + ICOM_METHOD2 (HRESULT,RelativePathTo,IMoniker*,pmkOther,IMoniker**,ppmkRelPath) \ + ICOM_METHOD3 (HRESULT,GetDisplayName,IBindCtx*,pbc,IMoniker*,pmkToLeft,LPOLESTR*,ppszDisplayName) \ + ICOM_METHOD5 (HRESULT,ParseDisplayName,IBindCtx*,pbc,IMoniker*,pmkToLeft,LPOLESTR,pszDisplayName,ULONG*,pchEaten,IMoniker**,ppmkOut) \ + ICOM_METHOD1 (HRESULT,IsSystemMoniker,DWORD*,pdwMksys) + +/*** IUnknown methods ***/ +#define IMoniker_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMoniker_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMoniker_Release(p) (p)->lpVtbl->Release(p) +/*** IPersist methods ***/ +#define IMoniker_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a) +/*** IPersistStream methods ***/ +#define IMoniker_IsDirty(p) (p)->lpVtbl->IsDirty(p) +#define IMoniker_Load(p,a) (p)->lpVtbl->Load(p,a) +#define IMoniker_Save(p,a,b) (p)->lpVtbl->Save(p,a,b) +#define IMoniker_GetSizeMax(p,a) (p)->lpVtbl->GetSizeMax(p,a) +/*** IMoniker methods ***/ +#define IMoniker_BindToObject(p,a,b,c,d) (p)->lpVtbl->BindToObject(p,a,b,c,d) +#define IMoniker_BindToStorage(p,a,b,c,d) (p)->lpVtbl->BindToStorage(p,a,b,c,d) +#define IMoniker_Reduce(p,a,b,c,d) (p)->lpVtbl->Reduce(p,a,b,c,d) +#define IMoniker_ComposeWith(p,a,b,c) (p)->lpVtbl->ComposeWith(p,a,b,c) +#define IMoniker_Enum(p,a,b) (p)->lpVtbl->Enum(p,a,b) +#define IMoniker_IsEqual(p,a) (p)->lpVtbl->IsEqual(p,a) +#define IMoniker_Hash(p,a) (p)->lpVtbl->Hash(p,a) +#define IMoniker_IsRunning(p,a,b,c) (p)->lpVtbl->IsRunning(p,a,b,c) +#define IMoniker_GetTimeOfLastChange(p,a,b,c) (p)->lpVtbl->GetTimeOfLastChange(p,a,b,c) +#define IMoniker_Inverse(p,a) (p)->lpVtbl->Inverse(p,a) +#define IMoniker_CommonPrefixWith(p,a,b) (p)->lpVtbl->CommonPrefixWith(p,a,b) +#define IMoniker_RelativePathTo(p,a,b) (p)->lpVtbl->RelativePathTo(p,a,b) +#define IMoniker_GetDisplayName(p,a,b,c) (p)->lpVtbl->GetDisplayName(p,a,b,c) +#define IMoniker_ParseDisplayName(p,a,b,c,d,e) (p)->lpVtbl->ParseDisplayName(p,a,b,c,d,e) +#define IMoniker_IsSystemMoniker(p,a) (p)->lpVtbl->IsSystemMoniker(p,a) + +#endif + +HRESULT CALLBACK IMoniker_RemoteBindToObject_Proxy( + IMoniker* This, + IBindCtx* pbc, + IMoniker* pmkToLeft, + REFIID riidResult, + IUnknown** ppvResult); +void __RPC_STUB IMoniker_RemoteBindToObject_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMoniker_BindToObject_Proxy( + IMoniker* This, + IBindCtx* pbc, + IMoniker* pmkToLeft, + REFIID riidResult, + void** ppvResult); +HRESULT __RPC_STUB IMoniker_BindToObject_Stub( + IMoniker* This, + IBindCtx* pbc, + IMoniker* pmkToLeft, + REFIID riidResult, + IUnknown** ppvResult); +HRESULT CALLBACK IMoniker_RemoteBindToStorage_Proxy( + IMoniker* This, + IBindCtx* pbc, + IMoniker* pmkToLeft, + REFIID riid, + IUnknown** ppvObj); +void __RPC_STUB IMoniker_RemoteBindToStorage_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMoniker_BindToStorage_Proxy( + IMoniker* This, + IBindCtx* pbc, + IMoniker* pmkToLeft, + REFIID riid, + void** ppvObj); +HRESULT __RPC_STUB IMoniker_BindToStorage_Stub( + IMoniker* This, + IBindCtx* pbc, + IMoniker* pmkToLeft, + REFIID riid, + IUnknown** ppvObj); +HRESULT CALLBACK IMoniker_Reduce_Proxy( + IMoniker* This, + IBindCtx* pbc, + DWORD dwReduceHowFar, + IMoniker** ppmkToLeft, + IMoniker** ppmkReduced); +void __RPC_STUB IMoniker_Reduce_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMoniker_ComposeWith_Proxy( + IMoniker* This, + IMoniker* pmkRight, + BOOL fOnlyIfNotGeneric, + IMoniker** ppmkComposite); +void __RPC_STUB IMoniker_ComposeWith_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMoniker_Enum_Proxy( + IMoniker* This, + BOOL fForward, + IEnumMoniker** ppenumMoniker); +void __RPC_STUB IMoniker_Enum_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMoniker_IsEqual_Proxy( + IMoniker* This, + IMoniker* pmkOtherMoniker); +void __RPC_STUB IMoniker_IsEqual_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMoniker_Hash_Proxy( + IMoniker* This, + DWORD* pdwHash); +void __RPC_STUB IMoniker_Hash_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMoniker_IsRunning_Proxy( + IMoniker* This, + IBindCtx* pbc, + IMoniker* pmkToLeft, + IMoniker* pmkNewlyRunning); +void __RPC_STUB IMoniker_IsRunning_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMoniker_GetTimeOfLastChange_Proxy( + IMoniker* This, + IBindCtx* pbc, + IMoniker* pmkToLeft, + FILETIME* pFileTime); +void __RPC_STUB IMoniker_GetTimeOfLastChange_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMoniker_Inverse_Proxy( + IMoniker* This, + IMoniker** ppmk); +void __RPC_STUB IMoniker_Inverse_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMoniker_CommonPrefixWith_Proxy( + IMoniker* This, + IMoniker* pmkOther, + IMoniker** ppmkPrefix); +void __RPC_STUB IMoniker_CommonPrefixWith_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMoniker_RelativePathTo_Proxy( + IMoniker* This, + IMoniker* pmkOther, + IMoniker** ppmkRelPath); +void __RPC_STUB IMoniker_RelativePathTo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMoniker_GetDisplayName_Proxy( + IMoniker* This, + IBindCtx* pbc, + IMoniker* pmkToLeft, + LPOLESTR* ppszDisplayName); +void __RPC_STUB IMoniker_GetDisplayName_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMoniker_ParseDisplayName_Proxy( + IMoniker* This, + IBindCtx* pbc, + IMoniker* pmkToLeft, + LPOLESTR pszDisplayName, + ULONG* pchEaten, + IMoniker** ppmkOut); +void __RPC_STUB IMoniker_ParseDisplayName_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMoniker_IsSystemMoniker_Proxy( + IMoniker* This, + DWORD* pdwMksys); +void __RPC_STUB IMoniker_IsSystemMoniker_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IROTData IROTData; +/***************************************************************************** + * IROTData interface + */ +DEFINE_GUID(IID_IROTData, 0xf29f6bc0, 0x5021, 0x11ce, 0xaa,0x15, 0x00,0x00,0x69,0x01,0x29,0x3f); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IROTData: IUnknown { + + virtual HRESULT CALLBACK GetComparisonData( + byte* pbData, + ULONG cbMax, + ULONG* pcbData) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IROTDataVtbl IROTDataVtbl; +struct IROTData { + const IROTDataVtbl* lpVtbl; +}; +struct IROTDataVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IROTData* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IROTData* This); + + ULONG (CALLBACK *Release)( + IROTData* This); + + /*** IROTData methods ***/ + HRESULT (CALLBACK *GetComparisonData)( + IROTData* This, + byte* pbData, + ULONG cbMax, + ULONG* pcbData); + +}; + +#define IROTData_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD3 (HRESULT,GetComparisonData,byte*,pbData,ULONG,cbMax,ULONG*,pcbData) + +/*** IUnknown methods ***/ +#define IROTData_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IROTData_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IROTData_Release(p) (p)->lpVtbl->Release(p) +/*** IROTData methods ***/ +#define IROTData_GetComparisonData(p,a,b,c) (p)->lpVtbl->GetComparisonData(p,a,b,c) + +#endif + +HRESULT CALLBACK IROTData_GetComparisonData_Proxy( + IROTData* This, + byte* pbData, + ULONG cbMax, + ULONG* pcbData); +void __RPC_STUB IROTData_GetComparisonData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef IEnumString *LPENUMSTRING; + +/***************************************************************************** + * IEnumString interface + */ +DEFINE_GUID(IID_IEnumString, 0x00000101, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IEnumString: IUnknown { + + virtual HRESULT CALLBACK Next( + ULONG celt, + LPOLESTR* rgelt, + ULONG* pceltFetched) = 0; + + virtual HRESULT CALLBACK Skip( + ULONG celt) = 0; + + virtual HRESULT CALLBACK Reset( + ) = 0; + + virtual HRESULT CALLBACK Clone( + IEnumString** ppenum) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IEnumStringVtbl IEnumStringVtbl; +struct IEnumString { + const IEnumStringVtbl* lpVtbl; +}; +struct IEnumStringVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IEnumString* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IEnumString* This); + + ULONG (CALLBACK *Release)( + IEnumString* This); + + /*** IEnumString methods ***/ + HRESULT (CALLBACK *Next)( + IEnumString* This, + ULONG celt, + LPOLESTR* rgelt, + ULONG* pceltFetched); + + HRESULT (CALLBACK *Skip)( + IEnumString* This, + ULONG celt); + + HRESULT (CALLBACK *Reset)( + IEnumString* This); + + HRESULT (CALLBACK *Clone)( + IEnumString* This, + IEnumString** ppenum); + +}; + +#define IEnumString_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD3 (HRESULT,Next,ULONG,celt,LPOLESTR*,rgelt,ULONG*,pceltFetched) \ + ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \ + ICOM_METHOD (HRESULT,Reset) \ + ICOM_METHOD1 (HRESULT,Clone,IEnumString**,ppenum) + +/*** IUnknown methods ***/ +#define IEnumString_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumString_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumString_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumString methods ***/ +#define IEnumString_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumString_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumString_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumString_Clone(p,a) (p)->lpVtbl->Clone(p,a) + +#endif + +HRESULT CALLBACK IEnumString_RemoteNext_Proxy( + IEnumString* This, + ULONG celt, + LPOLESTR* rgelt, + ULONG* pceltFetched); +void __RPC_STUB IEnumString_RemoteNext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumString_Next_Proxy( + IEnumString* This, + ULONG celt, + LPOLESTR* rgelt, + ULONG* pceltFetched); +HRESULT __RPC_STUB IEnumString_Next_Stub( + IEnumString* This, + ULONG celt, + LPOLESTR* rgelt, + ULONG* pceltFetched); +HRESULT CALLBACK IEnumString_Skip_Proxy( + IEnumString* This, + ULONG celt); +void __RPC_STUB IEnumString_Skip_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumString_Reset_Proxy( + IEnumString* This); +void __RPC_STUB IEnumString_Reset_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumString_Clone_Proxy( + IEnumString* This, + IEnumString** ppenum); +void __RPC_STUB IEnumString_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IClassActivator IClassActivator; +/***************************************************************************** + * IClassActivator interface + */ +DEFINE_GUID(IID_IClassActivator, 0x00000140, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IClassActivator: IUnknown { + + virtual HRESULT CALLBACK GetClassObject( + REFCLSID rclsid, + DWORD dwClassContext, + LCID locale, + REFIID riid, + void** ppv) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IClassActivatorVtbl IClassActivatorVtbl; +struct IClassActivator { + const IClassActivatorVtbl* lpVtbl; +}; +struct IClassActivatorVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IClassActivator* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IClassActivator* This); + + ULONG (CALLBACK *Release)( + IClassActivator* This); + + /*** IClassActivator methods ***/ + HRESULT (CALLBACK *GetClassObject)( + IClassActivator* This, + REFCLSID rclsid, + DWORD dwClassContext, + LCID locale, + REFIID riid, + void** ppv); + +}; + +#define IClassActivator_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD5 (HRESULT,GetClassObject,REFCLSID,rclsid,DWORD,dwClassContext,LCID,locale,REFIID,riid,void**,ppv) + +/*** IUnknown methods ***/ +#define IClassActivator_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IClassActivator_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IClassActivator_Release(p) (p)->lpVtbl->Release(p) +/*** IClassActivator methods ***/ +#define IClassActivator_GetClassObject(p,a,b,c,d,e) (p)->lpVtbl->GetClassObject(p,a,b,c,d,e) + +#endif + +HRESULT CALLBACK IClassActivator_GetClassObject_Proxy( + IClassActivator* This, + REFCLSID rclsid, + DWORD dwClassContext, + LCID locale, + REFIID riid, + void** ppv); +void __RPC_STUB IClassActivator_GetClassObject_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct ISequentialStream ISequentialStream; +/***************************************************************************** + * ISequentialStream interface + */ +DEFINE_GUID(IID_ISequentialStream, 0x0c733a30, 0x2a1c, 0x11ce, 0xad,0xe5, 0x00,0xaa,0x00,0x44,0x77,0x3d); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ISequentialStream: IUnknown { + + virtual HRESULT CALLBACK Read( + void* pv, + ULONG cb, + ULONG* pcbRead) = 0; + + virtual HRESULT CALLBACK Write( + const void* pv, + ULONG cb, + ULONG* pcbWritten) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct ISequentialStreamVtbl ISequentialStreamVtbl; +struct ISequentialStream { + const ISequentialStreamVtbl* lpVtbl; +}; +struct ISequentialStreamVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + ISequentialStream* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + ISequentialStream* This); + + ULONG (CALLBACK *Release)( + ISequentialStream* This); + + /*** ISequentialStream methods ***/ + HRESULT (CALLBACK *Read)( + ISequentialStream* This, + void* pv, + ULONG cb, + ULONG* pcbRead); + + HRESULT (CALLBACK *Write)( + ISequentialStream* This, + const void* pv, + ULONG cb, + ULONG* pcbWritten); + +}; + +#define ISequentialStream_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD3 (HRESULT,Read,void*,pv,ULONG,cb,ULONG*,pcbRead) \ + ICOM_METHOD3 (HRESULT,Write,const void*,pv,ULONG,cb,ULONG*,pcbWritten) + +/*** IUnknown methods ***/ +#define ISequentialStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ISequentialStream_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ISequentialStream_Release(p) (p)->lpVtbl->Release(p) +/*** ISequentialStream methods ***/ +#define ISequentialStream_Read(p,a,b,c) (p)->lpVtbl->Read(p,a,b,c) +#define ISequentialStream_Write(p,a,b,c) (p)->lpVtbl->Write(p,a,b,c) + +#endif + +HRESULT CALLBACK ISequentialStream_RemoteRead_Proxy( + ISequentialStream* This, + byte* pv, + ULONG cb, + ULONG* pcbRead); +void __RPC_STUB ISequentialStream_RemoteRead_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ISequentialStream_Read_Proxy( + ISequentialStream* This, + void* pv, + ULONG cb, + ULONG* pcbRead); +HRESULT __RPC_STUB ISequentialStream_Read_Stub( + ISequentialStream* This, + byte* pv, + ULONG cb, + ULONG* pcbRead); +HRESULT CALLBACK ISequentialStream_RemoteWrite_Proxy( + ISequentialStream* This, + const byte* pv, + ULONG cb, + ULONG* pcbWritten); +void __RPC_STUB ISequentialStream_RemoteWrite_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ISequentialStream_Write_Proxy( + ISequentialStream* This, + const void* pv, + ULONG cb, + ULONG* pcbWritten); +HRESULT __RPC_STUB ISequentialStream_Write_Stub( + ISequentialStream* This, + const byte* pv, + ULONG cb, + ULONG* pcbWritten); + +typedef IStream *LPSTREAM; + +typedef struct tagSTATSTG { + LPOLESTR pwcsName; + DWORD type; + ULARGE_INTEGER cbSize; + FILETIME mtime; + FILETIME ctime; + FILETIME atime; + DWORD grfMode; + DWORD grfLocksSupported; + CLSID clsid; + DWORD grfStateBits; + DWORD reserved; +} STATSTG; + +typedef enum tagSTGTY { + STGTY_STORAGE = 1, + STGTY_STREAM = 2, + STGTY_LOCKBYTES = 3, + STGTY_PROPERTY = 4 +} STGTY; + +typedef enum tagSTREAM_SEEK { + STREAM_SEEK_SET = 0, + STREAM_SEEK_CUR = 1, + STREAM_SEEK_END = 2 +} STREAM_SEEK; + +#undef LOCK_MAND +#undef LOCK_READ +#undef LOCK_WRITE +#undef LOCK_RW +typedef enum tagLOCKTYPE { + LOCK_WRITE = 1, + LOCK_EXCLUSIVE = 2, + LOCK_ONLYONCE = 4 +} LOCKTYPE; + +/***************************************************************************** + * IStream interface + */ +DEFINE_GUID(IID_IStream, 0x0000000c, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IStream: ISequentialStream { + + virtual HRESULT CALLBACK Seek( + LARGE_INTEGER dlibMove, + DWORD dwOrigin, + ULARGE_INTEGER* plibNewPosition) = 0; + + virtual HRESULT CALLBACK SetSize( + ULARGE_INTEGER libNewSize) = 0; + + virtual HRESULT CALLBACK CopyTo( + IStream* pstm, + ULARGE_INTEGER cb, + ULARGE_INTEGER* pcbRead, + ULARGE_INTEGER* pcbWritten) = 0; + + virtual HRESULT CALLBACK Commit( + DWORD grfCommitFlags) = 0; + + virtual HRESULT CALLBACK Revert( + ) = 0; + + virtual HRESULT CALLBACK LockRegion( + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType) = 0; + + virtual HRESULT CALLBACK UnlockRegion( + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType) = 0; + + virtual HRESULT CALLBACK Stat( + STATSTG* pstatstg, + DWORD grfStatFlag) = 0; + + virtual HRESULT CALLBACK Clone( + IStream** ppstm) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IStreamVtbl IStreamVtbl; +struct IStream { + const IStreamVtbl* lpVtbl; +}; +struct IStreamVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IStream* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IStream* This); + + ULONG (CALLBACK *Release)( + IStream* This); + + /*** ISequentialStream methods ***/ + HRESULT (CALLBACK *Read)( + IStream* This, + void* pv, + ULONG cb, + ULONG* pcbRead); + + HRESULT (CALLBACK *Write)( + IStream* This, + const void* pv, + ULONG cb, + ULONG* pcbWritten); + + /*** IStream methods ***/ + HRESULT (CALLBACK *Seek)( + IStream* This, + LARGE_INTEGER dlibMove, + DWORD dwOrigin, + ULARGE_INTEGER* plibNewPosition); + + HRESULT (CALLBACK *SetSize)( + IStream* This, + ULARGE_INTEGER libNewSize); + + HRESULT (CALLBACK *CopyTo)( + IStream* This, + IStream* pstm, + ULARGE_INTEGER cb, + ULARGE_INTEGER* pcbRead, + ULARGE_INTEGER* pcbWritten); + + HRESULT (CALLBACK *Commit)( + IStream* This, + DWORD grfCommitFlags); + + HRESULT (CALLBACK *Revert)( + IStream* This); + + HRESULT (CALLBACK *LockRegion)( + IStream* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); + + HRESULT (CALLBACK *UnlockRegion)( + IStream* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); + + HRESULT (CALLBACK *Stat)( + IStream* This, + STATSTG* pstatstg, + DWORD grfStatFlag); + + HRESULT (CALLBACK *Clone)( + IStream* This, + IStream** ppstm); + +}; + +#define IStream_IMETHODS \ + ISequentialStream_IMETHODS \ + ICOM_METHOD3 (HRESULT,Seek,LARGE_INTEGER,dlibMove,DWORD,dwOrigin,ULARGE_INTEGER*,plibNewPosition) \ + ICOM_METHOD1 (HRESULT,SetSize,ULARGE_INTEGER,libNewSize) \ + ICOM_METHOD4 (HRESULT,CopyTo,IStream*,pstm,ULARGE_INTEGER,cb,ULARGE_INTEGER*,pcbRead,ULARGE_INTEGER*,pcbWritten) \ + ICOM_METHOD1 (HRESULT,Commit,DWORD,grfCommitFlags) \ + ICOM_METHOD (HRESULT,Revert) \ + ICOM_METHOD3 (HRESULT,LockRegion,ULARGE_INTEGER,libOffset,ULARGE_INTEGER,cb,DWORD,dwLockType) \ + ICOM_METHOD3 (HRESULT,UnlockRegion,ULARGE_INTEGER,libOffset,ULARGE_INTEGER,cb,DWORD,dwLockType) \ + ICOM_METHOD2 (HRESULT,Stat,STATSTG*,pstatstg,DWORD,grfStatFlag) \ + ICOM_METHOD1 (HRESULT,Clone,IStream**,ppstm) + +/*** IUnknown methods ***/ +#define IStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IStream_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IStream_Release(p) (p)->lpVtbl->Release(p) +/*** ISequentialStream methods ***/ +#define IStream_Read(p,a,b,c) (p)->lpVtbl->Read(p,a,b,c) +#define IStream_Write(p,a,b,c) (p)->lpVtbl->Write(p,a,b,c) +/*** IStream methods ***/ +#define IStream_Seek(p,a,b,c) (p)->lpVtbl->Seek(p,a,b,c) +#define IStream_SetSize(p,a) (p)->lpVtbl->SetSize(p,a) +#define IStream_CopyTo(p,a,b,c,d) (p)->lpVtbl->CopyTo(p,a,b,c,d) +#define IStream_Commit(p,a) (p)->lpVtbl->Commit(p,a) +#define IStream_Revert(p) (p)->lpVtbl->Revert(p) +#define IStream_LockRegion(p,a,b,c) (p)->lpVtbl->LockRegion(p,a,b,c) +#define IStream_UnlockRegion(p,a,b,c) (p)->lpVtbl->UnlockRegion(p,a,b,c) +#define IStream_Stat(p,a,b) (p)->lpVtbl->Stat(p,a,b) +#define IStream_Clone(p,a) (p)->lpVtbl->Clone(p,a) + +#endif + +HRESULT CALLBACK IStream_RemoteSeek_Proxy( + IStream* This, + LARGE_INTEGER dlibMove, + DWORD dwOrigin, + ULARGE_INTEGER* plibNewPosition); +void __RPC_STUB IStream_RemoteSeek_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStream_Seek_Proxy( + IStream* This, + LARGE_INTEGER dlibMove, + DWORD dwOrigin, + ULARGE_INTEGER* plibNewPosition); +HRESULT __RPC_STUB IStream_Seek_Stub( + IStream* This, + LARGE_INTEGER dlibMove, + DWORD dwOrigin, + ULARGE_INTEGER* plibNewPosition); +HRESULT CALLBACK IStream_SetSize_Proxy( + IStream* This, + ULARGE_INTEGER libNewSize); +void __RPC_STUB IStream_SetSize_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStream_RemoteCopyTo_Proxy( + IStream* This, + IStream* pstm, + ULARGE_INTEGER cb, + ULARGE_INTEGER* pcbRead, + ULARGE_INTEGER* pcbWritten); +void __RPC_STUB IStream_RemoteCopyTo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStream_CopyTo_Proxy( + IStream* This, + IStream* pstm, + ULARGE_INTEGER cb, + ULARGE_INTEGER* pcbRead, + ULARGE_INTEGER* pcbWritten); +HRESULT __RPC_STUB IStream_CopyTo_Stub( + IStream* This, + IStream* pstm, + ULARGE_INTEGER cb, + ULARGE_INTEGER* pcbRead, + ULARGE_INTEGER* pcbWritten); +HRESULT CALLBACK IStream_Commit_Proxy( + IStream* This, + DWORD grfCommitFlags); +void __RPC_STUB IStream_Commit_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStream_Revert_Proxy( + IStream* This); +void __RPC_STUB IStream_Revert_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStream_LockRegion_Proxy( + IStream* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); +void __RPC_STUB IStream_LockRegion_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStream_UnlockRegion_Proxy( + IStream* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); +void __RPC_STUB IStream_UnlockRegion_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStream_Stat_Proxy( + IStream* This, + STATSTG* pstatstg, + DWORD grfStatFlag); +void __RPC_STUB IStream_Stat_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStream_Clone_Proxy( + IStream* This, + IStream** ppstm); +void __RPC_STUB IStream_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef IStream16 *LPSTREAM16; + +typedef struct tagSTATSTG16 { + LPOLESTR16 pwcsName; + DWORD type; + ULARGE_INTEGER cbSize; + FILETIME mtime; + FILETIME ctime; + FILETIME atime; + DWORD grfMode; + DWORD grfLocksSupported; + CLSID clsid; + DWORD grfStateBits; + DWORD reserved; +} STATSTG16; + +/***************************************************************************** + * IStream16 interface + */ +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IStream16: ISequentialStream { + + virtual HRESULT CALLBACK Seek( + LARGE_INTEGER dlibMove, + DWORD dwOrigin, + ULARGE_INTEGER* plibNewPosition) = 0; + + virtual HRESULT CALLBACK SetSize( + ULARGE_INTEGER libNewSize) = 0; + + virtual HRESULT CALLBACK CopyTo( + IStream16* pstm, + ULARGE_INTEGER cb, + ULARGE_INTEGER* pcbRead, + ULARGE_INTEGER* pcbWritten) = 0; + + virtual HRESULT CALLBACK Commit( + DWORD grfCommitFlags) = 0; + + virtual HRESULT CALLBACK Revert( + ) = 0; + + virtual HRESULT CALLBACK LockRegion( + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType) = 0; + + virtual HRESULT CALLBACK UnlockRegion( + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType) = 0; + + virtual HRESULT CALLBACK Stat( + STATSTG* pstatstg, + DWORD grfStatFlag) = 0; + + virtual HRESULT CALLBACK Clone( + IStream16** ppstm) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IStream16Vtbl IStream16Vtbl; +struct IStream16 { + const IStream16Vtbl* lpVtbl; +}; +struct IStream16Vtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IStream16* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IStream16* This); + + ULONG (CALLBACK *Release)( + IStream16* This); + + /*** ISequentialStream methods ***/ + HRESULT (CALLBACK *Read)( + IStream16* This, + void* pv, + ULONG cb, + ULONG* pcbRead); + + HRESULT (CALLBACK *Write)( + IStream16* This, + const void* pv, + ULONG cb, + ULONG* pcbWritten); + + /*** IStream16 methods ***/ + HRESULT (CALLBACK *Seek)( + IStream16* This, + LARGE_INTEGER dlibMove, + DWORD dwOrigin, + ULARGE_INTEGER* plibNewPosition); + + HRESULT (CALLBACK *SetSize)( + IStream16* This, + ULARGE_INTEGER libNewSize); + + HRESULT (CALLBACK *CopyTo)( + IStream16* This, + IStream16* pstm, + ULARGE_INTEGER cb, + ULARGE_INTEGER* pcbRead, + ULARGE_INTEGER* pcbWritten); + + HRESULT (CALLBACK *Commit)( + IStream16* This, + DWORD grfCommitFlags); + + HRESULT (CALLBACK *Revert)( + IStream16* This); + + HRESULT (CALLBACK *LockRegion)( + IStream16* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); + + HRESULT (CALLBACK *UnlockRegion)( + IStream16* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); + + HRESULT (CALLBACK *Stat)( + IStream16* This, + STATSTG* pstatstg, + DWORD grfStatFlag); + + HRESULT (CALLBACK *Clone)( + IStream16* This, + IStream16** ppstm); + +}; + +#define IStream16_IMETHODS \ + ISequentialStream_IMETHODS \ + ICOM_METHOD3 (HRESULT,Seek,LARGE_INTEGER,dlibMove,DWORD,dwOrigin,ULARGE_INTEGER*,plibNewPosition) \ + ICOM_METHOD1 (HRESULT,SetSize,ULARGE_INTEGER,libNewSize) \ + ICOM_METHOD4 (HRESULT,CopyTo,IStream16*,pstm,ULARGE_INTEGER,cb,ULARGE_INTEGER*,pcbRead,ULARGE_INTEGER*,pcbWritten) \ + ICOM_METHOD1 (HRESULT,Commit,DWORD,grfCommitFlags) \ + ICOM_METHOD (HRESULT,Revert) \ + ICOM_METHOD3 (HRESULT,LockRegion,ULARGE_INTEGER,libOffset,ULARGE_INTEGER,cb,DWORD,dwLockType) \ + ICOM_METHOD3 (HRESULT,UnlockRegion,ULARGE_INTEGER,libOffset,ULARGE_INTEGER,cb,DWORD,dwLockType) \ + ICOM_METHOD2 (HRESULT,Stat,STATSTG*,pstatstg,DWORD,grfStatFlag) \ + ICOM_METHOD1 (HRESULT,Clone,IStream16**,ppstm) + +/*** IUnknown methods ***/ +#define IStream16_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IStream16_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IStream16_Release(p) (p)->lpVtbl->Release(p) +/*** ISequentialStream methods ***/ +#define IStream16_Read(p,a,b,c) (p)->lpVtbl->Read(p,a,b,c) +#define IStream16_Write(p,a,b,c) (p)->lpVtbl->Write(p,a,b,c) +/*** IStream16 methods ***/ +#define IStream16_Seek(p,a,b,c) (p)->lpVtbl->Seek(p,a,b,c) +#define IStream16_SetSize(p,a) (p)->lpVtbl->SetSize(p,a) +#define IStream16_CopyTo(p,a,b,c,d) (p)->lpVtbl->CopyTo(p,a,b,c,d) +#define IStream16_Commit(p,a) (p)->lpVtbl->Commit(p,a) +#define IStream16_Revert(p) (p)->lpVtbl->Revert(p) +#define IStream16_LockRegion(p,a,b,c) (p)->lpVtbl->LockRegion(p,a,b,c) +#define IStream16_UnlockRegion(p,a,b,c) (p)->lpVtbl->UnlockRegion(p,a,b,c) +#define IStream16_Stat(p,a,b) (p)->lpVtbl->Stat(p,a,b) +#define IStream16_Clone(p,a) (p)->lpVtbl->Clone(p,a) + +#endif + +HRESULT CALLBACK IStream16_RemoteSeek_Proxy( + IStream16* This, + LARGE_INTEGER dlibMove, + DWORD dwOrigin, + ULARGE_INTEGER* plibNewPosition); +void __RPC_STUB IStream16_RemoteSeek_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStream16_Seek_Proxy( + IStream16* This, + LARGE_INTEGER dlibMove, + DWORD dwOrigin, + ULARGE_INTEGER* plibNewPosition); +HRESULT __RPC_STUB IStream16_Seek_Stub( + IStream16* This, + LARGE_INTEGER dlibMove, + DWORD dwOrigin, + ULARGE_INTEGER* plibNewPosition); +HRESULT CALLBACK IStream16_SetSize_Proxy( + IStream16* This, + ULARGE_INTEGER libNewSize); +void __RPC_STUB IStream16_SetSize_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStream16_RemoteCopyTo_Proxy( + IStream16* This, + IStream16* pstm, + ULARGE_INTEGER cb, + ULARGE_INTEGER* pcbRead, + ULARGE_INTEGER* pcbWritten); +void __RPC_STUB IStream16_RemoteCopyTo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStream16_CopyTo_Proxy( + IStream16* This, + IStream16* pstm, + ULARGE_INTEGER cb, + ULARGE_INTEGER* pcbRead, + ULARGE_INTEGER* pcbWritten); +HRESULT __RPC_STUB IStream16_CopyTo_Stub( + IStream16* This, + IStream16* pstm, + ULARGE_INTEGER cb, + ULARGE_INTEGER* pcbRead, + ULARGE_INTEGER* pcbWritten); +HRESULT CALLBACK IStream16_Commit_Proxy( + IStream16* This, + DWORD grfCommitFlags); +void __RPC_STUB IStream16_Commit_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStream16_Revert_Proxy( + IStream16* This); +void __RPC_STUB IStream16_Revert_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStream16_LockRegion_Proxy( + IStream16* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); +void __RPC_STUB IStream16_LockRegion_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStream16_UnlockRegion_Proxy( + IStream16* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); +void __RPC_STUB IStream16_UnlockRegion_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStream16_Stat_Proxy( + IStream16* This, + STATSTG* pstatstg, + DWORD grfStatFlag); +void __RPC_STUB IStream16_Stat_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStream16_Clone_Proxy( + IStream16* This, + IStream16** ppstm); +void __RPC_STUB IStream16_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IEnumSTATSTG IEnumSTATSTG; +typedef IEnumSTATSTG *LPENUMSTATSTG; + +/***************************************************************************** + * IEnumSTATSTG interface + */ +DEFINE_GUID(IID_IEnumSTATSTG, 0x0000000d, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IEnumSTATSTG: IUnknown { + + virtual HRESULT CALLBACK Next( + ULONG celt, + STATSTG* rgelt, + ULONG* pceltFetched) = 0; + + virtual HRESULT CALLBACK Skip( + ULONG celt) = 0; + + virtual HRESULT CALLBACK Reset( + ) = 0; + + virtual HRESULT CALLBACK Clone( + IEnumSTATSTG** ppenum) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IEnumSTATSTGVtbl IEnumSTATSTGVtbl; +struct IEnumSTATSTG { + const IEnumSTATSTGVtbl* lpVtbl; +}; +struct IEnumSTATSTGVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IEnumSTATSTG* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IEnumSTATSTG* This); + + ULONG (CALLBACK *Release)( + IEnumSTATSTG* This); + + /*** IEnumSTATSTG methods ***/ + HRESULT (CALLBACK *Next)( + IEnumSTATSTG* This, + ULONG celt, + STATSTG* rgelt, + ULONG* pceltFetched); + + HRESULT (CALLBACK *Skip)( + IEnumSTATSTG* This, + ULONG celt); + + HRESULT (CALLBACK *Reset)( + IEnumSTATSTG* This); + + HRESULT (CALLBACK *Clone)( + IEnumSTATSTG* This, + IEnumSTATSTG** ppenum); + +}; + +#define IEnumSTATSTG_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD3 (HRESULT,Next,ULONG,celt,STATSTG*,rgelt,ULONG*,pceltFetched) \ + ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \ + ICOM_METHOD (HRESULT,Reset) \ + ICOM_METHOD1 (HRESULT,Clone,IEnumSTATSTG**,ppenum) + +/*** IUnknown methods ***/ +#define IEnumSTATSTG_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumSTATSTG_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumSTATSTG_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumSTATSTG methods ***/ +#define IEnumSTATSTG_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumSTATSTG_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumSTATSTG_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumSTATSTG_Clone(p,a) (p)->lpVtbl->Clone(p,a) + +#endif + +HRESULT CALLBACK IEnumSTATSTG_RemoteNext_Proxy( + IEnumSTATSTG* This, + ULONG celt, + STATSTG* rgelt, + ULONG* pceltFetched); +void __RPC_STUB IEnumSTATSTG_RemoteNext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumSTATSTG_Next_Proxy( + IEnumSTATSTG* This, + ULONG celt, + STATSTG* rgelt, + ULONG* pceltFetched); +HRESULT __RPC_STUB IEnumSTATSTG_Next_Stub( + IEnumSTATSTG* This, + ULONG celt, + STATSTG* rgelt, + ULONG* pceltFetched); +HRESULT CALLBACK IEnumSTATSTG_Skip_Proxy( + IEnumSTATSTG* This, + ULONG celt); +void __RPC_STUB IEnumSTATSTG_Skip_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumSTATSTG_Reset_Proxy( + IEnumSTATSTG* This); +void __RPC_STUB IEnumSTATSTG_Reset_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumSTATSTG_Clone_Proxy( + IEnumSTATSTG* This, + IEnumSTATSTG** ppenum); +void __RPC_STUB IEnumSTATSTG_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IStorage IStorage; +typedef IStorage *LPSTORAGE; + +typedef struct tagRemSNB { + unsigned long ulCntStr; + unsigned long ulCntChar; + OLECHAR rgString[1]; +} RemSNB; + +typedef RemSNB *wireSNB; + +typedef OLECHAR **SNB; + +/***************************************************************************** + * IStorage interface + */ +DEFINE_GUID(IID_IStorage, 0x0000000b, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IStorage: IUnknown { + + virtual HRESULT CALLBACK CreateStream( + LPCOLESTR pwcsName, + DWORD grfMode, + DWORD reserved1, + DWORD reserved2, + IStream** ppstm) = 0; + + virtual HRESULT CALLBACK OpenStream( + LPCOLESTR pwcsName, + void* reserved1, + DWORD grfMode, + DWORD reserved2, + IStream** ppstm) = 0; + + virtual HRESULT CALLBACK CreateStorage( + LPCOLESTR pwcsName, + DWORD grfMode, + DWORD dwStgFmt, + DWORD reserved2, + IStorage** ppstg) = 0; + + virtual HRESULT CALLBACK OpenStorage( + LPCOLESTR pwcsName, + IStorage* pstgPriority, + DWORD grfMode, + SNB snbExclude, + DWORD reserved, + IStorage** ppstg) = 0; + + virtual HRESULT CALLBACK CopyTo( + DWORD ciidExclude, + const IID* rgiidExclude, + SNB snbExclude, + IStorage* pstgDest) = 0; + + virtual HRESULT CALLBACK MoveElementTo( + LPCOLESTR pwcsName, + IStorage* pstgDest, + LPCOLESTR pwcsNewName, + DWORD grfFlags) = 0; + + virtual HRESULT CALLBACK Commit( + DWORD grfCommitFlags) = 0; + + virtual HRESULT CALLBACK Revert( + ) = 0; + + virtual HRESULT CALLBACK EnumElements( + DWORD reserved1, + void* reserved2, + DWORD reserved3, + IEnumSTATSTG** ppenum) = 0; + + virtual HRESULT CALLBACK DestroyElement( + LPCOLESTR pwcsName) = 0; + + virtual HRESULT CALLBACK RenameElement( + LPCOLESTR pwcsOldName, + LPCOLESTR pwcsNewName) = 0; + + virtual HRESULT CALLBACK SetElementTimes( + LPCOLESTR pwcsName, + const FILETIME* pctime, + const FILETIME* patime, + const FILETIME* pmtime) = 0; + + virtual HRESULT CALLBACK SetClass( + REFCLSID clsid) = 0; + + virtual HRESULT CALLBACK SetStateBits( + DWORD grfStateBits, + DWORD grfMask) = 0; + + virtual HRESULT CALLBACK Stat( + STATSTG* pstatstg, + DWORD grfStatFlag) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IStorageVtbl IStorageVtbl; +struct IStorage { + const IStorageVtbl* lpVtbl; +}; +struct IStorageVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IStorage* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IStorage* This); + + ULONG (CALLBACK *Release)( + IStorage* This); + + /*** IStorage methods ***/ + HRESULT (CALLBACK *CreateStream)( + IStorage* This, + LPCOLESTR pwcsName, + DWORD grfMode, + DWORD reserved1, + DWORD reserved2, + IStream** ppstm); + + HRESULT (CALLBACK *OpenStream)( + IStorage* This, + LPCOLESTR pwcsName, + void* reserved1, + DWORD grfMode, + DWORD reserved2, + IStream** ppstm); + + HRESULT (CALLBACK *CreateStorage)( + IStorage* This, + LPCOLESTR pwcsName, + DWORD grfMode, + DWORD dwStgFmt, + DWORD reserved2, + IStorage** ppstg); + + HRESULT (CALLBACK *OpenStorage)( + IStorage* This, + LPCOLESTR pwcsName, + IStorage* pstgPriority, + DWORD grfMode, + SNB snbExclude, + DWORD reserved, + IStorage** ppstg); + + HRESULT (CALLBACK *CopyTo)( + IStorage* This, + DWORD ciidExclude, + const IID* rgiidExclude, + SNB snbExclude, + IStorage* pstgDest); + + HRESULT (CALLBACK *MoveElementTo)( + IStorage* This, + LPCOLESTR pwcsName, + IStorage* pstgDest, + LPCOLESTR pwcsNewName, + DWORD grfFlags); + + HRESULT (CALLBACK *Commit)( + IStorage* This, + DWORD grfCommitFlags); + + HRESULT (CALLBACK *Revert)( + IStorage* This); + + HRESULT (CALLBACK *EnumElements)( + IStorage* This, + DWORD reserved1, + void* reserved2, + DWORD reserved3, + IEnumSTATSTG** ppenum); + + HRESULT (CALLBACK *DestroyElement)( + IStorage* This, + LPCOLESTR pwcsName); + + HRESULT (CALLBACK *RenameElement)( + IStorage* This, + LPCOLESTR pwcsOldName, + LPCOLESTR pwcsNewName); + + HRESULT (CALLBACK *SetElementTimes)( + IStorage* This, + LPCOLESTR pwcsName, + const FILETIME* pctime, + const FILETIME* patime, + const FILETIME* pmtime); + + HRESULT (CALLBACK *SetClass)( + IStorage* This, + REFCLSID clsid); + + HRESULT (CALLBACK *SetStateBits)( + IStorage* This, + DWORD grfStateBits, + DWORD grfMask); + + HRESULT (CALLBACK *Stat)( + IStorage* This, + STATSTG* pstatstg, + DWORD grfStatFlag); + +}; + +#define IStorage_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD5 (HRESULT,CreateStream,LPCOLESTR,pwcsName,DWORD,grfMode,DWORD,reserved1,DWORD,reserved2,IStream**,ppstm) \ + ICOM_METHOD5 (HRESULT,OpenStream,LPCOLESTR,pwcsName,void*,reserved1,DWORD,grfMode,DWORD,reserved2,IStream**,ppstm) \ + ICOM_METHOD5 (HRESULT,CreateStorage,LPCOLESTR,pwcsName,DWORD,grfMode,DWORD,dwStgFmt,DWORD,reserved2,IStorage**,ppstg) \ + ICOM_METHOD6 (HRESULT,OpenStorage,LPCOLESTR,pwcsName,IStorage*,pstgPriority,DWORD,grfMode,SNB,snbExclude,DWORD,reserved,IStorage**,ppstg) \ + ICOM_METHOD4 (HRESULT,CopyTo,DWORD,ciidExclude,const IID*,rgiidExclude,SNB,snbExclude,IStorage*,pstgDest) \ + ICOM_METHOD4 (HRESULT,MoveElementTo,LPCOLESTR,pwcsName,IStorage*,pstgDest,LPCOLESTR,pwcsNewName,DWORD,grfFlags) \ + ICOM_METHOD1 (HRESULT,Commit,DWORD,grfCommitFlags) \ + ICOM_METHOD (HRESULT,Revert) \ + ICOM_METHOD4 (HRESULT,EnumElements,DWORD,reserved1,void*,reserved2,DWORD,reserved3,IEnumSTATSTG**,ppenum) \ + ICOM_METHOD1 (HRESULT,DestroyElement,LPCOLESTR,pwcsName) \ + ICOM_METHOD2 (HRESULT,RenameElement,LPCOLESTR,pwcsOldName,LPCOLESTR,pwcsNewName) \ + ICOM_METHOD4 (HRESULT,SetElementTimes,LPCOLESTR,pwcsName,const FILETIME*,pctime,const FILETIME*,patime,const FILETIME*,pmtime) \ + ICOM_METHOD1 (HRESULT,SetClass,REFCLSID,clsid) \ + ICOM_METHOD2 (HRESULT,SetStateBits,DWORD,grfStateBits,DWORD,grfMask) \ + ICOM_METHOD2 (HRESULT,Stat,STATSTG*,pstatstg,DWORD,grfStatFlag) + +/*** IUnknown methods ***/ +#define IStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IStorage_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IStorage_Release(p) (p)->lpVtbl->Release(p) +/*** IStorage methods ***/ +#define IStorage_CreateStream(p,a,b,c,d,e) (p)->lpVtbl->CreateStream(p,a,b,c,d,e) +#define IStorage_OpenStream(p,a,b,c,d,e) (p)->lpVtbl->OpenStream(p,a,b,c,d,e) +#define IStorage_CreateStorage(p,a,b,c,d,e) (p)->lpVtbl->CreateStorage(p,a,b,c,d,e) +#define IStorage_OpenStorage(p,a,b,c,d,e,f) (p)->lpVtbl->OpenStorage(p,a,b,c,d,e,f) +#define IStorage_CopyTo(p,a,b,c,d) (p)->lpVtbl->CopyTo(p,a,b,c,d) +#define IStorage_MoveElementTo(p,a,b,c,d) (p)->lpVtbl->MoveElementTo(p,a,b,c,d) +#define IStorage_Commit(p,a) (p)->lpVtbl->Commit(p,a) +#define IStorage_Revert(p) (p)->lpVtbl->Revert(p) +#define IStorage_EnumElements(p,a,b,c,d) (p)->lpVtbl->EnumElements(p,a,b,c,d) +#define IStorage_DestroyElement(p,a) (p)->lpVtbl->DestroyElement(p,a) +#define IStorage_RenameElement(p,a,b) (p)->lpVtbl->RenameElement(p,a,b) +#define IStorage_SetElementTimes(p,a,b,c,d) (p)->lpVtbl->SetElementTimes(p,a,b,c,d) +#define IStorage_SetClass(p,a) (p)->lpVtbl->SetClass(p,a) +#define IStorage_SetStateBits(p,a,b) (p)->lpVtbl->SetStateBits(p,a,b) +#define IStorage_Stat(p,a,b) (p)->lpVtbl->Stat(p,a,b) + +#endif + +HRESULT CALLBACK IStorage_CreateStream_Proxy( + IStorage* This, + LPCOLESTR pwcsName, + DWORD grfMode, + DWORD reserved1, + DWORD reserved2, + IStream** ppstm); +void __RPC_STUB IStorage_CreateStream_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage_RemoteOpenStream_Proxy( + IStorage* This, + LPCOLESTR pwcsName, + unsigned long cbReserved1, + byte* reserved1, + DWORD grfMode, + DWORD reserved2, + IStream** ppstm); +void __RPC_STUB IStorage_RemoteOpenStream_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage_OpenStream_Proxy( + IStorage* This, + LPCOLESTR pwcsName, + void* reserved1, + DWORD grfMode, + DWORD reserved2, + IStream** ppstm); +HRESULT __RPC_STUB IStorage_OpenStream_Stub( + IStorage* This, + LPCOLESTR pwcsName, + unsigned long cbReserved1, + byte* reserved1, + DWORD grfMode, + DWORD reserved2, + IStream** ppstm); +HRESULT CALLBACK IStorage_CreateStorage_Proxy( + IStorage* This, + LPCOLESTR pwcsName, + DWORD grfMode, + DWORD dwStgFmt, + DWORD reserved2, + IStorage** ppstg); +void __RPC_STUB IStorage_CreateStorage_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage_OpenStorage_Proxy( + IStorage* This, + LPCOLESTR pwcsName, + IStorage* pstgPriority, + DWORD grfMode, + SNB snbExclude, + DWORD reserved, + IStorage** ppstg); +void __RPC_STUB IStorage_OpenStorage_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage_CopyTo_Proxy( + IStorage* This, + DWORD ciidExclude, + const IID* rgiidExclude, + SNB snbExclude, + IStorage* pstgDest); +void __RPC_STUB IStorage_CopyTo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage_MoveElementTo_Proxy( + IStorage* This, + LPCOLESTR pwcsName, + IStorage* pstgDest, + LPCOLESTR pwcsNewName, + DWORD grfFlags); +void __RPC_STUB IStorage_MoveElementTo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage_Commit_Proxy( + IStorage* This, + DWORD grfCommitFlags); +void __RPC_STUB IStorage_Commit_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage_Revert_Proxy( + IStorage* This); +void __RPC_STUB IStorage_Revert_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage_RemoteEnumElements_Proxy( + IStorage* This, + DWORD reserved1, + unsigned long cbReserved2, + byte* reserved2, + DWORD reserved3, + IEnumSTATSTG** ppenum); +void __RPC_STUB IStorage_RemoteEnumElements_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage_EnumElements_Proxy( + IStorage* This, + DWORD reserved1, + void* reserved2, + DWORD reserved3, + IEnumSTATSTG** ppenum); +HRESULT __RPC_STUB IStorage_EnumElements_Stub( + IStorage* This, + DWORD reserved1, + unsigned long cbReserved2, + byte* reserved2, + DWORD reserved3, + IEnumSTATSTG** ppenum); +HRESULT CALLBACK IStorage_DestroyElement_Proxy( + IStorage* This, + LPCOLESTR pwcsName); +void __RPC_STUB IStorage_DestroyElement_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage_RenameElement_Proxy( + IStorage* This, + LPCOLESTR pwcsOldName, + LPCOLESTR pwcsNewName); +void __RPC_STUB IStorage_RenameElement_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage_SetElementTimes_Proxy( + IStorage* This, + LPCOLESTR pwcsName, + const FILETIME* pctime, + const FILETIME* patime, + const FILETIME* pmtime); +void __RPC_STUB IStorage_SetElementTimes_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage_SetClass_Proxy( + IStorage* This, + REFCLSID clsid); +void __RPC_STUB IStorage_SetClass_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage_SetStateBits_Proxy( + IStorage* This, + DWORD grfStateBits, + DWORD grfMask); +void __RPC_STUB IStorage_SetStateBits_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage_Stat_Proxy( + IStorage* This, + STATSTG* pstatstg, + DWORD grfStatFlag); +void __RPC_STUB IStorage_Stat_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IStorage16 IStorage16; +typedef IStorage16 *LPSTORAGE16; + +typedef struct tagRemSNB16 { + unsigned long ulCntStr; + unsigned long ulCntChar; + OLECHAR16 rgString[1]; +} RemSNB16; + +typedef RemSNB16 *wireSNB16; + +typedef OLECHAR16 **SNB16; + +/***************************************************************************** + * IStorage16 interface + */ +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IStorage16: IUnknown { + + virtual HRESULT CALLBACK CreateStream( + LPCOLESTR16 pwcsName, + DWORD grfMode, + DWORD reserved1, + DWORD reserved2, + IStream16** ppstm) = 0; + + virtual HRESULT CALLBACK OpenStream( + LPCOLESTR16 pwcsName, + void* reserved1, + DWORD grfMode, + DWORD reserved2, + IStream16** ppstm) = 0; + + virtual HRESULT CALLBACK CreateStorage( + LPCOLESTR16 pwcsName, + DWORD grfMode, + DWORD dwStgFmt, + DWORD reserved2, + IStorage16** ppstg) = 0; + + virtual HRESULT CALLBACK OpenStorage( + LPCOLESTR16 pwcsName, + IStorage16* pstgPriority, + DWORD grfMode, + SNB16 snbExclude, + DWORD reserved, + IStorage16** ppstg) = 0; + + virtual HRESULT CALLBACK CopyTo( + DWORD ciidExclude, + const IID* rgiidExclude, + SNB16 snbExclude, + IStorage16* pstgDest) = 0; + + virtual HRESULT CALLBACK MoveElementTo( + LPCOLESTR16 pwcsName, + IStorage16* pstgDest, + LPCOLESTR16 pwcsNewName, + DWORD grfFlags) = 0; + + virtual HRESULT CALLBACK Commit( + DWORD grfCommitFlags) = 0; + + virtual HRESULT CALLBACK Revert( + ) = 0; + + virtual HRESULT CALLBACK EnumElements( + DWORD reserved1, + void* reserved2, + DWORD reserved3, + IEnumSTATSTG** ppenum) = 0; + + virtual HRESULT CALLBACK DestroyElement( + LPCOLESTR16 pwcsName) = 0; + + virtual HRESULT CALLBACK RenameElement( + LPCOLESTR16 pwcsOldName, + LPCOLESTR16 pwcsNewName) = 0; + + virtual HRESULT CALLBACK SetElementTimes( + LPCOLESTR16 pwcsName, + const FILETIME* pctime, + const FILETIME* patime, + const FILETIME* pmtime) = 0; + + virtual HRESULT CALLBACK SetClass( + REFCLSID clsid) = 0; + + virtual HRESULT CALLBACK SetStateBits( + DWORD grfStateBits, + DWORD grfMask) = 0; + + virtual HRESULT CALLBACK Stat( + STATSTG* pstatstg, + DWORD grfStatFlag) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IStorage16Vtbl IStorage16Vtbl; +struct IStorage16 { + const IStorage16Vtbl* lpVtbl; +}; +struct IStorage16Vtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IStorage16* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IStorage16* This); + + ULONG (CALLBACK *Release)( + IStorage16* This); + + /*** IStorage16 methods ***/ + HRESULT (CALLBACK *CreateStream)( + IStorage16* This, + LPCOLESTR16 pwcsName, + DWORD grfMode, + DWORD reserved1, + DWORD reserved2, + IStream16** ppstm); + + HRESULT (CALLBACK *OpenStream)( + IStorage16* This, + LPCOLESTR16 pwcsName, + void* reserved1, + DWORD grfMode, + DWORD reserved2, + IStream16** ppstm); + + HRESULT (CALLBACK *CreateStorage)( + IStorage16* This, + LPCOLESTR16 pwcsName, + DWORD grfMode, + DWORD dwStgFmt, + DWORD reserved2, + IStorage16** ppstg); + + HRESULT (CALLBACK *OpenStorage)( + IStorage16* This, + LPCOLESTR16 pwcsName, + IStorage16* pstgPriority, + DWORD grfMode, + SNB16 snbExclude, + DWORD reserved, + IStorage16** ppstg); + + HRESULT (CALLBACK *CopyTo)( + IStorage16* This, + DWORD ciidExclude, + const IID* rgiidExclude, + SNB16 snbExclude, + IStorage16* pstgDest); + + HRESULT (CALLBACK *MoveElementTo)( + IStorage16* This, + LPCOLESTR16 pwcsName, + IStorage16* pstgDest, + LPCOLESTR16 pwcsNewName, + DWORD grfFlags); + + HRESULT (CALLBACK *Commit)( + IStorage16* This, + DWORD grfCommitFlags); + + HRESULT (CALLBACK *Revert)( + IStorage16* This); + + HRESULT (CALLBACK *EnumElements)( + IStorage16* This, + DWORD reserved1, + void* reserved2, + DWORD reserved3, + IEnumSTATSTG** ppenum); + + HRESULT (CALLBACK *DestroyElement)( + IStorage16* This, + LPCOLESTR16 pwcsName); + + HRESULT (CALLBACK *RenameElement)( + IStorage16* This, + LPCOLESTR16 pwcsOldName, + LPCOLESTR16 pwcsNewName); + + HRESULT (CALLBACK *SetElementTimes)( + IStorage16* This, + LPCOLESTR16 pwcsName, + const FILETIME* pctime, + const FILETIME* patime, + const FILETIME* pmtime); + + HRESULT (CALLBACK *SetClass)( + IStorage16* This, + REFCLSID clsid); + + HRESULT (CALLBACK *SetStateBits)( + IStorage16* This, + DWORD grfStateBits, + DWORD grfMask); + + HRESULT (CALLBACK *Stat)( + IStorage16* This, + STATSTG* pstatstg, + DWORD grfStatFlag); + +}; + +#define IStorage16_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD5 (HRESULT,CreateStream,LPCOLESTR16,pwcsName,DWORD,grfMode,DWORD,reserved1,DWORD,reserved2,IStream16**,ppstm) \ + ICOM_METHOD5 (HRESULT,OpenStream,LPCOLESTR16,pwcsName,void*,reserved1,DWORD,grfMode,DWORD,reserved2,IStream16**,ppstm) \ + ICOM_METHOD5 (HRESULT,CreateStorage,LPCOLESTR16,pwcsName,DWORD,grfMode,DWORD,dwStgFmt,DWORD,reserved2,IStorage16**,ppstg) \ + ICOM_METHOD6 (HRESULT,OpenStorage,LPCOLESTR16,pwcsName,IStorage16*,pstgPriority,DWORD,grfMode,SNB16,snbExclude,DWORD,reserved,IStorage16**,ppstg) \ + ICOM_METHOD4 (HRESULT,CopyTo,DWORD,ciidExclude,const IID*,rgiidExclude,SNB16,snbExclude,IStorage16*,pstgDest) \ + ICOM_METHOD4 (HRESULT,MoveElementTo,LPCOLESTR16,pwcsName,IStorage16*,pstgDest,LPCOLESTR16,pwcsNewName,DWORD,grfFlags) \ + ICOM_METHOD1 (HRESULT,Commit,DWORD,grfCommitFlags) \ + ICOM_METHOD (HRESULT,Revert) \ + ICOM_METHOD4 (HRESULT,EnumElements,DWORD,reserved1,void*,reserved2,DWORD,reserved3,IEnumSTATSTG**,ppenum) \ + ICOM_METHOD1 (HRESULT,DestroyElement,LPCOLESTR16,pwcsName) \ + ICOM_METHOD2 (HRESULT,RenameElement,LPCOLESTR16,pwcsOldName,LPCOLESTR16,pwcsNewName) \ + ICOM_METHOD4 (HRESULT,SetElementTimes,LPCOLESTR16,pwcsName,const FILETIME*,pctime,const FILETIME*,patime,const FILETIME*,pmtime) \ + ICOM_METHOD1 (HRESULT,SetClass,REFCLSID,clsid) \ + ICOM_METHOD2 (HRESULT,SetStateBits,DWORD,grfStateBits,DWORD,grfMask) \ + ICOM_METHOD2 (HRESULT,Stat,STATSTG*,pstatstg,DWORD,grfStatFlag) + +/*** IUnknown methods ***/ +#define IStorage16_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IStorage16_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IStorage16_Release(p) (p)->lpVtbl->Release(p) +/*** IStorage16 methods ***/ +#define IStorage16_CreateStream(p,a,b,c,d,e) (p)->lpVtbl->CreateStream(p,a,b,c,d,e) +#define IStorage16_OpenStream(p,a,b,c,d,e) (p)->lpVtbl->OpenStream(p,a,b,c,d,e) +#define IStorage16_CreateStorage(p,a,b,c,d,e) (p)->lpVtbl->CreateStorage(p,a,b,c,d,e) +#define IStorage16_OpenStorage(p,a,b,c,d,e,f) (p)->lpVtbl->OpenStorage(p,a,b,c,d,e,f) +#define IStorage16_CopyTo(p,a,b,c,d) (p)->lpVtbl->CopyTo(p,a,b,c,d) +#define IStorage16_MoveElementTo(p,a,b,c,d) (p)->lpVtbl->MoveElementTo(p,a,b,c,d) +#define IStorage16_Commit(p,a) (p)->lpVtbl->Commit(p,a) +#define IStorage16_Revert(p) (p)->lpVtbl->Revert(p) +#define IStorage16_EnumElements(p,a,b,c,d) (p)->lpVtbl->EnumElements(p,a,b,c,d) +#define IStorage16_DestroyElement(p,a) (p)->lpVtbl->DestroyElement(p,a) +#define IStorage16_RenameElement(p,a,b) (p)->lpVtbl->RenameElement(p,a,b) +#define IStorage16_SetElementTimes(p,a,b,c,d) (p)->lpVtbl->SetElementTimes(p,a,b,c,d) +#define IStorage16_SetClass(p,a) (p)->lpVtbl->SetClass(p,a) +#define IStorage16_SetStateBits(p,a,b) (p)->lpVtbl->SetStateBits(p,a,b) +#define IStorage16_Stat(p,a,b) (p)->lpVtbl->Stat(p,a,b) + +#endif + +HRESULT CALLBACK IStorage16_CreateStream_Proxy( + IStorage16* This, + LPCOLESTR16 pwcsName, + DWORD grfMode, + DWORD reserved1, + DWORD reserved2, + IStream16** ppstm); +void __RPC_STUB IStorage16_CreateStream_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage16_RemoteOpenStream_Proxy( + IStorage16* This, + LPCOLESTR16 pwcsName, + unsigned long cbReserved1, + byte* reserved1, + DWORD grfMode, + DWORD reserved2, + IStream16** ppstm); +void __RPC_STUB IStorage16_RemoteOpenStream_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage16_OpenStream_Proxy( + IStorage16* This, + LPCOLESTR16 pwcsName, + void* reserved1, + DWORD grfMode, + DWORD reserved2, + IStream16** ppstm); +HRESULT __RPC_STUB IStorage16_OpenStream_Stub( + IStorage16* This, + LPCOLESTR16 pwcsName, + unsigned long cbReserved1, + byte* reserved1, + DWORD grfMode, + DWORD reserved2, + IStream16** ppstm); +HRESULT CALLBACK IStorage16_CreateStorage_Proxy( + IStorage16* This, + LPCOLESTR16 pwcsName, + DWORD grfMode, + DWORD dwStgFmt, + DWORD reserved2, + IStorage16** ppstg); +void __RPC_STUB IStorage16_CreateStorage_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage16_OpenStorage_Proxy( + IStorage16* This, + LPCOLESTR16 pwcsName, + IStorage16* pstgPriority, + DWORD grfMode, + SNB16 snbExclude, + DWORD reserved, + IStorage16** ppstg); +void __RPC_STUB IStorage16_OpenStorage_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage16_CopyTo_Proxy( + IStorage16* This, + DWORD ciidExclude, + const IID* rgiidExclude, + SNB16 snbExclude, + IStorage16* pstgDest); +void __RPC_STUB IStorage16_CopyTo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage16_MoveElementTo_Proxy( + IStorage16* This, + LPCOLESTR16 pwcsName, + IStorage16* pstgDest, + LPCOLESTR16 pwcsNewName, + DWORD grfFlags); +void __RPC_STUB IStorage16_MoveElementTo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage16_Commit_Proxy( + IStorage16* This, + DWORD grfCommitFlags); +void __RPC_STUB IStorage16_Commit_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage16_Revert_Proxy( + IStorage16* This); +void __RPC_STUB IStorage16_Revert_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage16_RemoteEnumElements_Proxy( + IStorage16* This, + DWORD reserved1, + unsigned long cbReserved2, + byte* reserved2, + DWORD reserved3, + IEnumSTATSTG** ppenum); +void __RPC_STUB IStorage16_RemoteEnumElements_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage16_EnumElements_Proxy( + IStorage16* This, + DWORD reserved1, + void* reserved2, + DWORD reserved3, + IEnumSTATSTG** ppenum); +HRESULT __RPC_STUB IStorage16_EnumElements_Stub( + IStorage16* This, + DWORD reserved1, + unsigned long cbReserved2, + byte* reserved2, + DWORD reserved3, + IEnumSTATSTG** ppenum); +HRESULT CALLBACK IStorage16_DestroyElement_Proxy( + IStorage16* This, + LPCOLESTR16 pwcsName); +void __RPC_STUB IStorage16_DestroyElement_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage16_RenameElement_Proxy( + IStorage16* This, + LPCOLESTR16 pwcsOldName, + LPCOLESTR16 pwcsNewName); +void __RPC_STUB IStorage16_RenameElement_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage16_SetElementTimes_Proxy( + IStorage16* This, + LPCOLESTR16 pwcsName, + const FILETIME* pctime, + const FILETIME* patime, + const FILETIME* pmtime); +void __RPC_STUB IStorage16_SetElementTimes_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage16_SetClass_Proxy( + IStorage16* This, + REFCLSID clsid); +void __RPC_STUB IStorage16_SetClass_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage16_SetStateBits_Proxy( + IStorage16* This, + DWORD grfStateBits, + DWORD grfMask); +void __RPC_STUB IStorage16_SetStateBits_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStorage16_Stat_Proxy( + IStorage16* This, + STATSTG* pstatstg, + DWORD grfStatFlag); +void __RPC_STUB IStorage16_Stat_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IPersistFile IPersistFile; +typedef IPersistFile *LPPERSISTFILE; + +/***************************************************************************** + * IPersistFile interface + */ +DEFINE_GUID(IID_IPersistFile, 0x0000010b, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPersistFile: IPersist { + + virtual HRESULT CALLBACK IsDirty( + ) = 0; + + virtual HRESULT CALLBACK Load( + LPCOLESTR pszFileName, + DWORD dwMode) = 0; + + virtual HRESULT CALLBACK Save( + LPCOLESTR pszFileName, + BOOL fRemember) = 0; + + virtual HRESULT CALLBACK SaveCompleted( + LPCOLESTR pszFileName) = 0; + + virtual HRESULT CALLBACK GetCurFile( + LPOLESTR* ppszFileName) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IPersistFileVtbl IPersistFileVtbl; +struct IPersistFile { + const IPersistFileVtbl* lpVtbl; +}; +struct IPersistFileVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IPersistFile* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IPersistFile* This); + + ULONG (CALLBACK *Release)( + IPersistFile* This); + + /*** IPersist methods ***/ + HRESULT (CALLBACK *GetClassID)( + IPersistFile* This, + CLSID* pClassID); + + /*** IPersistFile methods ***/ + HRESULT (CALLBACK *IsDirty)( + IPersistFile* This); + + HRESULT (CALLBACK *Load)( + IPersistFile* This, + LPCOLESTR pszFileName, + DWORD dwMode); + + HRESULT (CALLBACK *Save)( + IPersistFile* This, + LPCOLESTR pszFileName, + BOOL fRemember); + + HRESULT (CALLBACK *SaveCompleted)( + IPersistFile* This, + LPCOLESTR pszFileName); + + HRESULT (CALLBACK *GetCurFile)( + IPersistFile* This, + LPOLESTR* ppszFileName); + +}; + +#define IPersistFile_IMETHODS \ + IPersist_IMETHODS \ + ICOM_METHOD (HRESULT,IsDirty) \ + ICOM_METHOD2 (HRESULT,Load,LPCOLESTR,pszFileName,DWORD,dwMode) \ + ICOM_METHOD2 (HRESULT,Save,LPCOLESTR,pszFileName,BOOL,fRemember) \ + ICOM_METHOD1 (HRESULT,SaveCompleted,LPCOLESTR,pszFileName) \ + ICOM_METHOD1 (HRESULT,GetCurFile,LPOLESTR*,ppszFileName) + +/*** IUnknown methods ***/ +#define IPersistFile_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPersistFile_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPersistFile_Release(p) (p)->lpVtbl->Release(p) +/*** IPersist methods ***/ +#define IPersistFile_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a) +/*** IPersistFile methods ***/ +#define IPersistFile_IsDirty(p) (p)->lpVtbl->IsDirty(p) +#define IPersistFile_Load(p,a,b) (p)->lpVtbl->Load(p,a,b) +#define IPersistFile_Save(p,a,b) (p)->lpVtbl->Save(p,a,b) +#define IPersistFile_SaveCompleted(p,a) (p)->lpVtbl->SaveCompleted(p,a) +#define IPersistFile_GetCurFile(p,a) (p)->lpVtbl->GetCurFile(p,a) + +#endif + +HRESULT CALLBACK IPersistFile_IsDirty_Proxy( + IPersistFile* This); +void __RPC_STUB IPersistFile_IsDirty_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistFile_Load_Proxy( + IPersistFile* This, + LPCOLESTR pszFileName, + DWORD dwMode); +void __RPC_STUB IPersistFile_Load_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistFile_Save_Proxy( + IPersistFile* This, + LPCOLESTR pszFileName, + BOOL fRemember); +void __RPC_STUB IPersistFile_Save_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistFile_SaveCompleted_Proxy( + IPersistFile* This, + LPCOLESTR pszFileName); +void __RPC_STUB IPersistFile_SaveCompleted_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistFile_GetCurFile_Proxy( + IPersistFile* This, + LPOLESTR* ppszFileName); +void __RPC_STUB IPersistFile_GetCurFile_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IPersistStorage IPersistStorage; +typedef IPersistStorage *LPPERSISTSTORAGE; + +/***************************************************************************** + * IPersistStorage interface + */ +DEFINE_GUID(IID_IPersistStorage, 0x0000010a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPersistStorage: IPersist { + + virtual HRESULT CALLBACK IsDirty( + ) = 0; + + virtual HRESULT CALLBACK InitNew( + IStorage* pStg) = 0; + + virtual HRESULT CALLBACK Load( + IStorage* pStg) = 0; + + virtual HRESULT CALLBACK Save( + IStorage* pStgSave, + BOOL fSameAsLoad) = 0; + + virtual HRESULT CALLBACK SaveCompleted( + IStorage* pStgNew) = 0; + + virtual HRESULT CALLBACK HandsOffStorage( + ) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IPersistStorageVtbl IPersistStorageVtbl; +struct IPersistStorage { + const IPersistStorageVtbl* lpVtbl; +}; +struct IPersistStorageVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IPersistStorage* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IPersistStorage* This); + + ULONG (CALLBACK *Release)( + IPersistStorage* This); + + /*** IPersist methods ***/ + HRESULT (CALLBACK *GetClassID)( + IPersistStorage* This, + CLSID* pClassID); + + /*** IPersistStorage methods ***/ + HRESULT (CALLBACK *IsDirty)( + IPersistStorage* This); + + HRESULT (CALLBACK *InitNew)( + IPersistStorage* This, + IStorage* pStg); + + HRESULT (CALLBACK *Load)( + IPersistStorage* This, + IStorage* pStg); + + HRESULT (CALLBACK *Save)( + IPersistStorage* This, + IStorage* pStgSave, + BOOL fSameAsLoad); + + HRESULT (CALLBACK *SaveCompleted)( + IPersistStorage* This, + IStorage* pStgNew); + + HRESULT (CALLBACK *HandsOffStorage)( + IPersistStorage* This); + +}; + +#define IPersistStorage_IMETHODS \ + IPersist_IMETHODS \ + ICOM_METHOD (HRESULT,IsDirty) \ + ICOM_METHOD1 (HRESULT,InitNew,IStorage*,pStg) \ + ICOM_METHOD1 (HRESULT,Load,IStorage*,pStg) \ + ICOM_METHOD2 (HRESULT,Save,IStorage*,pStgSave,BOOL,fSameAsLoad) \ + ICOM_METHOD1 (HRESULT,SaveCompleted,IStorage*,pStgNew) \ + ICOM_METHOD (HRESULT,HandsOffStorage) + +/*** IUnknown methods ***/ +#define IPersistStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPersistStorage_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPersistStorage_Release(p) (p)->lpVtbl->Release(p) +/*** IPersist methods ***/ +#define IPersistStorage_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a) +/*** IPersistStorage methods ***/ +#define IPersistStorage_IsDirty(p) (p)->lpVtbl->IsDirty(p) +#define IPersistStorage_InitNew(p,a) (p)->lpVtbl->InitNew(p,a) +#define IPersistStorage_Load(p,a) (p)->lpVtbl->Load(p,a) +#define IPersistStorage_Save(p,a,b) (p)->lpVtbl->Save(p,a,b) +#define IPersistStorage_SaveCompleted(p,a) (p)->lpVtbl->SaveCompleted(p,a) +#define IPersistStorage_HandsOffStorage(p) (p)->lpVtbl->HandsOffStorage(p) + +#endif + +HRESULT CALLBACK IPersistStorage_IsDirty_Proxy( + IPersistStorage* This); +void __RPC_STUB IPersistStorage_IsDirty_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistStorage_InitNew_Proxy( + IPersistStorage* This, + IStorage* pStg); +void __RPC_STUB IPersistStorage_InitNew_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistStorage_Load_Proxy( + IPersistStorage* This, + IStorage* pStg); +void __RPC_STUB IPersistStorage_Load_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistStorage_Save_Proxy( + IPersistStorage* This, + IStorage* pStgSave, + BOOL fSameAsLoad); +void __RPC_STUB IPersistStorage_Save_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistStorage_SaveCompleted_Proxy( + IPersistStorage* This, + IStorage* pStgNew); +void __RPC_STUB IPersistStorage_SaveCompleted_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistStorage_HandsOffStorage_Proxy( + IPersistStorage* This); +void __RPC_STUB IPersistStorage_HandsOffStorage_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IRootStorage IRootStorage; +typedef IRootStorage *LPROOTSTORAGE; + +/***************************************************************************** + * IRootStorage interface + */ +DEFINE_GUID(IID_IRootStorage, 0x00000012, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IRootStorage: IUnknown { + + virtual HRESULT CALLBACK SwitchToFile( + LPOLESTR pszFile) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IRootStorageVtbl IRootStorageVtbl; +struct IRootStorage { + const IRootStorageVtbl* lpVtbl; +}; +struct IRootStorageVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IRootStorage* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IRootStorage* This); + + ULONG (CALLBACK *Release)( + IRootStorage* This); + + /*** IRootStorage methods ***/ + HRESULT (CALLBACK *SwitchToFile)( + IRootStorage* This, + LPOLESTR pszFile); + +}; + +#define IRootStorage_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD1 (HRESULT,SwitchToFile,LPOLESTR,pszFile) + +/*** IUnknown methods ***/ +#define IRootStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IRootStorage_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IRootStorage_Release(p) (p)->lpVtbl->Release(p) +/*** IRootStorage methods ***/ +#define IRootStorage_SwitchToFile(p,a) (p)->lpVtbl->SwitchToFile(p,a) + +#endif + +HRESULT CALLBACK IRootStorage_SwitchToFile_Proxy( + IRootStorage* This, + LPOLESTR pszFile); +void __RPC_STUB IRootStorage_SwitchToFile_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct ILockBytes ILockBytes; +typedef ILockBytes *LPLOCKBYTES; + +/***************************************************************************** + * ILockBytes interface + */ +DEFINE_GUID(IID_ILockBytes, 0x0000000a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ILockBytes: IUnknown { + + virtual HRESULT CALLBACK ReadAt( + ULARGE_INTEGER ulOffset, + void* pv, + ULONG cb, + ULONG* pcbRead) = 0; + + virtual HRESULT CALLBACK WriteAt( + ULARGE_INTEGER ulOffset, + const void* pv, + ULONG cb, + ULONG* pcbWritten) = 0; + + virtual HRESULT CALLBACK Flush( + ) = 0; + + virtual HRESULT CALLBACK SetSize( + ULARGE_INTEGER cb) = 0; + + virtual HRESULT CALLBACK LockRegion( + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType) = 0; + + virtual HRESULT CALLBACK UnlockRegion( + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType) = 0; + + virtual HRESULT CALLBACK Stat( + STATSTG* pstatstg, + DWORD grfStatFlag) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct ILockBytesVtbl ILockBytesVtbl; +struct ILockBytes { + const ILockBytesVtbl* lpVtbl; +}; +struct ILockBytesVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + ILockBytes* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + ILockBytes* This); + + ULONG (CALLBACK *Release)( + ILockBytes* This); + + /*** ILockBytes methods ***/ + HRESULT (CALLBACK *ReadAt)( + ILockBytes* This, + ULARGE_INTEGER ulOffset, + void* pv, + ULONG cb, + ULONG* pcbRead); + + HRESULT (CALLBACK *WriteAt)( + ILockBytes* This, + ULARGE_INTEGER ulOffset, + const void* pv, + ULONG cb, + ULONG* pcbWritten); + + HRESULT (CALLBACK *Flush)( + ILockBytes* This); + + HRESULT (CALLBACK *SetSize)( + ILockBytes* This, + ULARGE_INTEGER cb); + + HRESULT (CALLBACK *LockRegion)( + ILockBytes* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); + + HRESULT (CALLBACK *UnlockRegion)( + ILockBytes* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); + + HRESULT (CALLBACK *Stat)( + ILockBytes* This, + STATSTG* pstatstg, + DWORD grfStatFlag); + +}; + +#define ILockBytes_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD4 (HRESULT,ReadAt,ULARGE_INTEGER,ulOffset,void*,pv,ULONG,cb,ULONG*,pcbRead) \ + ICOM_METHOD4 (HRESULT,WriteAt,ULARGE_INTEGER,ulOffset,const void*,pv,ULONG,cb,ULONG*,pcbWritten) \ + ICOM_METHOD (HRESULT,Flush) \ + ICOM_METHOD1 (HRESULT,SetSize,ULARGE_INTEGER,cb) \ + ICOM_METHOD3 (HRESULT,LockRegion,ULARGE_INTEGER,libOffset,ULARGE_INTEGER,cb,DWORD,dwLockType) \ + ICOM_METHOD3 (HRESULT,UnlockRegion,ULARGE_INTEGER,libOffset,ULARGE_INTEGER,cb,DWORD,dwLockType) \ + ICOM_METHOD2 (HRESULT,Stat,STATSTG*,pstatstg,DWORD,grfStatFlag) + +/*** IUnknown methods ***/ +#define ILockBytes_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ILockBytes_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ILockBytes_Release(p) (p)->lpVtbl->Release(p) +/*** ILockBytes methods ***/ +#define ILockBytes_ReadAt(p,a,b,c,d) (p)->lpVtbl->ReadAt(p,a,b,c,d) +#define ILockBytes_WriteAt(p,a,b,c,d) (p)->lpVtbl->WriteAt(p,a,b,c,d) +#define ILockBytes_Flush(p) (p)->lpVtbl->Flush(p) +#define ILockBytes_SetSize(p,a) (p)->lpVtbl->SetSize(p,a) +#define ILockBytes_LockRegion(p,a,b,c) (p)->lpVtbl->LockRegion(p,a,b,c) +#define ILockBytes_UnlockRegion(p,a,b,c) (p)->lpVtbl->UnlockRegion(p,a,b,c) +#define ILockBytes_Stat(p,a,b) (p)->lpVtbl->Stat(p,a,b) + +#endif + +HRESULT CALLBACK ILockBytes_RemoteReadAt_Proxy( + ILockBytes* This, + ULARGE_INTEGER ulOffset, + byte* pv, + ULONG cb, + ULONG* pcbRead); +void __RPC_STUB ILockBytes_RemoteReadAt_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ILockBytes_ReadAt_Proxy( + ILockBytes* This, + ULARGE_INTEGER ulOffset, + void* pv, + ULONG cb, + ULONG* pcbRead); +HRESULT __RPC_STUB ILockBytes_ReadAt_Stub( + ILockBytes* This, + ULARGE_INTEGER ulOffset, + byte* pv, + ULONG cb, + ULONG* pcbRead); +HRESULT CALLBACK ILockBytes_RemoteWriteAt_Proxy( + ILockBytes* This, + ULARGE_INTEGER ulOffset, + const byte* pv, + ULONG cb, + ULONG* pcbWritten); +void __RPC_STUB ILockBytes_RemoteWriteAt_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ILockBytes_WriteAt_Proxy( + ILockBytes* This, + ULARGE_INTEGER ulOffset, + const void* pv, + ULONG cb, + ULONG* pcbWritten); +HRESULT __RPC_STUB ILockBytes_WriteAt_Stub( + ILockBytes* This, + ULARGE_INTEGER ulOffset, + const byte* pv, + ULONG cb, + ULONG* pcbWritten); +HRESULT CALLBACK ILockBytes_Flush_Proxy( + ILockBytes* This); +void __RPC_STUB ILockBytes_Flush_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ILockBytes_SetSize_Proxy( + ILockBytes* This, + ULARGE_INTEGER cb); +void __RPC_STUB ILockBytes_SetSize_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ILockBytes_LockRegion_Proxy( + ILockBytes* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); +void __RPC_STUB ILockBytes_LockRegion_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ILockBytes_UnlockRegion_Proxy( + ILockBytes* This, + ULARGE_INTEGER libOffset, + ULARGE_INTEGER cb, + DWORD dwLockType); +void __RPC_STUB ILockBytes_UnlockRegion_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ILockBytes_Stat_Proxy( + ILockBytes* This, + STATSTG* pstatstg, + DWORD grfStatFlag); +void __RPC_STUB ILockBytes_Stat_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IFillLockBytes IFillLockBytes; +/***************************************************************************** + * IFillLockBytes interface + */ +DEFINE_GUID(IID_IFillLockBytes, 0x99caf010, 0x415e, 0x11cf, 0x88,0x14, 0x00,0xaa,0x00,0xb5,0x69,0xf5); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IFillLockBytes: IUnknown { + + virtual HRESULT CALLBACK FillAppend( + const void* pv, + ULONG cb, + ULONG* pcbWritten) = 0; + + virtual HRESULT CALLBACK FillAt( + ULARGE_INTEGER ulOffset, + const void* pv, + ULONG cb, + ULONG* pcbWritten) = 0; + + virtual HRESULT CALLBACK SetFillSize( + ULARGE_INTEGER ulSize) = 0; + + virtual HRESULT CALLBACK Terminate( + BOOL bCanceled) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IFillLockBytesVtbl IFillLockBytesVtbl; +struct IFillLockBytes { + const IFillLockBytesVtbl* lpVtbl; +}; +struct IFillLockBytesVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IFillLockBytes* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IFillLockBytes* This); + + ULONG (CALLBACK *Release)( + IFillLockBytes* This); + + /*** IFillLockBytes methods ***/ + HRESULT (CALLBACK *FillAppend)( + IFillLockBytes* This, + const void* pv, + ULONG cb, + ULONG* pcbWritten); + + HRESULT (CALLBACK *FillAt)( + IFillLockBytes* This, + ULARGE_INTEGER ulOffset, + const void* pv, + ULONG cb, + ULONG* pcbWritten); + + HRESULT (CALLBACK *SetFillSize)( + IFillLockBytes* This, + ULARGE_INTEGER ulSize); + + HRESULT (CALLBACK *Terminate)( + IFillLockBytes* This, + BOOL bCanceled); + +}; + +#define IFillLockBytes_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD3 (HRESULT,FillAppend,const void*,pv,ULONG,cb,ULONG*,pcbWritten) \ + ICOM_METHOD4 (HRESULT,FillAt,ULARGE_INTEGER,ulOffset,const void*,pv,ULONG,cb,ULONG*,pcbWritten) \ + ICOM_METHOD1 (HRESULT,SetFillSize,ULARGE_INTEGER,ulSize) \ + ICOM_METHOD1 (HRESULT,Terminate,BOOL,bCanceled) + +/*** IUnknown methods ***/ +#define IFillLockBytes_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IFillLockBytes_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IFillLockBytes_Release(p) (p)->lpVtbl->Release(p) +/*** IFillLockBytes methods ***/ +#define IFillLockBytes_FillAppend(p,a,b,c) (p)->lpVtbl->FillAppend(p,a,b,c) +#define IFillLockBytes_FillAt(p,a,b,c,d) (p)->lpVtbl->FillAt(p,a,b,c,d) +#define IFillLockBytes_SetFillSize(p,a) (p)->lpVtbl->SetFillSize(p,a) +#define IFillLockBytes_Terminate(p,a) (p)->lpVtbl->Terminate(p,a) + +#endif + +HRESULT CALLBACK IFillLockBytes_RemoteFillAppend_Proxy( + IFillLockBytes* This, + const byte* pv, + ULONG cb, + ULONG* pcbWritten); +void __RPC_STUB IFillLockBytes_RemoteFillAppend_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFillLockBytes_FillAppend_Proxy( + IFillLockBytes* This, + const void* pv, + ULONG cb, + ULONG* pcbWritten); +HRESULT __RPC_STUB IFillLockBytes_FillAppend_Stub( + IFillLockBytes* This, + const byte* pv, + ULONG cb, + ULONG* pcbWritten); +HRESULT CALLBACK IFillLockBytes_RemoteFillAt_Proxy( + IFillLockBytes* This, + ULARGE_INTEGER ulOffset, + const byte* pv, + ULONG cb, + ULONG* pcbWritten); +void __RPC_STUB IFillLockBytes_RemoteFillAt_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFillLockBytes_FillAt_Proxy( + IFillLockBytes* This, + ULARGE_INTEGER ulOffset, + const void* pv, + ULONG cb, + ULONG* pcbWritten); +HRESULT __RPC_STUB IFillLockBytes_FillAt_Stub( + IFillLockBytes* This, + ULARGE_INTEGER ulOffset, + const byte* pv, + ULONG cb, + ULONG* pcbWritten); +HRESULT CALLBACK IFillLockBytes_SetFillSize_Proxy( + IFillLockBytes* This, + ULARGE_INTEGER ulSize); +void __RPC_STUB IFillLockBytes_SetFillSize_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFillLockBytes_Terminate_Proxy( + IFillLockBytes* This, + BOOL bCanceled); +void __RPC_STUB IFillLockBytes_Terminate_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IProgressNotify IProgressNotify; +/***************************************************************************** + * IProgressNotify interface + */ +DEFINE_GUID(IID_IProgressNotify, 0xa9d758a0, 0x4617, 0x11cf, 0x95,0xfc, 0x00,0xaa,0x00,0x68,0x0d,0xb4); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IProgressNotify: IUnknown { + + virtual HRESULT CALLBACK OnProgress( + DWORD dwProgressCurrent, + DWORD dwProgressMaximum, + BOOL fAccurate, + BOOL fOwner) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IProgressNotifyVtbl IProgressNotifyVtbl; +struct IProgressNotify { + const IProgressNotifyVtbl* lpVtbl; +}; +struct IProgressNotifyVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IProgressNotify* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IProgressNotify* This); + + ULONG (CALLBACK *Release)( + IProgressNotify* This); + + /*** IProgressNotify methods ***/ + HRESULT (CALLBACK *OnProgress)( + IProgressNotify* This, + DWORD dwProgressCurrent, + DWORD dwProgressMaximum, + BOOL fAccurate, + BOOL fOwner); + +}; + +#define IProgressNotify_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD4 (HRESULT,OnProgress,DWORD,dwProgressCurrent,DWORD,dwProgressMaximum,BOOL,fAccurate,BOOL,fOwner) + +/*** IUnknown methods ***/ +#define IProgressNotify_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IProgressNotify_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IProgressNotify_Release(p) (p)->lpVtbl->Release(p) +/*** IProgressNotify methods ***/ +#define IProgressNotify_OnProgress(p,a,b,c,d) (p)->lpVtbl->OnProgress(p,a,b,c,d) + +#endif + +HRESULT CALLBACK IProgressNotify_OnProgress_Proxy( + IProgressNotify* This, + DWORD dwProgressCurrent, + DWORD dwProgressMaximum, + BOOL fAccurate, + BOOL fOwner); +void __RPC_STUB IProgressNotify_OnProgress_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct ILayoutStorage ILayoutStorage; +typedef struct tagStorageLayout { + DWORD LayoutType; + OLECHAR *pwcsElementName; + LARGE_INTEGER cOffset; + LARGE_INTEGER cBytes; +} StorageLayout; + +/***************************************************************************** + * ILayoutStorage interface + */ +DEFINE_GUID(IID_ILayoutStorage, 0x0e6d4d90, 0x6738, 0x11cf, 0x96,0x08, 0x00,0xaa,0x00,0x68,0x0d,0xb4); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ILayoutStorage: IUnknown { + + virtual HRESULT CALLBACK LayoutScript( + StorageLayout* pStorageLayout, + DWORD nEntries, + DWORD glfInterleavedFlag) = 0; + + virtual HRESULT CALLBACK BeginMonitor( + ) = 0; + + virtual HRESULT CALLBACK EndMonitor( + ) = 0; + + virtual HRESULT CALLBACK ReLayoutDocfile( + OLECHAR* pwcsNewDfName) = 0; + + virtual HRESULT CALLBACK ReLayoutDocfileOnILockBytes( + ILockBytes* pILockBytes) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct ILayoutStorageVtbl ILayoutStorageVtbl; +struct ILayoutStorage { + const ILayoutStorageVtbl* lpVtbl; +}; +struct ILayoutStorageVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + ILayoutStorage* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + ILayoutStorage* This); + + ULONG (CALLBACK *Release)( + ILayoutStorage* This); + + /*** ILayoutStorage methods ***/ + HRESULT (CALLBACK *LayoutScript)( + ILayoutStorage* This, + StorageLayout* pStorageLayout, + DWORD nEntries, + DWORD glfInterleavedFlag); + + HRESULT (CALLBACK *BeginMonitor)( + ILayoutStorage* This); + + HRESULT (CALLBACK *EndMonitor)( + ILayoutStorage* This); + + HRESULT (CALLBACK *ReLayoutDocfile)( + ILayoutStorage* This, + OLECHAR* pwcsNewDfName); + + HRESULT (CALLBACK *ReLayoutDocfileOnILockBytes)( + ILayoutStorage* This, + ILockBytes* pILockBytes); + +}; + +#define ILayoutStorage_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD3 (HRESULT,LayoutScript,StorageLayout*,pStorageLayout,DWORD,nEntries,DWORD,glfInterleavedFlag) \ + ICOM_METHOD (HRESULT,BeginMonitor) \ + ICOM_METHOD (HRESULT,EndMonitor) \ + ICOM_METHOD1 (HRESULT,ReLayoutDocfile,OLECHAR*,pwcsNewDfName) \ + ICOM_METHOD1 (HRESULT,ReLayoutDocfileOnILockBytes,ILockBytes*,pILockBytes) + +/*** IUnknown methods ***/ +#define ILayoutStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ILayoutStorage_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ILayoutStorage_Release(p) (p)->lpVtbl->Release(p) +/*** ILayoutStorage methods ***/ +#define ILayoutStorage_LayoutScript(p,a,b,c) (p)->lpVtbl->LayoutScript(p,a,b,c) +#define ILayoutStorage_BeginMonitor(p) (p)->lpVtbl->BeginMonitor(p) +#define ILayoutStorage_EndMonitor(p) (p)->lpVtbl->EndMonitor(p) +#define ILayoutStorage_ReLayoutDocfile(p,a) (p)->lpVtbl->ReLayoutDocfile(p,a) +#define ILayoutStorage_ReLayoutDocfileOnILockBytes(p,a) (p)->lpVtbl->ReLayoutDocfileOnILockBytes(p,a) + +#endif + +HRESULT CALLBACK ILayoutStorage_LayoutScript_Proxy( + ILayoutStorage* This, + StorageLayout* pStorageLayout, + DWORD nEntries, + DWORD glfInterleavedFlag); +void __RPC_STUB ILayoutStorage_LayoutScript_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ILayoutStorage_BeginMonitor_Proxy( + ILayoutStorage* This); +void __RPC_STUB ILayoutStorage_BeginMonitor_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ILayoutStorage_EndMonitor_Proxy( + ILayoutStorage* This); +void __RPC_STUB ILayoutStorage_EndMonitor_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ILayoutStorage_ReLayoutDocfile_Proxy( + ILayoutStorage* This, + OLECHAR* pwcsNewDfName); +void __RPC_STUB ILayoutStorage_ReLayoutDocfile_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ILayoutStorage_ReLayoutDocfileOnILockBytes_Proxy( + ILayoutStorage* This, + ILockBytes* pILockBytes); +void __RPC_STUB ILayoutStorage_ReLayoutDocfileOnILockBytes_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IEnumFORMATETC IEnumFORMATETC; +typedef IEnumFORMATETC *LPENUMFORMATETC; + +typedef struct tagDVTARGETDEVICE { + DWORD tdSize; + WORD tdDriverNameOffset; + WORD tdDeviceNameOffset; + WORD tdPortNameOffset; + WORD tdExtDevmodeOffset; + BYTE tdData[1]; +} DVTARGETDEVICE; + +typedef CLIPFORMAT *LPCLIPFORMAT; + +typedef struct tagFORMATETC { + CLIPFORMAT cfFormat; + DVTARGETDEVICE *ptd; + DWORD dwAspect; + LONG lindex; + DWORD tymed; +} FORMATETC, *LPFORMATETC; + +/***************************************************************************** + * IEnumFORMATETC interface + */ +DEFINE_GUID(IID_IEnumFORMATETC, 0x00000103, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IEnumFORMATETC: IUnknown { + + virtual HRESULT CALLBACK Next( + ULONG celt, + FORMATETC* rgelt, + ULONG* pceltFetched) = 0; + + virtual HRESULT CALLBACK Skip( + ULONG celt) = 0; + + virtual HRESULT CALLBACK Reset( + ) = 0; + + virtual HRESULT CALLBACK Clone( + IEnumFORMATETC** ppenum) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IEnumFORMATETCVtbl IEnumFORMATETCVtbl; +struct IEnumFORMATETC { + const IEnumFORMATETCVtbl* lpVtbl; +}; +struct IEnumFORMATETCVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IEnumFORMATETC* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IEnumFORMATETC* This); + + ULONG (CALLBACK *Release)( + IEnumFORMATETC* This); + + /*** IEnumFORMATETC methods ***/ + HRESULT (CALLBACK *Next)( + IEnumFORMATETC* This, + ULONG celt, + FORMATETC* rgelt, + ULONG* pceltFetched); + + HRESULT (CALLBACK *Skip)( + IEnumFORMATETC* This, + ULONG celt); + + HRESULT (CALLBACK *Reset)( + IEnumFORMATETC* This); + + HRESULT (CALLBACK *Clone)( + IEnumFORMATETC* This, + IEnumFORMATETC** ppenum); + +}; + +#define IEnumFORMATETC_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD3 (HRESULT,Next,ULONG,celt,FORMATETC*,rgelt,ULONG*,pceltFetched) \ + ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \ + ICOM_METHOD (HRESULT,Reset) \ + ICOM_METHOD1 (HRESULT,Clone,IEnumFORMATETC**,ppenum) + +/*** IUnknown methods ***/ +#define IEnumFORMATETC_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumFORMATETC_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumFORMATETC_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumFORMATETC methods ***/ +#define IEnumFORMATETC_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumFORMATETC_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumFORMATETC_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumFORMATETC_Clone(p,a) (p)->lpVtbl->Clone(p,a) + +#endif + +HRESULT CALLBACK IEnumFORMATETC_RemoteNext_Proxy( + IEnumFORMATETC* This, + ULONG celt, + FORMATETC* rgelt, + ULONG* pceltFetched); +void __RPC_STUB IEnumFORMATETC_RemoteNext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumFORMATETC_Next_Proxy( + IEnumFORMATETC* This, + ULONG celt, + FORMATETC* rgelt, + ULONG* pceltFetched); +HRESULT __RPC_STUB IEnumFORMATETC_Next_Stub( + IEnumFORMATETC* This, + ULONG celt, + FORMATETC* rgelt, + ULONG* pceltFetched); +HRESULT CALLBACK IEnumFORMATETC_Skip_Proxy( + IEnumFORMATETC* This, + ULONG celt); +void __RPC_STUB IEnumFORMATETC_Skip_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumFORMATETC_Reset_Proxy( + IEnumFORMATETC* This); +void __RPC_STUB IEnumFORMATETC_Reset_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumFORMATETC_Clone_Proxy( + IEnumFORMATETC* This, + IEnumFORMATETC** ppenum); +void __RPC_STUB IEnumFORMATETC_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IEnumSTATDATA IEnumSTATDATA; +typedef IEnumSTATDATA *LPENUMSTATDATA; + +typedef enum tagADVF { + ADVF_NODATA = 1, + ADVF_PRIMEFIRST = 2, + ADVF_ONLYONCE = 4, + ADVF_DATAONSTOP = 64, + ADVFCACHE_NOHANDLER = 8, + ADVFCACHE_FORCEBUILTIN = 16, + ADVFCACHE_ONSAVE = 32 +} ADVF; + +typedef struct tagSTATDATA { + FORMATETC formatetc; + DWORD advf; + IAdviseSink *pAdvSink; + DWORD dwConnection; +} STATDATA, *LPSTATDATA; + +/***************************************************************************** + * IEnumSTATDATA interface + */ +DEFINE_GUID(IID_IEnumSTATDATA, 0x00000105, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IEnumSTATDATA: IUnknown { + + virtual HRESULT CALLBACK Next( + ULONG celt, + STATDATA* rgelt, + ULONG* pceltFetched) = 0; + + virtual HRESULT CALLBACK Skip( + ULONG celt) = 0; + + virtual HRESULT CALLBACK Reset( + ) = 0; + + virtual HRESULT CALLBACK Clone( + IEnumSTATDATA** ppenum) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IEnumSTATDATAVtbl IEnumSTATDATAVtbl; +struct IEnumSTATDATA { + const IEnumSTATDATAVtbl* lpVtbl; +}; +struct IEnumSTATDATAVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IEnumSTATDATA* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IEnumSTATDATA* This); + + ULONG (CALLBACK *Release)( + IEnumSTATDATA* This); + + /*** IEnumSTATDATA methods ***/ + HRESULT (CALLBACK *Next)( + IEnumSTATDATA* This, + ULONG celt, + STATDATA* rgelt, + ULONG* pceltFetched); + + HRESULT (CALLBACK *Skip)( + IEnumSTATDATA* This, + ULONG celt); + + HRESULT (CALLBACK *Reset)( + IEnumSTATDATA* This); + + HRESULT (CALLBACK *Clone)( + IEnumSTATDATA* This, + IEnumSTATDATA** ppenum); + +}; + +#define IEnumSTATDATA_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD3 (HRESULT,Next,ULONG,celt,STATDATA*,rgelt,ULONG*,pceltFetched) \ + ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \ + ICOM_METHOD (HRESULT,Reset) \ + ICOM_METHOD1 (HRESULT,Clone,IEnumSTATDATA**,ppenum) + +/*** IUnknown methods ***/ +#define IEnumSTATDATA_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumSTATDATA_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumSTATDATA_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumSTATDATA methods ***/ +#define IEnumSTATDATA_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumSTATDATA_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumSTATDATA_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumSTATDATA_Clone(p,a) (p)->lpVtbl->Clone(p,a) + +#endif + +HRESULT CALLBACK IEnumSTATDATA_RemoteNext_Proxy( + IEnumSTATDATA* This, + ULONG celt, + STATDATA* rgelt, + ULONG* pceltFetched); +void __RPC_STUB IEnumSTATDATA_RemoteNext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumSTATDATA_Next_Proxy( + IEnumSTATDATA* This, + ULONG celt, + STATDATA* rgelt, + ULONG* pceltFetched); +HRESULT __RPC_STUB IEnumSTATDATA_Next_Stub( + IEnumSTATDATA* This, + ULONG celt, + STATDATA* rgelt, + ULONG* pceltFetched); +HRESULT CALLBACK IEnumSTATDATA_Skip_Proxy( + IEnumSTATDATA* This, + ULONG celt); +void __RPC_STUB IEnumSTATDATA_Skip_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumSTATDATA_Reset_Proxy( + IEnumSTATDATA* This); +void __RPC_STUB IEnumSTATDATA_Reset_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumSTATDATA_Clone_Proxy( + IEnumSTATDATA* This, + IEnumSTATDATA** ppenum); +void __RPC_STUB IEnumSTATDATA_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef IAdviseSink *LPADVISESINK; + +typedef enum tagTYMED { + TYMED_HGLOBAL = 1, + TYMED_FILE = 2, + TYMED_ISTREAM = 4, + TYMED_ISTORAGE = 8, + TYMED_GDI = 16, + TYMED_MFPICT = 32, + TYMED_ENHMF = 64, + TYMED_NULL = 0 +} TYMED; + +typedef struct tagRemSTGMEDIUM { + DWORD tymed; + DWORD dwHandleType; + unsigned long pData; + unsigned long pUnkForRelease; + unsigned long cbData; + byte data[1]; +} RemSTGMEDIUM; + +typedef struct tagSTGMEDIUM { + DWORD tymed; + union { + HBITMAP hBitmap; + HMETAFILEPICT hMetaFilePict; + HENHMETAFILE hEnhMetaFile; + HGLOBAL hGlobal; + LPOLESTR lpszFileName; + IStream *pstm; + IStorage *pstg; + } DUMMYUNIONNAME; + IUnknown *pUnkForRelease; +} uSTGMEDIUM; + +typedef struct _GDI_OBJECT { + DWORD ObjectType; + union { + wireHBITMAP hBitmap; + wireHPALETTE hPalette; + wireHGLOBAL hGeneric; + } u; +} GDI_OBJECT; + +typedef struct _userSTGMEDIUM { + struct _STGMEDIUM_UNION { + DWORD tymed; + union { + wireHMETAFILEPICT hMetaFilePict; + wireHENHMETAFILE hHEnhMetaFile; + GDI_OBJECT *hGdiHandle; + wireHGLOBAL hGlobal; + LPOLESTR lpszFileName; + BYTE_BLOB *pstm; + BYTE_BLOB *pstg; + } u; + } DUMMYSTRUCTNAME; + IUnknown *pUnkForRelease; +} userSTGMEDIUM; + +typedef userSTGMEDIUM *wireSTGMEDIUM; + +typedef uSTGMEDIUM STGMEDIUM; + +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; + +/***************************************************************************** + * IAdviseSink interface + */ +DEFINE_GUID(IID_IAdviseSink, 0x0000010f, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IAdviseSink: IUnknown { + + virtual void CALLBACK OnDataChange( + FORMATETC* pFormatetc, + STGMEDIUM* pStgmed) = 0; + + virtual void CALLBACK OnViewChange( + DWORD dwAspect, + LONG lindex) = 0; + + virtual void CALLBACK OnRename( + IMoniker* pmk) = 0; + + virtual void CALLBACK OnSave( + ) = 0; + + virtual void CALLBACK OnClose( + ) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IAdviseSinkVtbl IAdviseSinkVtbl; +struct IAdviseSink { + const IAdviseSinkVtbl* lpVtbl; +}; +struct IAdviseSinkVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IAdviseSink* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IAdviseSink* This); + + ULONG (CALLBACK *Release)( + IAdviseSink* This); + + /*** IAdviseSink methods ***/ + void (CALLBACK *OnDataChange)( + IAdviseSink* This, + FORMATETC* pFormatetc, + STGMEDIUM* pStgmed); + + void (CALLBACK *OnViewChange)( + IAdviseSink* This, + DWORD dwAspect, + LONG lindex); + + void (CALLBACK *OnRename)( + IAdviseSink* This, + IMoniker* pmk); + + void (CALLBACK *OnSave)( + IAdviseSink* This); + + void (CALLBACK *OnClose)( + IAdviseSink* This); + +}; + +#define IAdviseSink_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_VMETHOD2(OnDataChange,FORMATETC*,pFormatetc,STGMEDIUM*,pStgmed) \ + ICOM_VMETHOD2(OnViewChange,DWORD,dwAspect,LONG,lindex) \ + ICOM_VMETHOD1(OnRename,IMoniker*,pmk) \ + ICOM_VMETHOD (OnSave) \ + ICOM_VMETHOD (OnClose) + +/*** IUnknown methods ***/ +#define IAdviseSink_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IAdviseSink_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IAdviseSink_Release(p) (p)->lpVtbl->Release(p) +/*** IAdviseSink methods ***/ +#define IAdviseSink_OnDataChange(p,a,b) (p)->lpVtbl->OnDataChange(p,a,b) +#define IAdviseSink_OnViewChange(p,a,b) (p)->lpVtbl->OnViewChange(p,a,b) +#define IAdviseSink_OnRename(p,a) (p)->lpVtbl->OnRename(p,a) +#define IAdviseSink_OnSave(p) (p)->lpVtbl->OnSave(p) +#define IAdviseSink_OnClose(p) (p)->lpVtbl->OnClose(p) + +#endif + +HRESULT CALLBACK IAdviseSink_RemoteOnDataChange_Proxy( + IAdviseSink* This, + IAsyncManager** ppIAM, + FORMATETC* pFormatetc, + ASYNC_STGMEDIUM* pStgmed); +void __RPC_STUB IAdviseSink_RemoteOnDataChange_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IAdviseSink_OnDataChange_Proxy( + IAdviseSink* This, + FORMATETC* pFormatetc, + STGMEDIUM* pStgmed); +HRESULT __RPC_STUB IAdviseSink_OnDataChange_Stub( + IAdviseSink* This, + IAsyncManager** ppIAM, + FORMATETC* pFormatetc, + ASYNC_STGMEDIUM* pStgmed); +HRESULT CALLBACK IAdviseSink_RemoteOnViewChange_Proxy( + IAdviseSink* This, + IAsyncManager** ppIAM, + DWORD dwAspect, + LONG lindex); +void __RPC_STUB IAdviseSink_RemoteOnViewChange_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IAdviseSink_OnViewChange_Proxy( + IAdviseSink* This, + DWORD dwAspect, + LONG lindex); +HRESULT __RPC_STUB IAdviseSink_OnViewChange_Stub( + IAdviseSink* This, + IAsyncManager** ppIAM, + DWORD dwAspect, + LONG lindex); +HRESULT CALLBACK IAdviseSink_RemoteOnRename_Proxy( + IAdviseSink* This, + IAsyncManager** ppIAM, + IMoniker* pmk); +void __RPC_STUB IAdviseSink_RemoteOnRename_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IAdviseSink_OnRename_Proxy( + IAdviseSink* This, + IMoniker* pmk); +HRESULT __RPC_STUB IAdviseSink_OnRename_Stub( + IAdviseSink* This, + IAsyncManager** ppIAM, + IMoniker* pmk); +HRESULT CALLBACK IAdviseSink_RemoteOnSave_Proxy( + IAdviseSink* This, + IAsyncManager** ppIAM); +void __RPC_STUB IAdviseSink_RemoteOnSave_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IAdviseSink_OnSave_Proxy( + IAdviseSink* This); +HRESULT __RPC_STUB IAdviseSink_OnSave_Stub( + IAdviseSink* This, + IAsyncManager** ppIAM); +HRESULT CALLBACK IAdviseSink_RemoteOnClose_Proxy( + IAdviseSink* This); +void __RPC_STUB IAdviseSink_RemoteOnClose_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IAdviseSink_OnClose_Proxy( + IAdviseSink* This); +HRESULT __RPC_STUB IAdviseSink_OnClose_Stub( + IAdviseSink* This); + +typedef struct IAdviseSink2 IAdviseSink2; +typedef IAdviseSink2 *LPADVISESINK2; + +/***************************************************************************** + * IAdviseSink2 interface + */ +DEFINE_GUID(IID_IAdviseSink2, 0x00000125, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IAdviseSink2: IAdviseSink { + + virtual void CALLBACK OnLinkSrcChange( + IMoniker* pmk) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IAdviseSink2Vtbl IAdviseSink2Vtbl; +struct IAdviseSink2 { + const IAdviseSink2Vtbl* lpVtbl; +}; +struct IAdviseSink2Vtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IAdviseSink2* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IAdviseSink2* This); + + ULONG (CALLBACK *Release)( + IAdviseSink2* This); + + /*** IAdviseSink methods ***/ + void (CALLBACK *OnDataChange)( + IAdviseSink2* This, + FORMATETC* pFormatetc, + STGMEDIUM* pStgmed); + + void (CALLBACK *OnViewChange)( + IAdviseSink2* This, + DWORD dwAspect, + LONG lindex); + + void (CALLBACK *OnRename)( + IAdviseSink2* This, + IMoniker* pmk); + + void (CALLBACK *OnSave)( + IAdviseSink2* This); + + void (CALLBACK *OnClose)( + IAdviseSink2* This); + + /*** IAdviseSink2 methods ***/ + void (CALLBACK *OnLinkSrcChange)( + IAdviseSink2* This, + IMoniker* pmk); + +}; + +#define IAdviseSink2_IMETHODS \ + IAdviseSink_IMETHODS \ + ICOM_VMETHOD1(OnLinkSrcChange,IMoniker*,pmk) + +/*** IUnknown methods ***/ +#define IAdviseSink2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IAdviseSink2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IAdviseSink2_Release(p) (p)->lpVtbl->Release(p) +/*** IAdviseSink methods ***/ +#define IAdviseSink2_OnDataChange(p,a,b) (p)->lpVtbl->OnDataChange(p,a,b) +#define IAdviseSink2_OnViewChange(p,a,b) (p)->lpVtbl->OnViewChange(p,a,b) +#define IAdviseSink2_OnRename(p,a) (p)->lpVtbl->OnRename(p,a) +#define IAdviseSink2_OnSave(p) (p)->lpVtbl->OnSave(p) +#define IAdviseSink2_OnClose(p) (p)->lpVtbl->OnClose(p) +/*** IAdviseSink2 methods ***/ +#define IAdviseSink2_OnLinkSrcChange(p,a) (p)->lpVtbl->OnLinkSrcChange(p,a) + +#endif + +HRESULT CALLBACK IAdviseSink2_RemoteOnLinkSrcChange_Proxy( + IAdviseSink2* This, + IAsyncManager** ppIAM, + IMoniker* pmk); +void __RPC_STUB IAdviseSink2_RemoteOnLinkSrcChange_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IAdviseSink2_OnLinkSrcChange_Proxy( + IAdviseSink2* This, + IMoniker* pmk); +HRESULT __RPC_STUB IAdviseSink2_OnLinkSrcChange_Stub( + IAdviseSink2* This, + IAsyncManager** ppIAM, + IMoniker* pmk); + +typedef struct IDataObject IDataObject; +typedef IDataObject *LPDATAOBJECT; + +typedef enum tagDATADIR { + DATADIR_GET = 1, + DATADIR_SET = 2 +} DATADIR; + +/***************************************************************************** + * IDataObject interface + */ +DEFINE_GUID(IID_IDataObject, 0x0000010e, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IDataObject: IUnknown { + + virtual HRESULT CALLBACK GetData( + FORMATETC* pformatetcIn, + STGMEDIUM* pmedium) = 0; + + virtual HRESULT CALLBACK GetDataHere( + FORMATETC* pformatetc, + STGMEDIUM* pmedium) = 0; + + virtual HRESULT CALLBACK QueryGetData( + FORMATETC* pformatetc) = 0; + + virtual HRESULT CALLBACK GetCanonicalFormatEtc( + FORMATETC* pformatectIn, + FORMATETC* pformatetcOut) = 0; + + virtual HRESULT CALLBACK SetData( + FORMATETC* pformatetc, + STGMEDIUM* pmedium, + BOOL fRelease) = 0; + + virtual HRESULT CALLBACK EnumFormatEtc( + DWORD dwDirection, + IEnumFORMATETC** ppenumFormatEtc) = 0; + + virtual HRESULT CALLBACK DAdvise( + FORMATETC* pformatetc, + DWORD advf, + IAdviseSink* pAdvSink, + DWORD* pdwConnection) = 0; + + virtual HRESULT CALLBACK DUnadvise( + DWORD dwConnection) = 0; + + virtual HRESULT CALLBACK EnumDAdvise( + IEnumSTATDATA** ppenumAdvise) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IDataObjectVtbl IDataObjectVtbl; +struct IDataObject { + const IDataObjectVtbl* lpVtbl; +}; +struct IDataObjectVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IDataObject* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IDataObject* This); + + ULONG (CALLBACK *Release)( + IDataObject* This); + + /*** IDataObject methods ***/ + HRESULT (CALLBACK *GetData)( + IDataObject* This, + FORMATETC* pformatetcIn, + STGMEDIUM* pmedium); + + HRESULT (CALLBACK *GetDataHere)( + IDataObject* This, + FORMATETC* pformatetc, + STGMEDIUM* pmedium); + + HRESULT (CALLBACK *QueryGetData)( + IDataObject* This, + FORMATETC* pformatetc); + + HRESULT (CALLBACK *GetCanonicalFormatEtc)( + IDataObject* This, + FORMATETC* pformatectIn, + FORMATETC* pformatetcOut); + + HRESULT (CALLBACK *SetData)( + IDataObject* This, + FORMATETC* pformatetc, + STGMEDIUM* pmedium, + BOOL fRelease); + + HRESULT (CALLBACK *EnumFormatEtc)( + IDataObject* This, + DWORD dwDirection, + IEnumFORMATETC** ppenumFormatEtc); + + HRESULT (CALLBACK *DAdvise)( + IDataObject* This, + FORMATETC* pformatetc, + DWORD advf, + IAdviseSink* pAdvSink, + DWORD* pdwConnection); + + HRESULT (CALLBACK *DUnadvise)( + IDataObject* This, + DWORD dwConnection); + + HRESULT (CALLBACK *EnumDAdvise)( + IDataObject* This, + IEnumSTATDATA** ppenumAdvise); + +}; + +#define IDataObject_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD2 (HRESULT,GetData,FORMATETC*,pformatetcIn,STGMEDIUM*,pmedium) \ + ICOM_METHOD2 (HRESULT,GetDataHere,FORMATETC*,pformatetc,STGMEDIUM*,pmedium) \ + ICOM_METHOD1 (HRESULT,QueryGetData,FORMATETC*,pformatetc) \ + ICOM_METHOD2 (HRESULT,GetCanonicalFormatEtc,FORMATETC*,pformatectIn,FORMATETC*,pformatetcOut) \ + ICOM_METHOD3 (HRESULT,SetData,FORMATETC*,pformatetc,STGMEDIUM*,pmedium,BOOL,fRelease) \ + ICOM_METHOD2 (HRESULT,EnumFormatEtc,DWORD,dwDirection,IEnumFORMATETC**,ppenumFormatEtc) \ + ICOM_METHOD4 (HRESULT,DAdvise,FORMATETC*,pformatetc,DWORD,advf,IAdviseSink*,pAdvSink,DWORD*,pdwConnection) \ + ICOM_METHOD1 (HRESULT,DUnadvise,DWORD,dwConnection) \ + ICOM_METHOD1 (HRESULT,EnumDAdvise,IEnumSTATDATA**,ppenumAdvise) + +/*** IUnknown methods ***/ +#define IDataObject_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDataObject_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDataObject_Release(p) (p)->lpVtbl->Release(p) +/*** IDataObject methods ***/ +#define IDataObject_GetData(p,a,b) (p)->lpVtbl->GetData(p,a,b) +#define IDataObject_GetDataHere(p,a,b) (p)->lpVtbl->GetDataHere(p,a,b) +#define IDataObject_QueryGetData(p,a) (p)->lpVtbl->QueryGetData(p,a) +#define IDataObject_GetCanonicalFormatEtc(p,a,b) (p)->lpVtbl->GetCanonicalFormatEtc(p,a,b) +#define IDataObject_SetData(p,a,b,c) (p)->lpVtbl->SetData(p,a,b,c) +#define IDataObject_EnumFormatEtc(p,a,b) (p)->lpVtbl->EnumFormatEtc(p,a,b) +#define IDataObject_DAdvise(p,a,b,c,d) (p)->lpVtbl->DAdvise(p,a,b,c,d) +#define IDataObject_DUnadvise(p,a) (p)->lpVtbl->DUnadvise(p,a) +#define IDataObject_EnumDAdvise(p,a) (p)->lpVtbl->EnumDAdvise(p,a) + +#endif + +HRESULT CALLBACK IDataObject_RemoteGetData_Proxy( + IDataObject* This, + FORMATETC* pformatetcIn, + STGMEDIUM* pRemoteMedium); +void __RPC_STUB IDataObject_RemoteGetData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IDataObject_GetData_Proxy( + IDataObject* This, + FORMATETC* pformatetcIn, + STGMEDIUM* pmedium); +HRESULT __RPC_STUB IDataObject_GetData_Stub( + IDataObject* This, + FORMATETC* pformatetcIn, + STGMEDIUM* pRemoteMedium); +HRESULT CALLBACK IDataObject_RemoteGetDataHere_Proxy( + IDataObject* This, + FORMATETC* pformatetc, + STGMEDIUM* pRemoteMedium); +void __RPC_STUB IDataObject_RemoteGetDataHere_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IDataObject_GetDataHere_Proxy( + IDataObject* This, + FORMATETC* pformatetc, + STGMEDIUM* pmedium); +HRESULT __RPC_STUB IDataObject_GetDataHere_Stub( + IDataObject* This, + FORMATETC* pformatetc, + STGMEDIUM* pRemoteMedium); +HRESULT CALLBACK IDataObject_QueryGetData_Proxy( + IDataObject* This, + FORMATETC* pformatetc); +void __RPC_STUB IDataObject_QueryGetData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IDataObject_GetCanonicalFormatEtc_Proxy( + IDataObject* This, + FORMATETC* pformatectIn, + FORMATETC* pformatetcOut); +void __RPC_STUB IDataObject_GetCanonicalFormatEtc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IDataObject_RemoteSetData_Proxy( + IDataObject* This, + FORMATETC* pformatetc, + FLAG_STGMEDIUM* pmedium, + BOOL fRelease); +void __RPC_STUB IDataObject_RemoteSetData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IDataObject_SetData_Proxy( + IDataObject* This, + FORMATETC* pformatetc, + STGMEDIUM* pmedium, + BOOL fRelease); +HRESULT __RPC_STUB IDataObject_SetData_Stub( + IDataObject* This, + FORMATETC* pformatetc, + FLAG_STGMEDIUM* pmedium, + BOOL fRelease); +HRESULT CALLBACK IDataObject_EnumFormatEtc_Proxy( + IDataObject* This, + DWORD dwDirection, + IEnumFORMATETC** ppenumFormatEtc); +void __RPC_STUB IDataObject_EnumFormatEtc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IDataObject_DAdvise_Proxy( + IDataObject* This, + FORMATETC* pformatetc, + DWORD advf, + IAdviseSink* pAdvSink, + DWORD* pdwConnection); +void __RPC_STUB IDataObject_DAdvise_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IDataObject_DUnadvise_Proxy( + IDataObject* This, + DWORD dwConnection); +void __RPC_STUB IDataObject_DUnadvise_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IDataObject_EnumDAdvise_Proxy( + IDataObject* This, + IEnumSTATDATA** ppenumAdvise); +void __RPC_STUB IDataObject_EnumDAdvise_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IDataAdviseHolder IDataAdviseHolder; +typedef IDataAdviseHolder *LPDATAADVISEHOLDER; + +/***************************************************************************** + * IDataAdviseHolder interface + */ +DEFINE_GUID(IID_IDataAdviseHolder, 0x00000110, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IDataAdviseHolder: IUnknown { + + virtual HRESULT CALLBACK Advise( + IDataObject* pDataObject, + FORMATETC* pFetc, + DWORD advf, + IAdviseSink* pAdvise, + DWORD* pdwConnection) = 0; + + virtual HRESULT CALLBACK Unadvise( + DWORD dwConnection) = 0; + + virtual HRESULT CALLBACK EnumAdvise( + IEnumSTATDATA** ppenumAdvise) = 0; + + virtual HRESULT CALLBACK SendOnDataChange( + IDataObject* pDataObject, + DWORD dwReserved, + DWORD advf) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IDataAdviseHolderVtbl IDataAdviseHolderVtbl; +struct IDataAdviseHolder { + const IDataAdviseHolderVtbl* lpVtbl; +}; +struct IDataAdviseHolderVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IDataAdviseHolder* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IDataAdviseHolder* This); + + ULONG (CALLBACK *Release)( + IDataAdviseHolder* This); + + /*** IDataAdviseHolder methods ***/ + HRESULT (CALLBACK *Advise)( + IDataAdviseHolder* This, + IDataObject* pDataObject, + FORMATETC* pFetc, + DWORD advf, + IAdviseSink* pAdvise, + DWORD* pdwConnection); + + HRESULT (CALLBACK *Unadvise)( + IDataAdviseHolder* This, + DWORD dwConnection); + + HRESULT (CALLBACK *EnumAdvise)( + IDataAdviseHolder* This, + IEnumSTATDATA** ppenumAdvise); + + HRESULT (CALLBACK *SendOnDataChange)( + IDataAdviseHolder* This, + IDataObject* pDataObject, + DWORD dwReserved, + DWORD advf); + +}; + +#define IDataAdviseHolder_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD5 (HRESULT,Advise,IDataObject*,pDataObject,FORMATETC*,pFetc,DWORD,advf,IAdviseSink*,pAdvise,DWORD*,pdwConnection) \ + ICOM_METHOD1 (HRESULT,Unadvise,DWORD,dwConnection) \ + ICOM_METHOD1 (HRESULT,EnumAdvise,IEnumSTATDATA**,ppenumAdvise) \ + ICOM_METHOD3 (HRESULT,SendOnDataChange,IDataObject*,pDataObject,DWORD,dwReserved,DWORD,advf) + +/*** IUnknown methods ***/ +#define IDataAdviseHolder_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDataAdviseHolder_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDataAdviseHolder_Release(p) (p)->lpVtbl->Release(p) +/*** IDataAdviseHolder methods ***/ +#define IDataAdviseHolder_Advise(p,a,b,c,d,e) (p)->lpVtbl->Advise(p,a,b,c,d,e) +#define IDataAdviseHolder_Unadvise(p,a) (p)->lpVtbl->Unadvise(p,a) +#define IDataAdviseHolder_EnumAdvise(p,a) (p)->lpVtbl->EnumAdvise(p,a) +#define IDataAdviseHolder_SendOnDataChange(p,a,b,c) (p)->lpVtbl->SendOnDataChange(p,a,b,c) + +#endif + +HRESULT CALLBACK IDataAdviseHolder_Advise_Proxy( + IDataAdviseHolder* This, + IDataObject* pDataObject, + FORMATETC* pFetc, + DWORD advf, + IAdviseSink* pAdvise, + DWORD* pdwConnection); +void __RPC_STUB IDataAdviseHolder_Advise_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IDataAdviseHolder_Unadvise_Proxy( + IDataAdviseHolder* This, + DWORD dwConnection); +void __RPC_STUB IDataAdviseHolder_Unadvise_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IDataAdviseHolder_EnumAdvise_Proxy( + IDataAdviseHolder* This, + IEnumSTATDATA** ppenumAdvise); +void __RPC_STUB IDataAdviseHolder_EnumAdvise_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IDataAdviseHolder_SendOnDataChange_Proxy( + IDataAdviseHolder* This, + IDataObject* pDataObject, + DWORD dwReserved, + DWORD advf); +void __RPC_STUB IDataAdviseHolder_SendOnDataChange_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IMessageFilter IMessageFilter; +typedef IMessageFilter *LPMESSAGEFILTER; + +typedef enum tagCALLTYPE { + CALLTYPE_TOPLEVEL = 1, + CALLTYPE_NESTED = 2, + CALLTYPE_ASYNC = 3, + CALLTYPE_TOPLEVEL_CALLPENDING = 4, + CALLTYPE_ASYNC_CALLPENDING = 5 +} CALLTYPE; + +typedef enum tagSERVERCALL { + SERVERCALL_ISHANDLED = 0, + SERVERCALL_REJECTED = 1, + SERVERCALL_RETRYLATER = 2 +} SERVERCALL; + +typedef enum tagPENDINGTYPE { + PENDINGTYPE_TOPLEVEL = 1, + PENDINGTYPE_NESTED = 2 +} PENDINGTYPE; + +typedef enum tagPENDINGMSG { + PENDINGMSG_CANCELCALL = 0, + PENDINGMSG_WAITNOPROCESS = 1, + PENDINGMSG_WAITDEFPROCESS = 2 +} PENDINGMSG; + +typedef struct tagINTERFACEINFO { + IUnknown *pUnk; + IID iid; + WORD wMethod; +} INTERFACEINFO, *LPINTERFACEINFO; + +/***************************************************************************** + * IMessageFilter interface + */ +DEFINE_GUID(IID_IMessageFilter, 0x00000016, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IMessageFilter: IUnknown { + + virtual DWORD CALLBACK HandleInComingCall( + DWORD dwCallType, + HTASK htaskCaller, + DWORD dwTickCount, + LPINTERFACEINFO lpInterfaceInfo) = 0; + + virtual DWORD CALLBACK RetryRejectedCall( + HTASK htaskCallee, + DWORD dwTickCount, + DWORD dwRejectType) = 0; + + virtual DWORD CALLBACK MessagePending( + HTASK htaskCallee, + DWORD dwTickCount, + DWORD dwPendingType) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IMessageFilterVtbl IMessageFilterVtbl; +struct IMessageFilter { + const IMessageFilterVtbl* lpVtbl; +}; +struct IMessageFilterVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IMessageFilter* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IMessageFilter* This); + + ULONG (CALLBACK *Release)( + IMessageFilter* This); + + /*** IMessageFilter methods ***/ + DWORD (CALLBACK *HandleInComingCall)( + IMessageFilter* This, + DWORD dwCallType, + HTASK htaskCaller, + DWORD dwTickCount, + LPINTERFACEINFO lpInterfaceInfo); + + DWORD (CALLBACK *RetryRejectedCall)( + IMessageFilter* This, + HTASK htaskCallee, + DWORD dwTickCount, + DWORD dwRejectType); + + DWORD (CALLBACK *MessagePending)( + IMessageFilter* This, + HTASK htaskCallee, + DWORD dwTickCount, + DWORD dwPendingType); + +}; + +#define IMessageFilter_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD4 (DWORD,HandleInComingCall,DWORD,dwCallType,HTASK,htaskCaller,DWORD,dwTickCount,LPINTERFACEINFO,lpInterfaceInfo) \ + ICOM_METHOD3 (DWORD,RetryRejectedCall,HTASK,htaskCallee,DWORD,dwTickCount,DWORD,dwRejectType) \ + ICOM_METHOD3 (DWORD,MessagePending,HTASK,htaskCallee,DWORD,dwTickCount,DWORD,dwPendingType) + +/*** IUnknown methods ***/ +#define IMessageFilter_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMessageFilter_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMessageFilter_Release(p) (p)->lpVtbl->Release(p) +/*** IMessageFilter methods ***/ +#define IMessageFilter_HandleInComingCall(p,a,b,c,d) (p)->lpVtbl->HandleInComingCall(p,a,b,c,d) +#define IMessageFilter_RetryRejectedCall(p,a,b,c) (p)->lpVtbl->RetryRejectedCall(p,a,b,c) +#define IMessageFilter_MessagePending(p,a,b,c) (p)->lpVtbl->MessagePending(p,a,b,c) + +#endif + +DWORD CALLBACK IMessageFilter_HandleInComingCall_Proxy( + IMessageFilter* This, + DWORD dwCallType, + HTASK htaskCaller, + DWORD dwTickCount, + LPINTERFACEINFO lpInterfaceInfo); +void __RPC_STUB IMessageFilter_HandleInComingCall_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +DWORD CALLBACK IMessageFilter_RetryRejectedCall_Proxy( + IMessageFilter* This, + HTASK htaskCallee, + DWORD dwTickCount, + DWORD dwRejectType); +void __RPC_STUB IMessageFilter_RetryRejectedCall_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +DWORD CALLBACK IMessageFilter_MessagePending_Proxy( + IMessageFilter* This, + HTASK htaskCallee, + DWORD dwTickCount, + DWORD dwPendingType); +void __RPC_STUB IMessageFilter_MessagePending_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IRpcChannelBuffer IRpcChannelBuffer; +typedef IRpcChannelBuffer *LPRPCCHANNELBUFFER; + +typedef unsigned long RPCOLEDATAREP; + +typedef struct tagRPCOLEMESSAGE { + void *reserved1; + RPCOLEDATAREP dataRepresentation; + void *Buffer; + ULONG cbBuffer; + ULONG iMethod; + void *reserved2[5]; + ULONG rpcFlags; +} RPCOLEMESSAGE; + +typedef RPCOLEMESSAGE *PRPCOLEMESSAGE; + +/***************************************************************************** + * IRpcChannelBuffer interface + */ +DEFINE_GUID(IID_IRpcChannelBuffer, 0xd5f56b60, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IRpcChannelBuffer: IUnknown { + + virtual HRESULT CALLBACK GetBuffer( + RPCOLEMESSAGE* pMessage, + REFIID riid) = 0; + + virtual HRESULT CALLBACK SendReceive( + RPCOLEMESSAGE* pMessage, + ULONG* pStatus) = 0; + + virtual HRESULT CALLBACK FreeBuffer( + RPCOLEMESSAGE* pMessage) = 0; + + virtual HRESULT CALLBACK GetDestCtx( + DWORD* pdwDestContext, + void** ppvDestContext) = 0; + + virtual HRESULT CALLBACK IsConnected( + ) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IRpcChannelBufferVtbl IRpcChannelBufferVtbl; +struct IRpcChannelBuffer { + const IRpcChannelBufferVtbl* lpVtbl; +}; +struct IRpcChannelBufferVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IRpcChannelBuffer* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IRpcChannelBuffer* This); + + ULONG (CALLBACK *Release)( + IRpcChannelBuffer* This); + + /*** IRpcChannelBuffer methods ***/ + HRESULT (CALLBACK *GetBuffer)( + IRpcChannelBuffer* This, + RPCOLEMESSAGE* pMessage, + REFIID riid); + + HRESULT (CALLBACK *SendReceive)( + IRpcChannelBuffer* This, + RPCOLEMESSAGE* pMessage, + ULONG* pStatus); + + HRESULT (CALLBACK *FreeBuffer)( + IRpcChannelBuffer* This, + RPCOLEMESSAGE* pMessage); + + HRESULT (CALLBACK *GetDestCtx)( + IRpcChannelBuffer* This, + DWORD* pdwDestContext, + void** ppvDestContext); + + HRESULT (CALLBACK *IsConnected)( + IRpcChannelBuffer* This); + +}; + +#define IRpcChannelBuffer_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD2 (HRESULT,GetBuffer,RPCOLEMESSAGE*,pMessage,REFIID,riid) \ + ICOM_METHOD2 (HRESULT,SendReceive,RPCOLEMESSAGE*,pMessage,ULONG*,pStatus) \ + ICOM_METHOD1 (HRESULT,FreeBuffer,RPCOLEMESSAGE*,pMessage) \ + ICOM_METHOD2 (HRESULT,GetDestCtx,DWORD*,pdwDestContext,void**,ppvDestContext) \ + ICOM_METHOD (HRESULT,IsConnected) + +/*** IUnknown methods ***/ +#define IRpcChannelBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IRpcChannelBuffer_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IRpcChannelBuffer_Release(p) (p)->lpVtbl->Release(p) +/*** IRpcChannelBuffer methods ***/ +#define IRpcChannelBuffer_GetBuffer(p,a,b) (p)->lpVtbl->GetBuffer(p,a,b) +#define IRpcChannelBuffer_SendReceive(p,a,b) (p)->lpVtbl->SendReceive(p,a,b) +#define IRpcChannelBuffer_FreeBuffer(p,a) (p)->lpVtbl->FreeBuffer(p,a) +#define IRpcChannelBuffer_GetDestCtx(p,a,b) (p)->lpVtbl->GetDestCtx(p,a,b) +#define IRpcChannelBuffer_IsConnected(p) (p)->lpVtbl->IsConnected(p) + +#endif + +HRESULT CALLBACK IRpcChannelBuffer_GetBuffer_Proxy( + IRpcChannelBuffer* This, + RPCOLEMESSAGE* pMessage, + REFIID riid); +void __RPC_STUB IRpcChannelBuffer_GetBuffer_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRpcChannelBuffer_SendReceive_Proxy( + IRpcChannelBuffer* This, + RPCOLEMESSAGE* pMessage, + ULONG* pStatus); +void __RPC_STUB IRpcChannelBuffer_SendReceive_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRpcChannelBuffer_FreeBuffer_Proxy( + IRpcChannelBuffer* This, + RPCOLEMESSAGE* pMessage); +void __RPC_STUB IRpcChannelBuffer_FreeBuffer_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRpcChannelBuffer_GetDestCtx_Proxy( + IRpcChannelBuffer* This, + DWORD* pdwDestContext, + void** ppvDestContext); +void __RPC_STUB IRpcChannelBuffer_GetDestCtx_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRpcChannelBuffer_IsConnected_Proxy( + IRpcChannelBuffer* This); +void __RPC_STUB IRpcChannelBuffer_IsConnected_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IRpcChannelBuffer2 IRpcChannelBuffer2; +typedef IRpcChannelBuffer2 *LPRPCCHANNELBUFFER2; + +/***************************************************************************** + * IRpcChannelBuffer2 interface + */ +DEFINE_GUID(IID_IRpcChannelBuffer2, 0x594f31d0, 0x7f19, 0x11d0, 0xb1,0x94, 0x00,0xa0,0xc9,0x0d,0xc8,0xbf); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IRpcChannelBuffer2: IRpcChannelBuffer { + + virtual HRESULT CALLBACK GetProtocolVersion( + DWORD* pdwVersion) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IRpcChannelBuffer2Vtbl IRpcChannelBuffer2Vtbl; +struct IRpcChannelBuffer2 { + const IRpcChannelBuffer2Vtbl* lpVtbl; +}; +struct IRpcChannelBuffer2Vtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IRpcChannelBuffer2* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IRpcChannelBuffer2* This); + + ULONG (CALLBACK *Release)( + IRpcChannelBuffer2* This); + + /*** IRpcChannelBuffer methods ***/ + HRESULT (CALLBACK *GetBuffer)( + IRpcChannelBuffer2* This, + RPCOLEMESSAGE* pMessage, + REFIID riid); + + HRESULT (CALLBACK *SendReceive)( + IRpcChannelBuffer2* This, + RPCOLEMESSAGE* pMessage, + ULONG* pStatus); + + HRESULT (CALLBACK *FreeBuffer)( + IRpcChannelBuffer2* This, + RPCOLEMESSAGE* pMessage); + + HRESULT (CALLBACK *GetDestCtx)( + IRpcChannelBuffer2* This, + DWORD* pdwDestContext, + void** ppvDestContext); + + HRESULT (CALLBACK *IsConnected)( + IRpcChannelBuffer2* This); + + /*** IRpcChannelBuffer2 methods ***/ + HRESULT (CALLBACK *GetProtocolVersion)( + IRpcChannelBuffer2* This, + DWORD* pdwVersion); + +}; + +#define IRpcChannelBuffer2_IMETHODS \ + IRpcChannelBuffer_IMETHODS \ + ICOM_METHOD1 (HRESULT,GetProtocolVersion,DWORD*,pdwVersion) + +/*** IUnknown methods ***/ +#define IRpcChannelBuffer2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IRpcChannelBuffer2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IRpcChannelBuffer2_Release(p) (p)->lpVtbl->Release(p) +/*** IRpcChannelBuffer methods ***/ +#define IRpcChannelBuffer2_GetBuffer(p,a,b) (p)->lpVtbl->GetBuffer(p,a,b) +#define IRpcChannelBuffer2_SendReceive(p,a,b) (p)->lpVtbl->SendReceive(p,a,b) +#define IRpcChannelBuffer2_FreeBuffer(p,a) (p)->lpVtbl->FreeBuffer(p,a) +#define IRpcChannelBuffer2_GetDestCtx(p,a,b) (p)->lpVtbl->GetDestCtx(p,a,b) +#define IRpcChannelBuffer2_IsConnected(p) (p)->lpVtbl->IsConnected(p) +/*** IRpcChannelBuffer2 methods ***/ +#define IRpcChannelBuffer2_GetProtocolVersion(p,a) (p)->lpVtbl->GetProtocolVersion(p,a) + +#endif + +HRESULT CALLBACK IRpcChannelBuffer2_GetProtocolVersion_Proxy( + IRpcChannelBuffer2* This, + DWORD* pdwVersion); +void __RPC_STUB IRpcChannelBuffer2_GetProtocolVersion_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IRpcChannelBuffer3 IRpcChannelBuffer3; +typedef IRpcChannelBuffer3 *LPRPCCHANNELBUFFER3; + +/***************************************************************************** + * IRpcChannelBuffer3 interface + */ +DEFINE_GUID(IID_IRpcChannelBuffer3, 0x25b15600, 0x0115, 0x11d0, 0xbf,0x0d, 0x00,0xaa,0x00,0xb8,0xdf,0xd2); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IRpcChannelBuffer3: IRpcChannelBuffer2 { + + virtual HRESULT CALLBACK Send( + RPCOLEMESSAGE* pMsg, + ULONG* pulStatus) = 0; + + virtual HRESULT CALLBACK Receive( + RPCOLEMESSAGE* pMsg, + ULONG ulSize, + ULONG* pulStatus) = 0; + + virtual HRESULT CALLBACK Cancel( + RPCOLEMESSAGE* pMsg) = 0; + + virtual HRESULT CALLBACK GetCallContext( + RPCOLEMESSAGE* pMsg, + REFIID riid, + void** pInterface) = 0; + + virtual HRESULT CALLBACK GetDestCtxEx( + RPCOLEMESSAGE* pMsg, + DWORD* pdwDestContext, + void** ppvDestContext) = 0; + + virtual HRESULT CALLBACK GetState( + RPCOLEMESSAGE* pMsg, + DWORD* pState) = 0; + + virtual HRESULT CALLBACK RegisterAsync( + RPCOLEMESSAGE* pMsg, + IAsyncManager* pAsyncMgr) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IRpcChannelBuffer3Vtbl IRpcChannelBuffer3Vtbl; +struct IRpcChannelBuffer3 { + const IRpcChannelBuffer3Vtbl* lpVtbl; +}; +struct IRpcChannelBuffer3Vtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IRpcChannelBuffer3* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IRpcChannelBuffer3* This); + + ULONG (CALLBACK *Release)( + IRpcChannelBuffer3* This); + + /*** IRpcChannelBuffer methods ***/ + HRESULT (CALLBACK *GetBuffer)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE* pMessage, + REFIID riid); + + HRESULT (CALLBACK *SendReceive)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE* pMessage, + ULONG* pStatus); + + HRESULT (CALLBACK *FreeBuffer)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE* pMessage); + + HRESULT (CALLBACK *GetDestCtx)( + IRpcChannelBuffer3* This, + DWORD* pdwDestContext, + void** ppvDestContext); + + HRESULT (CALLBACK *IsConnected)( + IRpcChannelBuffer3* This); + + /*** IRpcChannelBuffer2 methods ***/ + HRESULT (CALLBACK *GetProtocolVersion)( + IRpcChannelBuffer3* This, + DWORD* pdwVersion); + + /*** IRpcChannelBuffer3 methods ***/ + HRESULT (CALLBACK *Send)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE* pMsg, + ULONG* pulStatus); + + HRESULT (CALLBACK *Receive)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE* pMsg, + ULONG ulSize, + ULONG* pulStatus); + + HRESULT (CALLBACK *Cancel)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE* pMsg); + + HRESULT (CALLBACK *GetCallContext)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE* pMsg, + REFIID riid, + void** pInterface); + + HRESULT (CALLBACK *GetDestCtxEx)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE* pMsg, + DWORD* pdwDestContext, + void** ppvDestContext); + + HRESULT (CALLBACK *GetState)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE* pMsg, + DWORD* pState); + + HRESULT (CALLBACK *RegisterAsync)( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE* pMsg, + IAsyncManager* pAsyncMgr); + +}; + +#define IRpcChannelBuffer3_IMETHODS \ + IRpcChannelBuffer2_IMETHODS \ + ICOM_METHOD2 (HRESULT,Send,RPCOLEMESSAGE*,pMsg,ULONG*,pulStatus) \ + ICOM_METHOD3 (HRESULT,Receive,RPCOLEMESSAGE*,pMsg,ULONG,ulSize,ULONG*,pulStatus) \ + ICOM_METHOD1 (HRESULT,Cancel,RPCOLEMESSAGE*,pMsg) \ + ICOM_METHOD3 (HRESULT,GetCallContext,RPCOLEMESSAGE*,pMsg,REFIID,riid,void**,pInterface) \ + ICOM_METHOD3 (HRESULT,GetDestCtxEx,RPCOLEMESSAGE*,pMsg,DWORD*,pdwDestContext,void**,ppvDestContext) \ + ICOM_METHOD2 (HRESULT,GetState,RPCOLEMESSAGE*,pMsg,DWORD*,pState) \ + ICOM_METHOD2 (HRESULT,RegisterAsync,RPCOLEMESSAGE*,pMsg,IAsyncManager*,pAsyncMgr) + +/*** IUnknown methods ***/ +#define IRpcChannelBuffer3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IRpcChannelBuffer3_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IRpcChannelBuffer3_Release(p) (p)->lpVtbl->Release(p) +/*** IRpcChannelBuffer methods ***/ +#define IRpcChannelBuffer3_GetBuffer(p,a,b) (p)->lpVtbl->GetBuffer(p,a,b) +#define IRpcChannelBuffer3_SendReceive(p,a,b) (p)->lpVtbl->SendReceive(p,a,b) +#define IRpcChannelBuffer3_FreeBuffer(p,a) (p)->lpVtbl->FreeBuffer(p,a) +#define IRpcChannelBuffer3_GetDestCtx(p,a,b) (p)->lpVtbl->GetDestCtx(p,a,b) +#define IRpcChannelBuffer3_IsConnected(p) (p)->lpVtbl->IsConnected(p) +/*** IRpcChannelBuffer2 methods ***/ +#define IRpcChannelBuffer3_GetProtocolVersion(p,a) (p)->lpVtbl->GetProtocolVersion(p,a) +/*** IRpcChannelBuffer3 methods ***/ +#define IRpcChannelBuffer3_Send(p,a,b) (p)->lpVtbl->Send(p,a,b) +#define IRpcChannelBuffer3_Receive(p,a,b,c) (p)->lpVtbl->Receive(p,a,b,c) +#define IRpcChannelBuffer3_Cancel(p,a) (p)->lpVtbl->Cancel(p,a) +#define IRpcChannelBuffer3_GetCallContext(p,a,b,c) (p)->lpVtbl->GetCallContext(p,a,b,c) +#define IRpcChannelBuffer3_GetDestCtxEx(p,a,b,c) (p)->lpVtbl->GetDestCtxEx(p,a,b,c) +#define IRpcChannelBuffer3_GetState(p,a,b) (p)->lpVtbl->GetState(p,a,b) +#define IRpcChannelBuffer3_RegisterAsync(p,a,b) (p)->lpVtbl->RegisterAsync(p,a,b) + +#endif + +HRESULT CALLBACK IRpcChannelBuffer3_Send_Proxy( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE* pMsg, + ULONG* pulStatus); +void __RPC_STUB IRpcChannelBuffer3_Send_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRpcChannelBuffer3_Receive_Proxy( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE* pMsg, + ULONG ulSize, + ULONG* pulStatus); +void __RPC_STUB IRpcChannelBuffer3_Receive_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRpcChannelBuffer3_Cancel_Proxy( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE* pMsg); +void __RPC_STUB IRpcChannelBuffer3_Cancel_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRpcChannelBuffer3_GetCallContext_Proxy( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE* pMsg, + REFIID riid, + void** pInterface); +void __RPC_STUB IRpcChannelBuffer3_GetCallContext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRpcChannelBuffer3_GetDestCtxEx_Proxy( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE* pMsg, + DWORD* pdwDestContext, + void** ppvDestContext); +void __RPC_STUB IRpcChannelBuffer3_GetDestCtxEx_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRpcChannelBuffer3_GetState_Proxy( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE* pMsg, + DWORD* pState); +void __RPC_STUB IRpcChannelBuffer3_GetState_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRpcChannelBuffer3_RegisterAsync_Proxy( + IRpcChannelBuffer3* This, + RPCOLEMESSAGE* pMsg, + IAsyncManager* pAsyncMgr); +void __RPC_STUB IRpcChannelBuffer3_RegisterAsync_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IRpcProxyBuffer IRpcProxyBuffer; +typedef IRpcProxyBuffer *LPRPCPROXYBUFFER; + +/***************************************************************************** + * IRpcProxyBuffer interface + */ +DEFINE_GUID(IID_IRpcProxyBuffer, 0xd5f56a34, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IRpcProxyBuffer: IUnknown { + + virtual HRESULT CALLBACK Connect( + IRpcChannelBuffer* pRpcChannelBuffer) = 0; + + virtual void CALLBACK Disconnect( + ) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IRpcProxyBufferVtbl IRpcProxyBufferVtbl; +struct IRpcProxyBuffer { + const IRpcProxyBufferVtbl* lpVtbl; +}; +struct IRpcProxyBufferVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IRpcProxyBuffer* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IRpcProxyBuffer* This); + + ULONG (CALLBACK *Release)( + IRpcProxyBuffer* This); + + /*** IRpcProxyBuffer methods ***/ + HRESULT (CALLBACK *Connect)( + IRpcProxyBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer); + + void (CALLBACK *Disconnect)( + IRpcProxyBuffer* This); + +}; + +#define IRpcProxyBuffer_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD1 (HRESULT,Connect,IRpcChannelBuffer*,pRpcChannelBuffer) \ + ICOM_VMETHOD (Disconnect) + +/*** IUnknown methods ***/ +#define IRpcProxyBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IRpcProxyBuffer_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IRpcProxyBuffer_Release(p) (p)->lpVtbl->Release(p) +/*** IRpcProxyBuffer methods ***/ +#define IRpcProxyBuffer_Connect(p,a) (p)->lpVtbl->Connect(p,a) +#define IRpcProxyBuffer_Disconnect(p) (p)->lpVtbl->Disconnect(p) + +#endif + +HRESULT CALLBACK IRpcProxyBuffer_Connect_Proxy( + IRpcProxyBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer); +void __RPC_STUB IRpcProxyBuffer_Connect_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IRpcProxyBuffer_Disconnect_Proxy( + IRpcProxyBuffer* This); +void __RPC_STUB IRpcProxyBuffer_Disconnect_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IRpcStubBuffer IRpcStubBuffer; +typedef IRpcStubBuffer *LPRPCSTUBBUFFER; + +/***************************************************************************** + * IRpcStubBuffer interface + */ +DEFINE_GUID(IID_IRpcStubBuffer, 0xd5f56afc, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IRpcStubBuffer: IUnknown { + + virtual HRESULT CALLBACK Connect( + IUnknown* pUnkServer) = 0; + + virtual void CALLBACK Disconnect( + ) = 0; + + virtual HRESULT CALLBACK Invoke( + RPCOLEMESSAGE* _prpcmsg, + IRpcChannelBuffer* _pRpcChannelBuffer) = 0; + + virtual IRpcStubBuffer* CALLBACK IsIIDSupported( + REFIID riid) = 0; + + virtual ULONG CALLBACK CountRefs( + ) = 0; + + virtual HRESULT CALLBACK DebugServerQueryInterface( + void** ppv) = 0; + + virtual void CALLBACK DebugServerRelease( + void* pv) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IRpcStubBufferVtbl IRpcStubBufferVtbl; +struct IRpcStubBuffer { + const IRpcStubBufferVtbl* lpVtbl; +}; +struct IRpcStubBufferVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IRpcStubBuffer* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IRpcStubBuffer* This); + + ULONG (CALLBACK *Release)( + IRpcStubBuffer* This); + + /*** IRpcStubBuffer methods ***/ + HRESULT (CALLBACK *Connect)( + IRpcStubBuffer* This, + IUnknown* pUnkServer); + + void (CALLBACK *Disconnect)( + IRpcStubBuffer* This); + + HRESULT (CALLBACK *Invoke)( + IRpcStubBuffer* This, + RPCOLEMESSAGE* _prpcmsg, + IRpcChannelBuffer* _pRpcChannelBuffer); + + IRpcStubBuffer* (CALLBACK *IsIIDSupported)( + IRpcStubBuffer* This, + REFIID riid); + + ULONG (CALLBACK *CountRefs)( + IRpcStubBuffer* This); + + HRESULT (CALLBACK *DebugServerQueryInterface)( + IRpcStubBuffer* This, + void** ppv); + + void (CALLBACK *DebugServerRelease)( + IRpcStubBuffer* This, + void* pv); + +}; + +#define IRpcStubBuffer_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD1 (HRESULT,Connect,IUnknown*,pUnkServer) \ + ICOM_VMETHOD (Disconnect) \ + ICOM_METHOD2 (HRESULT,Invoke,RPCOLEMESSAGE*,_prpcmsg,IRpcChannelBuffer*,_pRpcChannelBuffer) \ + ICOM_METHOD1 (IRpcStubBuffer*,IsIIDSupported,REFIID,riid) \ + ICOM_METHOD (ULONG,CountRefs) \ + ICOM_METHOD1 (HRESULT,DebugServerQueryInterface,void**,ppv) \ + ICOM_VMETHOD1(DebugServerRelease,void*,pv) + +/*** IUnknown methods ***/ +#define IRpcStubBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IRpcStubBuffer_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IRpcStubBuffer_Release(p) (p)->lpVtbl->Release(p) +/*** IRpcStubBuffer methods ***/ +#define IRpcStubBuffer_Connect(p,a) (p)->lpVtbl->Connect(p,a) +#define IRpcStubBuffer_Disconnect(p) (p)->lpVtbl->Disconnect(p) +#define IRpcStubBuffer_Invoke(p,a,b) (p)->lpVtbl->Invoke(p,a,b) +#define IRpcStubBuffer_IsIIDSupported(p,a) (p)->lpVtbl->IsIIDSupported(p,a) +#define IRpcStubBuffer_CountRefs(p) (p)->lpVtbl->CountRefs(p) +#define IRpcStubBuffer_DebugServerQueryInterface(p,a) (p)->lpVtbl->DebugServerQueryInterface(p,a) +#define IRpcStubBuffer_DebugServerRelease(p,a) (p)->lpVtbl->DebugServerRelease(p,a) + +#endif + +HRESULT CALLBACK IRpcStubBuffer_Connect_Proxy( + IRpcStubBuffer* This, + IUnknown* pUnkServer); +void __RPC_STUB IRpcStubBuffer_Connect_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IRpcStubBuffer_Disconnect_Proxy( + IRpcStubBuffer* This); +void __RPC_STUB IRpcStubBuffer_Disconnect_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRpcStubBuffer_Invoke_Proxy( + IRpcStubBuffer* This, + RPCOLEMESSAGE* _prpcmsg, + IRpcChannelBuffer* _pRpcChannelBuffer); +void __RPC_STUB IRpcStubBuffer_Invoke_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +IRpcStubBuffer* CALLBACK IRpcStubBuffer_IsIIDSupported_Proxy( + IRpcStubBuffer* This, + REFIID riid); +void __RPC_STUB IRpcStubBuffer_IsIIDSupported_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +ULONG CALLBACK IRpcStubBuffer_CountRefs_Proxy( + IRpcStubBuffer* This); +void __RPC_STUB IRpcStubBuffer_CountRefs_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRpcStubBuffer_DebugServerQueryInterface_Proxy( + IRpcStubBuffer* This, + void** ppv); +void __RPC_STUB IRpcStubBuffer_DebugServerQueryInterface_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IRpcStubBuffer_DebugServerRelease_Proxy( + IRpcStubBuffer* This, + void* pv); +void __RPC_STUB IRpcStubBuffer_DebugServerRelease_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IPSFactoryBuffer IPSFactoryBuffer; +typedef IPSFactoryBuffer *LPPSFACTORYBUFFER; + +/***************************************************************************** + * IPSFactoryBuffer interface + */ +DEFINE_GUID(IID_IPSFactoryBuffer, 0xd5f569d0, 0x593b, 0x101a, 0xb5,0x69, 0x08,0x00,0x2b,0x2d,0xbf,0x7a); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPSFactoryBuffer: IUnknown { + + virtual HRESULT CALLBACK CreateProxy( + IUnknown* pUnkOuter, + REFIID riid, + IRpcProxyBuffer** ppProxy, + void** ppv) = 0; + + virtual HRESULT CALLBACK CreateStub( + REFIID riid, + IUnknown* pUnkServer, + IRpcStubBuffer** ppStub) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IPSFactoryBufferVtbl IPSFactoryBufferVtbl; +struct IPSFactoryBuffer { + const IPSFactoryBufferVtbl* lpVtbl; +}; +struct IPSFactoryBufferVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IPSFactoryBuffer* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IPSFactoryBuffer* This); + + ULONG (CALLBACK *Release)( + IPSFactoryBuffer* This); + + /*** IPSFactoryBuffer methods ***/ + HRESULT (CALLBACK *CreateProxy)( + IPSFactoryBuffer* This, + IUnknown* pUnkOuter, + REFIID riid, + IRpcProxyBuffer** ppProxy, + void** ppv); + + HRESULT (CALLBACK *CreateStub)( + IPSFactoryBuffer* This, + REFIID riid, + IUnknown* pUnkServer, + IRpcStubBuffer** ppStub); + +}; + +#define IPSFactoryBuffer_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD4 (HRESULT,CreateProxy,IUnknown*,pUnkOuter,REFIID,riid,IRpcProxyBuffer**,ppProxy,void**,ppv) \ + ICOM_METHOD3 (HRESULT,CreateStub,REFIID,riid,IUnknown*,pUnkServer,IRpcStubBuffer**,ppStub) + +/*** IUnknown methods ***/ +#define IPSFactoryBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPSFactoryBuffer_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPSFactoryBuffer_Release(p) (p)->lpVtbl->Release(p) +/*** IPSFactoryBuffer methods ***/ +#define IPSFactoryBuffer_CreateProxy(p,a,b,c,d) (p)->lpVtbl->CreateProxy(p,a,b,c,d) +#define IPSFactoryBuffer_CreateStub(p,a,b,c) (p)->lpVtbl->CreateStub(p,a,b,c) + +#endif + +HRESULT CALLBACK IPSFactoryBuffer_CreateProxy_Proxy( + IPSFactoryBuffer* This, + IUnknown* pUnkOuter, + REFIID riid, + IRpcProxyBuffer** ppProxy, + void** ppv); +void __RPC_STUB IPSFactoryBuffer_CreateProxy_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPSFactoryBuffer_CreateStub_Proxy( + IPSFactoryBuffer* This, + REFIID riid, + IUnknown* pUnkServer, + IRpcStubBuffer** ppStub); +void __RPC_STUB IPSFactoryBuffer_CreateStub_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IChannelHook IChannelHook; +typedef IChannelHook *LPCHANNELHOOK; + +typedef struct SChannelHookCallInfo { + IID iid; + DWORD cbSize; + GUID uCausality; + DWORD dwServerPid; + DWORD iMethod; + void *pObject; +} SChannelHookCallInfo; + +/***************************************************************************** + * IChannelHook interface + */ +DEFINE_GUID(IID_IChannelHook, 0x1008c4a0, 0x7613, 0x11cf, 0x9a,0xf1, 0x00,0x20,0xaf,0x6e,0x72,0xf4); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IChannelHook: IUnknown { + + virtual void CALLBACK ClientGetSize( + REFGUID uExtent, + REFIID riid, + ULONG* pDataSize) = 0; + + virtual void CALLBACK ClientFillBuffer( + REFGUID uExtent, + REFIID riid, + ULONG* pDataSize, + void* pDataBuffer) = 0; + + virtual void CALLBACK ClientNotify( + REFGUID uExtent, + REFIID riid, + ULONG cbDataSize, + void* pDataBuffer, + DWORD lDataRep, + HRESULT hrFault) = 0; + + virtual void CALLBACK ServerNotify( + REFGUID uExtent, + REFIID riid, + ULONG cbDataSize, + void* pDataBuffer, + DWORD lDataRep) = 0; + + virtual void CALLBACK ServerGetSize( + REFGUID uExtent, + REFIID riid, + HRESULT hrFault, + ULONG* pDataSize) = 0; + + virtual void CALLBACK ServerFillBuffer( + REFGUID uExtent, + REFIID riid, + ULONG* pDataSize, + void* pDataBuffer, + HRESULT hrFault) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IChannelHookVtbl IChannelHookVtbl; +struct IChannelHook { + const IChannelHookVtbl* lpVtbl; +}; +struct IChannelHookVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IChannelHook* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IChannelHook* This); + + ULONG (CALLBACK *Release)( + IChannelHook* This); + + /*** IChannelHook methods ***/ + void (CALLBACK *ClientGetSize)( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG* pDataSize); + + void (CALLBACK *ClientFillBuffer)( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG* pDataSize, + void* pDataBuffer); + + void (CALLBACK *ClientNotify)( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG cbDataSize, + void* pDataBuffer, + DWORD lDataRep, + HRESULT hrFault); + + void (CALLBACK *ServerNotify)( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG cbDataSize, + void* pDataBuffer, + DWORD lDataRep); + + void (CALLBACK *ServerGetSize)( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + HRESULT hrFault, + ULONG* pDataSize); + + void (CALLBACK *ServerFillBuffer)( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG* pDataSize, + void* pDataBuffer, + HRESULT hrFault); + +}; + +#define IChannelHook_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_VMETHOD3(ClientGetSize,REFGUID,uExtent,REFIID,riid,ULONG*,pDataSize) \ + ICOM_VMETHOD4(ClientFillBuffer,REFGUID,uExtent,REFIID,riid,ULONG*,pDataSize,void*,pDataBuffer) \ + ICOM_VMETHOD6(ClientNotify,REFGUID,uExtent,REFIID,riid,ULONG,cbDataSize,void*,pDataBuffer,DWORD,lDataRep,HRESULT,hrFault) \ + ICOM_VMETHOD5(ServerNotify,REFGUID,uExtent,REFIID,riid,ULONG,cbDataSize,void*,pDataBuffer,DWORD,lDataRep) \ + ICOM_VMETHOD4(ServerGetSize,REFGUID,uExtent,REFIID,riid,HRESULT,hrFault,ULONG*,pDataSize) \ + ICOM_VMETHOD5(ServerFillBuffer,REFGUID,uExtent,REFIID,riid,ULONG*,pDataSize,void*,pDataBuffer,HRESULT,hrFault) + +/*** IUnknown methods ***/ +#define IChannelHook_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IChannelHook_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IChannelHook_Release(p) (p)->lpVtbl->Release(p) +/*** IChannelHook methods ***/ +#define IChannelHook_ClientGetSize(p,a,b,c) (p)->lpVtbl->ClientGetSize(p,a,b,c) +#define IChannelHook_ClientFillBuffer(p,a,b,c,d) (p)->lpVtbl->ClientFillBuffer(p,a,b,c,d) +#define IChannelHook_ClientNotify(p,a,b,c,d,e,f) (p)->lpVtbl->ClientNotify(p,a,b,c,d,e,f) +#define IChannelHook_ServerNotify(p,a,b,c,d,e) (p)->lpVtbl->ServerNotify(p,a,b,c,d,e) +#define IChannelHook_ServerGetSize(p,a,b,c,d) (p)->lpVtbl->ServerGetSize(p,a,b,c,d) +#define IChannelHook_ServerFillBuffer(p,a,b,c,d,e) (p)->lpVtbl->ServerFillBuffer(p,a,b,c,d,e) + +#endif + +void CALLBACK IChannelHook_ClientGetSize_Proxy( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG* pDataSize); +void __RPC_STUB IChannelHook_ClientGetSize_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IChannelHook_ClientFillBuffer_Proxy( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG* pDataSize, + void* pDataBuffer); +void __RPC_STUB IChannelHook_ClientFillBuffer_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IChannelHook_ClientNotify_Proxy( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG cbDataSize, + void* pDataBuffer, + DWORD lDataRep, + HRESULT hrFault); +void __RPC_STUB IChannelHook_ClientNotify_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IChannelHook_ServerNotify_Proxy( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG cbDataSize, + void* pDataBuffer, + DWORD lDataRep); +void __RPC_STUB IChannelHook_ServerNotify_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IChannelHook_ServerGetSize_Proxy( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + HRESULT hrFault, + ULONG* pDataSize); +void __RPC_STUB IChannelHook_ServerGetSize_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IChannelHook_ServerFillBuffer_Proxy( + IChannelHook* This, + REFGUID uExtent, + REFIID riid, + ULONG* pDataSize, + void* pDataBuffer, + HRESULT hrFault); +void __RPC_STUB IChannelHook_ServerFillBuffer_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IEnumSTATPROPSTG IEnumSTATPROPSTG; +typedef struct IEnumSTATPROPSETSTG IEnumSTATPROPSETSTG; +typedef struct IPropertyStorage IPropertyStorage; +typedef IPropertyStorage *LPPROPERTYSTORAGE; + +extern const FMTID FMTID_SummaryInformation; + +extern const FMTID FMTID_DocSummaryInformation; + +extern const FMTID FMTID_UserDefinedProperties; + +#define PROPSETFLAG_DEFAULT (0) + +#define PROPSETFLAG_NONSIMPLE (1) + +#define PROPSETFLAG_ANSI (2) + +#define PROPSETFLAG_UNBUFFERED (4) + +typedef struct tagPROPVARIANT PROPVARIANT; + +typedef struct tagCAUB { + ULONG cElems; + unsigned char *pElems; +} CAUB; + +typedef struct tagCAI { + ULONG cElems; + short *pElems; +} CAI; + +typedef struct tagCAUI { + ULONG cElems; + USHORT *pElems; +} CAUI; + +typedef struct tagCAL { + ULONG cElems; + long *pElems; +} CAL; + +typedef struct tagCAUL { + ULONG cElems; + ULONG *pElems; +} CAUL; + +typedef struct tagCAFLT { + ULONG cElems; + float *pElems; +} CAFLT; + +typedef struct tagCADBL { + ULONG cElems; + double *pElems; +} CADBL; + +typedef struct tagCACY { + ULONG cElems; + CY *pElems; +} CACY; + +typedef struct tagCADATE { + ULONG cElems; + DATE *pElems; +} CADATE; + +typedef struct tagCABSTR { + ULONG cElems; + BSTR *pElems; +} CABSTR; + +typedef struct tagCABSTRBLOB { + ULONG cElems; + BSTRBLOB *pElems; +} CABSTRBLOB; + +typedef struct tagCABOOL { + ULONG cElems; + VARIANT_BOOL *pElems; +} CABOOL; + +typedef struct tagCASCODE { + ULONG cElems; + SCODE *pElems; +} CASCODE; + +typedef struct tagCAPROPVARIANT { + ULONG cElems; + PROPVARIANT *pElems; +} CAPROPVARIANT; + +typedef struct tagCAH { + ULONG cElems; + LARGE_INTEGER *pElems; +} CAH; + +typedef struct tagCAUH { + ULONG cElems; + ULARGE_INTEGER *pElems; +} CAUH; + +typedef struct tagCALPSTR { + ULONG cElems; + LPSTR *pElems; +} CALPSTR; + +typedef struct tagCALPWSTR { + ULONG cElems; + LPWSTR *pElems; +} CALPWSTR; + +typedef struct tagCAFILETIME { + ULONG cElems; + FILETIME *pElems; +} CAFILETIME; + +typedef struct tagCACLIPDATA { + ULONG cElems; + CLIPDATA *pElems; +} CACLIPDATA; + +typedef struct tagCACLSID { + ULONG cElems; + CLSID *pElems; +} CACLSID; + +struct tagPROPVARIANT { + VARTYPE vt; + WORD wReserved1; + WORD wReserved2; + WORD wReserved3; + union { + UCHAR bVal; + short iVal; + USHORT uiVal; + VARIANT_BOOL boolVal; + long lVal; + ULONG ulVal; + float fltVal; + SCODE scode; + LARGE_INTEGER hVal; + ULARGE_INTEGER uhVal; + double dblVal; + CY cyVal; + DATE date; + FILETIME filetime; + CLSID *puuid; + BLOB blob; + CLIPDATA *pclipdata; + IStream *pStream; + IStorage *pStorage; + BSTR bstrVal; + BSTRBLOB bstrblobVal; + LPSTR pszVal; + LPWSTR pwszVal; + CAUB caub; + CAI cai; + CAUI caui; + CABOOL cabool; + CAL cal; + CAUL caul; + CAFLT caflt; + CASCODE cascode; + CAH cah; + CAUH cauh; + CADBL cadbl; + CACY cacy; + CADATE cadate; + CAFILETIME cafiletime; + CACLSID cauuid; + CACLIPDATA caclipdata; + CABSTR cabstr; + CABSTRBLOB cabstrblob; + CALPSTR calpstr; + CALPWSTR calpwstr; + CAPROPVARIANT capropvar; + } DUMMYUNIONNAME; +}; + +typedef struct tagPROPVARIANT *LPPROPVARIANT; + +#define PRSPEC_INVALID (0x7fffffff) + +#define PRSPEC_LPWSTR (0) + +#define PRSPEC_PROPID (1) + +typedef struct tagPROPSPEC { + ULONG ulKind; + union { + PROPID propid; + LPOLESTR lpwstr; + } DUMMYUNIONNAME; +} PROPSPEC; + +typedef struct tagSTATPROPSTG { + LPOLESTR lpwstrName; + PROPID propid; + VARTYPE vt; +} STATPROPSTG; + +typedef struct tagSTATPROPSETSTG { + FMTID fmtid; + CLSID clsid; + DWORD grfFlags; + FILETIME mtime; + FILETIME ctime; + FILETIME atime; + DWORD dwOSVersion; +} STATPROPSETSTG; + +/***************************************************************************** + * IPropertyStorage interface + */ +DEFINE_GUID(IID_IPropertyStorage, 0x00000138, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPropertyStorage: IUnknown { + + virtual HRESULT CALLBACK ReadMultiple( + ULONG cpspec, + const PROPSPEC rgpspec[], + PROPVARIANT rgpropvar[]) = 0; + + virtual HRESULT CALLBACK WriteMultiple( + ULONG cpspec, + const PROPSPEC rgpspec[], + const PROPVARIANT rgpropvar[], + PROPID propidNameFirst) = 0; + + virtual HRESULT CALLBACK DeleteMultiple( + ULONG cpspec, + const PROPSPEC rgpspec[]) = 0; + + virtual HRESULT CALLBACK ReadPropertyNames( + ULONG cpropid, + const PROPID rgpropid[], + LPOLESTR rglpwstrName[]) = 0; + + virtual HRESULT CALLBACK WritePropertyNames( + ULONG cpropid, + const PROPID rgpropid[], + const LPOLESTR rglpwstrName[]) = 0; + + virtual HRESULT CALLBACK DeletePropertyNames( + ULONG cpropid, + const PROPID rgpropid[]) = 0; + + virtual HRESULT CALLBACK Commit( + DWORD grfCommitFlags) = 0; + + virtual HRESULT CALLBACK Revert( + ) = 0; + + virtual HRESULT CALLBACK Enum( + IEnumSTATPROPSTG** ppenum) = 0; + + virtual HRESULT CALLBACK SetTimes( + const FILETIME* pctime, + const FILETIME* patime, + const FILETIME* pmtime) = 0; + + virtual HRESULT CALLBACK SetClass( + REFCLSID clsid) = 0; + + virtual HRESULT CALLBACK Stat( + STATPROPSETSTG* statpsstg) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IPropertyStorageVtbl IPropertyStorageVtbl; +struct IPropertyStorage { + const IPropertyStorageVtbl* lpVtbl; +}; +struct IPropertyStorageVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IPropertyStorage* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IPropertyStorage* This); + + ULONG (CALLBACK *Release)( + IPropertyStorage* This); + + /*** IPropertyStorage methods ***/ + HRESULT (CALLBACK *ReadMultiple)( + IPropertyStorage* This, + ULONG cpspec, + const PROPSPEC rgpspec[], + PROPVARIANT rgpropvar[]); + + HRESULT (CALLBACK *WriteMultiple)( + IPropertyStorage* This, + ULONG cpspec, + const PROPSPEC rgpspec[], + const PROPVARIANT rgpropvar[], + PROPID propidNameFirst); + + HRESULT (CALLBACK *DeleteMultiple)( + IPropertyStorage* This, + ULONG cpspec, + const PROPSPEC rgpspec[]); + + HRESULT (CALLBACK *ReadPropertyNames)( + IPropertyStorage* This, + ULONG cpropid, + const PROPID rgpropid[], + LPOLESTR rglpwstrName[]); + + HRESULT (CALLBACK *WritePropertyNames)( + IPropertyStorage* This, + ULONG cpropid, + const PROPID rgpropid[], + const LPOLESTR rglpwstrName[]); + + HRESULT (CALLBACK *DeletePropertyNames)( + IPropertyStorage* This, + ULONG cpropid, + const PROPID rgpropid[]); + + HRESULT (CALLBACK *Commit)( + IPropertyStorage* This, + DWORD grfCommitFlags); + + HRESULT (CALLBACK *Revert)( + IPropertyStorage* This); + + HRESULT (CALLBACK *Enum)( + IPropertyStorage* This, + IEnumSTATPROPSTG** ppenum); + + HRESULT (CALLBACK *SetTimes)( + IPropertyStorage* This, + const FILETIME* pctime, + const FILETIME* patime, + const FILETIME* pmtime); + + HRESULT (CALLBACK *SetClass)( + IPropertyStorage* This, + REFCLSID clsid); + + HRESULT (CALLBACK *Stat)( + IPropertyStorage* This, + STATPROPSETSTG* statpsstg); + +}; + +#define IPropertyStorage_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD3 (HRESULT,ReadMultiple,ULONG,cpspec,const PROPSPEC*,rgpspec,PROPVARIANT*,rgpropvar) \ + ICOM_METHOD4 (HRESULT,WriteMultiple,ULONG,cpspec,const PROPSPEC*,rgpspec,const PROPVARIANT*,rgpropvar,PROPID,propidNameFirst) \ + ICOM_METHOD2 (HRESULT,DeleteMultiple,ULONG,cpspec,const PROPSPEC*,rgpspec) \ + ICOM_METHOD3 (HRESULT,ReadPropertyNames,ULONG,cpropid,const PROPID*,rgpropid,LPOLESTR*,rglpwstrName) \ + ICOM_METHOD3 (HRESULT,WritePropertyNames,ULONG,cpropid,const PROPID*,rgpropid,const LPOLESTR*,rglpwstrName) \ + ICOM_METHOD2 (HRESULT,DeletePropertyNames,ULONG,cpropid,const PROPID*,rgpropid) \ + ICOM_METHOD1 (HRESULT,Commit,DWORD,grfCommitFlags) \ + ICOM_METHOD (HRESULT,Revert) \ + ICOM_METHOD1 (HRESULT,Enum,IEnumSTATPROPSTG**,ppenum) \ + ICOM_METHOD3 (HRESULT,SetTimes,const FILETIME*,pctime,const FILETIME*,patime,const FILETIME*,pmtime) \ + ICOM_METHOD1 (HRESULT,SetClass,REFCLSID,clsid) \ + ICOM_METHOD1 (HRESULT,Stat,STATPROPSETSTG*,statpsstg) + +/*** IUnknown methods ***/ +#define IPropertyStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPropertyStorage_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPropertyStorage_Release(p) (p)->lpVtbl->Release(p) +/*** IPropertyStorage methods ***/ +#define IPropertyStorage_ReadMultiple(p,a,b,c) (p)->lpVtbl->ReadMultiple(p,a,b,c) +#define IPropertyStorage_WriteMultiple(p,a,b,c,d) (p)->lpVtbl->WriteMultiple(p,a,b,c,d) +#define IPropertyStorage_DeleteMultiple(p,a,b) (p)->lpVtbl->DeleteMultiple(p,a,b) +#define IPropertyStorage_ReadPropertyNames(p,a,b,c) (p)->lpVtbl->ReadPropertyNames(p,a,b,c) +#define IPropertyStorage_WritePropertyNames(p,a,b,c) (p)->lpVtbl->WritePropertyNames(p,a,b,c) +#define IPropertyStorage_DeletePropertyNames(p,a,b) (p)->lpVtbl->DeletePropertyNames(p,a,b) +#define IPropertyStorage_Commit(p,a) (p)->lpVtbl->Commit(p,a) +#define IPropertyStorage_Revert(p) (p)->lpVtbl->Revert(p) +#define IPropertyStorage_Enum(p,a) (p)->lpVtbl->Enum(p,a) +#define IPropertyStorage_SetTimes(p,a,b,c) (p)->lpVtbl->SetTimes(p,a,b,c) +#define IPropertyStorage_SetClass(p,a) (p)->lpVtbl->SetClass(p,a) +#define IPropertyStorage_Stat(p,a) (p)->lpVtbl->Stat(p,a) + +#endif + +HRESULT CALLBACK IPropertyStorage_ReadMultiple_Proxy( + IPropertyStorage* This, + ULONG cpspec, + const PROPSPEC rgpspec[], + PROPVARIANT rgpropvar[]); +void __RPC_STUB IPropertyStorage_ReadMultiple_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyStorage_WriteMultiple_Proxy( + IPropertyStorage* This, + ULONG cpspec, + const PROPSPEC rgpspec[], + const PROPVARIANT rgpropvar[], + PROPID propidNameFirst); +void __RPC_STUB IPropertyStorage_WriteMultiple_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyStorage_DeleteMultiple_Proxy( + IPropertyStorage* This, + ULONG cpspec, + const PROPSPEC rgpspec[]); +void __RPC_STUB IPropertyStorage_DeleteMultiple_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyStorage_ReadPropertyNames_Proxy( + IPropertyStorage* This, + ULONG cpropid, + const PROPID rgpropid[], + LPOLESTR rglpwstrName[]); +void __RPC_STUB IPropertyStorage_ReadPropertyNames_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyStorage_WritePropertyNames_Proxy( + IPropertyStorage* This, + ULONG cpropid, + const PROPID rgpropid[], + const LPOLESTR rglpwstrName[]); +void __RPC_STUB IPropertyStorage_WritePropertyNames_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyStorage_DeletePropertyNames_Proxy( + IPropertyStorage* This, + ULONG cpropid, + const PROPID rgpropid[]); +void __RPC_STUB IPropertyStorage_DeletePropertyNames_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyStorage_Commit_Proxy( + IPropertyStorage* This, + DWORD grfCommitFlags); +void __RPC_STUB IPropertyStorage_Commit_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyStorage_Revert_Proxy( + IPropertyStorage* This); +void __RPC_STUB IPropertyStorage_Revert_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyStorage_Enum_Proxy( + IPropertyStorage* This, + IEnumSTATPROPSTG** ppenum); +void __RPC_STUB IPropertyStorage_Enum_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyStorage_SetTimes_Proxy( + IPropertyStorage* This, + const FILETIME* pctime, + const FILETIME* patime, + const FILETIME* pmtime); +void __RPC_STUB IPropertyStorage_SetTimes_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyStorage_SetClass_Proxy( + IPropertyStorage* This, + REFCLSID clsid); +void __RPC_STUB IPropertyStorage_SetClass_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyStorage_Stat_Proxy( + IPropertyStorage* This, + STATPROPSETSTG* statpsstg); +void __RPC_STUB IPropertyStorage_Stat_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IPropertySetStorage IPropertySetStorage; +typedef IPropertySetStorage *LPPROPERTYSETSTORAGE; + +/***************************************************************************** + * IPropertySetStorage interface + */ +DEFINE_GUID(IID_IPropertySetStorage, 0x0000013a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPropertySetStorage: IUnknown { + + virtual HRESULT CALLBACK Create( + REFFMTID rfmtid, + const CLSID* pclsid, + DWORD grfFlags, + DWORD grfMode, + IPropertyStorage** ppprstg) = 0; + + virtual HRESULT CALLBACK Open( + REFFMTID rfmtid, + DWORD grfMode, + IPropertyStorage** ppprstg) = 0; + + virtual HRESULT CALLBACK Delete( + REFFMTID rfmtid) = 0; + + virtual HRESULT CALLBACK Enum( + IEnumSTATPROPSETSTG** ppenum) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IPropertySetStorageVtbl IPropertySetStorageVtbl; +struct IPropertySetStorage { + const IPropertySetStorageVtbl* lpVtbl; +}; +struct IPropertySetStorageVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IPropertySetStorage* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IPropertySetStorage* This); + + ULONG (CALLBACK *Release)( + IPropertySetStorage* This); + + /*** IPropertySetStorage methods ***/ + HRESULT (CALLBACK *Create)( + IPropertySetStorage* This, + REFFMTID rfmtid, + const CLSID* pclsid, + DWORD grfFlags, + DWORD grfMode, + IPropertyStorage** ppprstg); + + HRESULT (CALLBACK *Open)( + IPropertySetStorage* This, + REFFMTID rfmtid, + DWORD grfMode, + IPropertyStorage** ppprstg); + + HRESULT (CALLBACK *Delete)( + IPropertySetStorage* This, + REFFMTID rfmtid); + + HRESULT (CALLBACK *Enum)( + IPropertySetStorage* This, + IEnumSTATPROPSETSTG** ppenum); + +}; + +#define IPropertySetStorage_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD5 (HRESULT,Create,REFFMTID,rfmtid,const CLSID*,pclsid,DWORD,grfFlags,DWORD,grfMode,IPropertyStorage**,ppprstg) \ + ICOM_METHOD3 (HRESULT,Open,REFFMTID,rfmtid,DWORD,grfMode,IPropertyStorage**,ppprstg) \ + ICOM_METHOD1 (HRESULT,Delete,REFFMTID,rfmtid) \ + ICOM_METHOD1 (HRESULT,Enum,IEnumSTATPROPSETSTG**,ppenum) + +/*** IUnknown methods ***/ +#define IPropertySetStorage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPropertySetStorage_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPropertySetStorage_Release(p) (p)->lpVtbl->Release(p) +/*** IPropertySetStorage methods ***/ +#define IPropertySetStorage_Create(p,a,b,c,d,e) (p)->lpVtbl->Create(p,a,b,c,d,e) +#define IPropertySetStorage_Open(p,a,b,c) (p)->lpVtbl->Open(p,a,b,c) +#define IPropertySetStorage_Delete(p,a) (p)->lpVtbl->Delete(p,a) +#define IPropertySetStorage_Enum(p,a) (p)->lpVtbl->Enum(p,a) + +#endif + +HRESULT CALLBACK IPropertySetStorage_Create_Proxy( + IPropertySetStorage* This, + REFFMTID rfmtid, + const CLSID* pclsid, + DWORD grfFlags, + DWORD grfMode, + IPropertyStorage** ppprstg); +void __RPC_STUB IPropertySetStorage_Create_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertySetStorage_Open_Proxy( + IPropertySetStorage* This, + REFFMTID rfmtid, + DWORD grfMode, + IPropertyStorage** ppprstg); +void __RPC_STUB IPropertySetStorage_Open_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertySetStorage_Delete_Proxy( + IPropertySetStorage* This, + REFFMTID rfmtid); +void __RPC_STUB IPropertySetStorage_Delete_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertySetStorage_Enum_Proxy( + IPropertySetStorage* This, + IEnumSTATPROPSETSTG** ppenum); +void __RPC_STUB IPropertySetStorage_Enum_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef IEnumSTATPROPSTG *LPENUMSTATPROPSTG; + +/***************************************************************************** + * IEnumSTATPROPSTG interface + */ +DEFINE_GUID(IID_IEnumSTATPROPSTG, 0x00000139, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IEnumSTATPROPSTG: IUnknown { + + virtual HRESULT CALLBACK Next( + ULONG celt, + STATPROPSTG* rgelt, + ULONG* pceltFetched) = 0; + + virtual HRESULT CALLBACK Skip( + ULONG celt) = 0; + + virtual HRESULT CALLBACK Reset( + ) = 0; + + virtual HRESULT CALLBACK Clone( + IEnumSTATPROPSTG** ppenum) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IEnumSTATPROPSTGVtbl IEnumSTATPROPSTGVtbl; +struct IEnumSTATPROPSTG { + const IEnumSTATPROPSTGVtbl* lpVtbl; +}; +struct IEnumSTATPROPSTGVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IEnumSTATPROPSTG* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IEnumSTATPROPSTG* This); + + ULONG (CALLBACK *Release)( + IEnumSTATPROPSTG* This); + + /*** IEnumSTATPROPSTG methods ***/ + HRESULT (CALLBACK *Next)( + IEnumSTATPROPSTG* This, + ULONG celt, + STATPROPSTG* rgelt, + ULONG* pceltFetched); + + HRESULT (CALLBACK *Skip)( + IEnumSTATPROPSTG* This, + ULONG celt); + + HRESULT (CALLBACK *Reset)( + IEnumSTATPROPSTG* This); + + HRESULT (CALLBACK *Clone)( + IEnumSTATPROPSTG* This, + IEnumSTATPROPSTG** ppenum); + +}; + +#define IEnumSTATPROPSTG_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD3 (HRESULT,Next,ULONG,celt,STATPROPSTG*,rgelt,ULONG*,pceltFetched) \ + ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \ + ICOM_METHOD (HRESULT,Reset) \ + ICOM_METHOD1 (HRESULT,Clone,IEnumSTATPROPSTG**,ppenum) + +/*** IUnknown methods ***/ +#define IEnumSTATPROPSTG_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumSTATPROPSTG_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumSTATPROPSTG_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumSTATPROPSTG methods ***/ +#define IEnumSTATPROPSTG_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumSTATPROPSTG_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumSTATPROPSTG_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumSTATPROPSTG_Clone(p,a) (p)->lpVtbl->Clone(p,a) + +#endif + +HRESULT CALLBACK IEnumSTATPROPSTG_RemoteNext_Proxy( + IEnumSTATPROPSTG* This, + ULONG celt, + STATPROPSTG* rgelt, + ULONG* pceltFetched); +void __RPC_STUB IEnumSTATPROPSTG_RemoteNext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumSTATPROPSTG_Next_Proxy( + IEnumSTATPROPSTG* This, + ULONG celt, + STATPROPSTG* rgelt, + ULONG* pceltFetched); +HRESULT __RPC_STUB IEnumSTATPROPSTG_Next_Stub( + IEnumSTATPROPSTG* This, + ULONG celt, + STATPROPSTG* rgelt, + ULONG* pceltFetched); +HRESULT CALLBACK IEnumSTATPROPSTG_Skip_Proxy( + IEnumSTATPROPSTG* This, + ULONG celt); +void __RPC_STUB IEnumSTATPROPSTG_Skip_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumSTATPROPSTG_Reset_Proxy( + IEnumSTATPROPSTG* This); +void __RPC_STUB IEnumSTATPROPSTG_Reset_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumSTATPROPSTG_Clone_Proxy( + IEnumSTATPROPSTG* This, + IEnumSTATPROPSTG** ppenum); +void __RPC_STUB IEnumSTATPROPSTG_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef IEnumSTATPROPSETSTG *LPENUMSTATPROPSETSTG; + +/***************************************************************************** + * IEnumSTATPROPSETSTG interface + */ +DEFINE_GUID(IID_IEnumSTATPROPSETSTG, 0x0000013b, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IEnumSTATPROPSETSTG: IUnknown { + + virtual HRESULT CALLBACK Next( + ULONG celt, + STATPROPSETSTG* rgelt, + ULONG* pceltFetched) = 0; + + virtual HRESULT CALLBACK Skip( + ULONG celt) = 0; + + virtual HRESULT CALLBACK Reset( + ) = 0; + + virtual HRESULT CALLBACK Clone( + IEnumSTATPROPSETSTG** ppenum) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IEnumSTATPROPSETSTGVtbl IEnumSTATPROPSETSTGVtbl; +struct IEnumSTATPROPSETSTG { + const IEnumSTATPROPSETSTGVtbl* lpVtbl; +}; +struct IEnumSTATPROPSETSTGVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IEnumSTATPROPSETSTG* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IEnumSTATPROPSETSTG* This); + + ULONG (CALLBACK *Release)( + IEnumSTATPROPSETSTG* This); + + /*** IEnumSTATPROPSETSTG methods ***/ + HRESULT (CALLBACK *Next)( + IEnumSTATPROPSETSTG* This, + ULONG celt, + STATPROPSETSTG* rgelt, + ULONG* pceltFetched); + + HRESULT (CALLBACK *Skip)( + IEnumSTATPROPSETSTG* This, + ULONG celt); + + HRESULT (CALLBACK *Reset)( + IEnumSTATPROPSETSTG* This); + + HRESULT (CALLBACK *Clone)( + IEnumSTATPROPSETSTG* This, + IEnumSTATPROPSETSTG** ppenum); + +}; + +#define IEnumSTATPROPSETSTG_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD3 (HRESULT,Next,ULONG,celt,STATPROPSETSTG*,rgelt,ULONG*,pceltFetched) \ + ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \ + ICOM_METHOD (HRESULT,Reset) \ + ICOM_METHOD1 (HRESULT,Clone,IEnumSTATPROPSETSTG**,ppenum) + +/*** IUnknown methods ***/ +#define IEnumSTATPROPSETSTG_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumSTATPROPSETSTG_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumSTATPROPSETSTG_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumSTATPROPSETSTG methods ***/ +#define IEnumSTATPROPSETSTG_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumSTATPROPSETSTG_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumSTATPROPSETSTG_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumSTATPROPSETSTG_Clone(p,a) (p)->lpVtbl->Clone(p,a) + +#endif + +HRESULT CALLBACK IEnumSTATPROPSETSTG_RemoteNext_Proxy( + IEnumSTATPROPSETSTG* This, + ULONG celt, + STATPROPSETSTG* rgelt, + ULONG* pceltFetched); +void __RPC_STUB IEnumSTATPROPSETSTG_RemoteNext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumSTATPROPSETSTG_Next_Proxy( + IEnumSTATPROPSETSTG* This, + ULONG celt, + STATPROPSETSTG* rgelt, + ULONG* pceltFetched); +HRESULT __RPC_STUB IEnumSTATPROPSETSTG_Next_Stub( + IEnumSTATPROPSETSTG* This, + ULONG celt, + STATPROPSETSTG* rgelt, + ULONG* pceltFetched); +HRESULT CALLBACK IEnumSTATPROPSETSTG_Skip_Proxy( + IEnumSTATPROPSETSTG* This, + ULONG celt); +void __RPC_STUB IEnumSTATPROPSETSTG_Skip_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumSTATPROPSETSTG_Reset_Proxy( + IEnumSTATPROPSETSTG* This); +void __RPC_STUB IEnumSTATPROPSETSTG_Reset_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumSTATPROPSETSTG_Clone_Proxy( + IEnumSTATPROPSETSTG* This, + IEnumSTATPROPSETSTG** ppenum); +void __RPC_STUB IEnumSTATPROPSETSTG_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IClientSecurity IClientSecurity; +typedef struct tagSOLE_AUTHENTICATION_SERVICE { + DWORD dwAuthnSvc; + DWORD dwAuthzSvc; + OLECHAR *pPrincipalName; + HRESULT hr; +} SOLE_AUTHENTICATION_SERVICE; + +typedef SOLE_AUTHENTICATION_SERVICE *PSOLE_AUTHENTICATION_SERVICE; + +typedef enum tagEOLE_AUTHENTICATION_CAPABILITIES { + EOAC_NONE = 0x0, + EOAC_MUTUAL_AUTH = 0x1, + EOAC_CLOAKING = 0x10, + EOAC_SECURE_REFS = 0x2, + EOAC_ACCESS_CONTROL = 0x4, + EOAC_APPID = 0x8 +} EOLE_AUTHENTICATION_CAPABILITIES; + +/***************************************************************************** + * IClientSecurity interface + */ +DEFINE_GUID(IID_IClientSecurity, 0x0000013d, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IClientSecurity: IUnknown { + + virtual HRESULT CALLBACK QueryBlanket( + IUnknown* pProxy, + DWORD* pAuthnSvc, + DWORD* pAuthzSvc, + OLECHAR** pServerPrincName, + DWORD* pAuthnLevel, + DWORD* pImpLevel, + void** pAuthInfo, + DWORD* pCapabilites) = 0; + + virtual HRESULT CALLBACK SetBlanket( + IUnknown* pProxy, + DWORD AuthnSvc, + DWORD AuthzSvc, + OLECHAR* pServerPrincName, + DWORD AuthnLevel, + DWORD ImpLevel, + void* pAuthInfo, + DWORD Capabilities) = 0; + + virtual HRESULT CALLBACK CopyProxy( + IUnknown* pProxy, + IUnknown** ppCopy) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IClientSecurityVtbl IClientSecurityVtbl; +struct IClientSecurity { + const IClientSecurityVtbl* lpVtbl; +}; +struct IClientSecurityVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IClientSecurity* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IClientSecurity* This); + + ULONG (CALLBACK *Release)( + IClientSecurity* This); + + /*** IClientSecurity methods ***/ + HRESULT (CALLBACK *QueryBlanket)( + IClientSecurity* This, + IUnknown* pProxy, + DWORD* pAuthnSvc, + DWORD* pAuthzSvc, + OLECHAR** pServerPrincName, + DWORD* pAuthnLevel, + DWORD* pImpLevel, + void** pAuthInfo, + DWORD* pCapabilites); + + HRESULT (CALLBACK *SetBlanket)( + IClientSecurity* This, + IUnknown* pProxy, + DWORD AuthnSvc, + DWORD AuthzSvc, + OLECHAR* pServerPrincName, + DWORD AuthnLevel, + DWORD ImpLevel, + void* pAuthInfo, + DWORD Capabilities); + + HRESULT (CALLBACK *CopyProxy)( + IClientSecurity* This, + IUnknown* pProxy, + IUnknown** ppCopy); + +}; + +#define IClientSecurity_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD8 (HRESULT,QueryBlanket,IUnknown*,pProxy,DWORD*,pAuthnSvc,DWORD*,pAuthzSvc,OLECHAR**,pServerPrincName,DWORD*,pAuthnLevel,DWORD*,pImpLevel,void**,pAuthInfo,DWORD*,pCapabilites) \ + ICOM_METHOD8 (HRESULT,SetBlanket,IUnknown*,pProxy,DWORD,AuthnSvc,DWORD,AuthzSvc,OLECHAR*,pServerPrincName,DWORD,AuthnLevel,DWORD,ImpLevel,void*,pAuthInfo,DWORD,Capabilities) \ + ICOM_METHOD2 (HRESULT,CopyProxy,IUnknown*,pProxy,IUnknown**,ppCopy) + +/*** IUnknown methods ***/ +#define IClientSecurity_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IClientSecurity_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IClientSecurity_Release(p) (p)->lpVtbl->Release(p) +/*** IClientSecurity methods ***/ +#define IClientSecurity_QueryBlanket(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->QueryBlanket(p,a,b,c,d,e,f,g,h) +#define IClientSecurity_SetBlanket(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->SetBlanket(p,a,b,c,d,e,f,g,h) +#define IClientSecurity_CopyProxy(p,a,b) (p)->lpVtbl->CopyProxy(p,a,b) + +#endif + +HRESULT CALLBACK IClientSecurity_QueryBlanket_Proxy( + IClientSecurity* This, + IUnknown* pProxy, + DWORD* pAuthnSvc, + DWORD* pAuthzSvc, + OLECHAR** pServerPrincName, + DWORD* pAuthnLevel, + DWORD* pImpLevel, + void** pAuthInfo, + DWORD* pCapabilites); +void __RPC_STUB IClientSecurity_QueryBlanket_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IClientSecurity_SetBlanket_Proxy( + IClientSecurity* This, + IUnknown* pProxy, + DWORD AuthnSvc, + DWORD AuthzSvc, + OLECHAR* pServerPrincName, + DWORD AuthnLevel, + DWORD ImpLevel, + void* pAuthInfo, + DWORD Capabilities); +void __RPC_STUB IClientSecurity_SetBlanket_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IClientSecurity_CopyProxy_Proxy( + IClientSecurity* This, + IUnknown* pProxy, + IUnknown** ppCopy); +void __RPC_STUB IClientSecurity_CopyProxy_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IServerSecurity IServerSecurity; +/***************************************************************************** + * IServerSecurity interface + */ +DEFINE_GUID(IID_IServerSecurity, 0x0000013e, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IServerSecurity: IUnknown { + + virtual HRESULT CALLBACK QueryBlanket( + DWORD* pAuthnSvc, + DWORD* pAuthzSvc, + OLECHAR** pServerPrincName, + DWORD* pAuthnLevel, + DWORD* pImpLevel, + void** pPrivs, + DWORD* pCapabilities) = 0; + + virtual HRESULT CALLBACK ImpersonateClient( + ) = 0; + + virtual HRESULT CALLBACK RevertToSelf( + ) = 0; + + virtual BOOL CALLBACK IsImpersonating( + ) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IServerSecurityVtbl IServerSecurityVtbl; +struct IServerSecurity { + const IServerSecurityVtbl* lpVtbl; +}; +struct IServerSecurityVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IServerSecurity* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IServerSecurity* This); + + ULONG (CALLBACK *Release)( + IServerSecurity* This); + + /*** IServerSecurity methods ***/ + HRESULT (CALLBACK *QueryBlanket)( + IServerSecurity* This, + DWORD* pAuthnSvc, + DWORD* pAuthzSvc, + OLECHAR** pServerPrincName, + DWORD* pAuthnLevel, + DWORD* pImpLevel, + void** pPrivs, + DWORD* pCapabilities); + + HRESULT (CALLBACK *ImpersonateClient)( + IServerSecurity* This); + + HRESULT (CALLBACK *RevertToSelf)( + IServerSecurity* This); + + BOOL (CALLBACK *IsImpersonating)( + IServerSecurity* This); + +}; + +#define IServerSecurity_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD7 (HRESULT,QueryBlanket,DWORD*,pAuthnSvc,DWORD*,pAuthzSvc,OLECHAR**,pServerPrincName,DWORD*,pAuthnLevel,DWORD*,pImpLevel,void**,pPrivs,DWORD*,pCapabilities) \ + ICOM_METHOD (HRESULT,ImpersonateClient) \ + ICOM_METHOD (HRESULT,RevertToSelf) \ + ICOM_METHOD (BOOL,IsImpersonating) + +/*** IUnknown methods ***/ +#define IServerSecurity_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IServerSecurity_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IServerSecurity_Release(p) (p)->lpVtbl->Release(p) +/*** IServerSecurity methods ***/ +#define IServerSecurity_QueryBlanket(p,a,b,c,d,e,f,g) (p)->lpVtbl->QueryBlanket(p,a,b,c,d,e,f,g) +#define IServerSecurity_ImpersonateClient(p) (p)->lpVtbl->ImpersonateClient(p) +#define IServerSecurity_RevertToSelf(p) (p)->lpVtbl->RevertToSelf(p) +#define IServerSecurity_IsImpersonating(p) (p)->lpVtbl->IsImpersonating(p) + +#endif + +HRESULT CALLBACK IServerSecurity_QueryBlanket_Proxy( + IServerSecurity* This, + DWORD* pAuthnSvc, + DWORD* pAuthzSvc, + OLECHAR** pServerPrincName, + DWORD* pAuthnLevel, + DWORD* pImpLevel, + void** pPrivs, + DWORD* pCapabilities); +void __RPC_STUB IServerSecurity_QueryBlanket_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IServerSecurity_ImpersonateClient_Proxy( + IServerSecurity* This); +void __RPC_STUB IServerSecurity_ImpersonateClient_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IServerSecurity_RevertToSelf_Proxy( + IServerSecurity* This); +void __RPC_STUB IServerSecurity_RevertToSelf_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +BOOL CALLBACK IServerSecurity_IsImpersonating_Proxy( + IServerSecurity* This); +void __RPC_STUB IServerSecurity_IsImpersonating_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IAsyncSetup IAsyncSetup; +/***************************************************************************** + * IAsyncSetup interface + */ +DEFINE_GUID(IID_IAsyncSetup, 0x00000024, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IAsyncSetup: IUnknown { + + virtual HRESULT CALLBACK GetAsyncManager( + REFIID riid, + IUnknown* pOuter, + DWORD dwFlags, + IUnknown** ppInner, + IAsyncManager** ppAsyncMgr) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IAsyncSetupVtbl IAsyncSetupVtbl; +struct IAsyncSetup { + const IAsyncSetupVtbl* lpVtbl; +}; +struct IAsyncSetupVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IAsyncSetup* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IAsyncSetup* This); + + ULONG (CALLBACK *Release)( + IAsyncSetup* This); + + /*** IAsyncSetup methods ***/ + HRESULT (CALLBACK *GetAsyncManager)( + IAsyncSetup* This, + REFIID riid, + IUnknown* pOuter, + DWORD dwFlags, + IUnknown** ppInner, + IAsyncManager** ppAsyncMgr); + +}; + +#define IAsyncSetup_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD5 (HRESULT,GetAsyncManager,REFIID,riid,IUnknown*,pOuter,DWORD,dwFlags,IUnknown**,ppInner,IAsyncManager**,ppAsyncMgr) + +/*** IUnknown methods ***/ +#define IAsyncSetup_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IAsyncSetup_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IAsyncSetup_Release(p) (p)->lpVtbl->Release(p) +/*** IAsyncSetup methods ***/ +#define IAsyncSetup_GetAsyncManager(p,a,b,c,d,e) (p)->lpVtbl->GetAsyncManager(p,a,b,c,d,e) + +#endif + +HRESULT CALLBACK IAsyncSetup_GetAsyncManager_Proxy( + IAsyncSetup* This, + REFIID riid, + IUnknown* pOuter, + DWORD dwFlags, + IUnknown** ppInner, + IAsyncManager** ppAsyncMgr); +void __RPC_STUB IAsyncSetup_GetAsyncManager_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef enum tagDCOM_CALL_STATE { + DCOM_NONE = 0, + DCOM_CALL_COMPLETE = 1, + DCOM_CALL_CANCELED = 2 +} DCOM_CALL_STATE; + +/***************************************************************************** + * IAsyncManager interface + */ +DEFINE_GUID(IID_IAsyncManager, 0x0000002a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IAsyncManager: IUnknown { + + virtual HRESULT CALLBACK CompleteCall( + HRESULT Result) = 0; + + virtual HRESULT CALLBACK GetCallContext( + REFIID riid, + void** pInterface) = 0; + + virtual HRESULT CALLBACK GetState( + ULONG* pulStateFlags) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IAsyncManagerVtbl IAsyncManagerVtbl; +struct IAsyncManager { + const IAsyncManagerVtbl* lpVtbl; +}; +struct IAsyncManagerVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IAsyncManager* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IAsyncManager* This); + + ULONG (CALLBACK *Release)( + IAsyncManager* This); + + /*** IAsyncManager methods ***/ + HRESULT (CALLBACK *CompleteCall)( + IAsyncManager* This, + HRESULT Result); + + HRESULT (CALLBACK *GetCallContext)( + IAsyncManager* This, + REFIID riid, + void** pInterface); + + HRESULT (CALLBACK *GetState)( + IAsyncManager* This, + ULONG* pulStateFlags); + +}; + +#define IAsyncManager_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD1 (HRESULT,CompleteCall,HRESULT,Result) \ + ICOM_METHOD2 (HRESULT,GetCallContext,REFIID,riid,void**,pInterface) \ + ICOM_METHOD1 (HRESULT,GetState,ULONG*,pulStateFlags) + +/*** IUnknown methods ***/ +#define IAsyncManager_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IAsyncManager_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IAsyncManager_Release(p) (p)->lpVtbl->Release(p) +/*** IAsyncManager methods ***/ +#define IAsyncManager_CompleteCall(p,a) (p)->lpVtbl->CompleteCall(p,a) +#define IAsyncManager_GetCallContext(p,a,b) (p)->lpVtbl->GetCallContext(p,a,b) +#define IAsyncManager_GetState(p,a) (p)->lpVtbl->GetState(p,a) + +#endif + +HRESULT CALLBACK IAsyncManager_CompleteCall_Proxy( + IAsyncManager* This, + HRESULT Result); +void __RPC_STUB IAsyncManager_CompleteCall_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IAsyncManager_GetCallContext_Proxy( + IAsyncManager* This, + REFIID riid, + void** pInterface); +void __RPC_STUB IAsyncManager_GetCallContext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IAsyncManager_GetState_Proxy( + IAsyncManager* This, + ULONG* pulStateFlags); +void __RPC_STUB IAsyncManager_GetState_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#ifdef __cplusplus +} +#endif +#endif /* __WIDL_OBJIDL_H */ diff --git a/include/objidl.idl b/include/objidl.idl new file mode 100644 index 00000000000..b3d3917c223 --- /dev/null +++ b/include/objidl.idl @@ -0,0 +1,2400 @@ +/* + * Copyright 2002 Ove Kaaven + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +import "unknwn.idl"; + +interface IStream; +interface IStream16; +interface IEnumString; +interface IRunningObjectTable; +interface IMoniker; +interface IAdviseSink; +interface IAsyncManager; + +/* FIXME: COSERVERINFO should be moved here from wtypes.idl */ + +/******************** Fundamentals ********************/ + +[ + local, + object, + uuid(00000003-0000-0000-C000-000000000046) +] +interface IMarshal : IUnknown +{ + typedef [unique] IMarshal *LPMARSHAL; + + HRESULT GetUnmarshalClass( + [in] REFIID riid, + [in, unique] void *pv, + [in] DWORD dwDestContext, + [in, unique] void *pvDestContext, + [in] DWORD mshlflags, + [out] CLSID *pCid); + + HRESULT GetMarshalSizeMax( + [in] REFIID riid, + [in, unique] void *pv, + [in] DWORD dwDestContext, + [in, unique] void *pvDestContext, + [in] DWORD mshlflags, + [out] DWORD *pSize); + + HRESULT MarshalInterface( + [in, unique] IStream *pStm, + [in] REFIID riid, + [in, unique] void *pv, + [in] DWORD dwDestContext, + [in, unique] void *pvDestContext, + [in] DWORD mshlflags); + + HRESULT UnmarshalInterface( + [in, unique] IStream *pStm, + [in] REFIID riid, + [out] void **ppv); + + HRESULT ReleaseMarshalData( + [in, unique] IStream *pStm); + + HRESULT DisconnectObject( + [in] DWORD dwReserved); +} + +[ + local, + object, + uuid(00000018-0000-0000-C000-000000000046) +] +interface IStdMarshalInfo : IUnknown +{ + typedef [unique] IStdMarshalInfo *LPSTDMARSHALINFO; + + HRESULT GetClassForHandler( + [in] DWORD dwDestContext, + [in, unique] void *pvDestContext, + [out] CLSID *pClsid); +} + +[ + local, + object, + uuid(00000019-0000-0000-C000-000000000046) +] +interface IExternalConnection : IUnknown +{ + typedef [unique] IExternalConnection *LPEXTERNALCONNECTION; + + typedef enum tagEXTCONN { + EXTCONN_STRONG = 0x0001, + EXTCONN_WEAK = 0x0002, + EXTCONN_CALLABLE = 0x0004 + } EXTCONN; + + DWORD AddConnection( + [in] DWORD extconn, + [in] DWORD reserved); + + DWORD ReleaseConnection( + [in] DWORD extconn, + [in] DWORD reserved, + [in] BOOL fLastReleaseCloses); +} + +[ + local, + object, + uuid(00000020-0000-0000-C000-000000000046) +] +interface IMultiQI : IUnknown +{ + typedef [unique] IMultiQI *LPMULTIQI; + + typedef struct tagMULTI_QI { + const IID *pIID; + IUnknown *pItf; + HRESULT hr; + } MULTI_QI; + + HRESULT QueryMultipleInterfaces( + [in] ULONG cMQIs, + [in, out] MULTI_QI *pMQIs); +} + +[ + local, + object, + uuid(00000002-0000-0000-C000-000000000046) +] +interface IMalloc : IUnknown +{ + typedef [unique] IMalloc *LPMALLOC; + + LPVOID Alloc( + [in] ULONG cb); + + LPVOID Realloc( + [in] LPVOID pv, + [in] ULONG cb); + + void Free( + [in] LPVOID pv); + + ULONG GetSize( + [in] LPVOID pv); + + int DidAlloc(LPVOID pv); + + void HeapMinimize(); +} + +[ + local, + object, + uuid(0000001d-0000-0000-C000-000000000046) +] +interface IMallocSpy : IUnknown +{ + typedef [unique] IMallocSpy *LPMALLOCSPY; + + ULONG PreAlloc( + [in] ULONG cbRequest); + + LPVOID PostAlloc( + [in] LPVOID pActual); + + LPVOID PreFree( + [in] LPVOID pRequest, + [in] BOOL fSpyed); + + void PostFree( + [in] BOOL fSpyed); + + ULONG PreRealloc( + [in] LPVOID pRequest, + [in] ULONG cbRequest, + [out] LPVOID *ppNewRequest, + [in] BOOL fSpyed); + + LPVOID PostRealloc( + [in] LPVOID pActual, + [in] BOOL fSpyed); + + LPVOID PreGetSize( + [in] LPVOID pRequest, + [in] BOOL fSpyed); + + ULONG PostGetSize( + [in] ULONG cbActual, + [in] BOOL fSpyed); + + LPVOID PreDidAlloc( + [in] LPVOID pRequest, + [in] BOOL fSpyed); + + int PostDidAlloc( + [in] LPVOID pRequest, + [in] BOOL fSpyed, + [in] int fActual); + + void PreHeapMinimize(); + + void PostHeapMinimize(); +} + +[ + object, + uuid(00000100-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IEnumUnknown : IUnknown +{ + typedef [unique] IEnumUnknown *LPENUMUNKNOWN; + + [local] + HRESULT Next( + [in] ULONG celt, + [out] IUnknown **rgelt, + [out] ULONG *pceltFetched); + + [call_as(Next)] + HRESULT RemoteNext( + [in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] + IUnknown **rgelt, + [out] ULONG *pceltFetched); + + HRESULT Skip( + [in] ULONG celt); + + HRESULT Reset(); + + HRESULT Clone( + [out] IEnumUnknown **ppenum); +} + +[ + object, + uuid(00000022-0000-0000-C000-000000000046), + version(1.0), + pointer_default(unique) +] +interface ISurrogate : IUnknown +{ + typedef [unique] ISurrogate *LPSURROGATE; + + HRESULT LoadDllServer( + [in] REFCLSID Clsid); + HRESULT FreeSurrogate(); +} + +[ + local, + object, + uuid(00000146-0000-0000-C000-000000000046) +] +interface IGlobalInterfaceTable : IUnknown +{ + typedef [unique] IGlobalInterfaceTable *LPGLOBALINTERFACETABLE; + + HRESULT RegisterInterfaceInGlobal( + [in] IUnknown *pUnk, + [in] REFIID riid, + [out] DWORD *pdwCookie); + + HRESULT RevokeInterfaceFromGlobal( + [in] DWORD dwCookie); + + HRESULT GetInterfaceFromGlobal( + [in] DWORD dwCookie, + [in] REFIID riid, + [out, iid_is(riid)] void **ppv); +} + +/******************** Monikers ********************/ + +[ + object, + uuid(0000000e-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IBindCtx : IUnknown +{ + typedef [unique] IBindCtx *LPBINDCTX; + typedef [unique] IBindCtx *LPBC; + + typedef struct tagBIND_OPTS { + DWORD cbStruct; + DWORD grfFlags; + DWORD grfMode; + DWORD dwTickCountDeadline; + } BIND_OPTS, *LPBIND_OPTS; + + /* FIXME: C++ crap */ + typedef struct tagBIND_OPTS2 { + DWORD cbStruct; + DWORD grfFlags; + DWORD grfMode; + DWORD dwTickCountDeadline; + DWORD dwTrackFlags; + DWORD dwClassContext; + LCID locale; + COSERVERINFO *pServerInfo; + } BIND_OPTS2, *LPBIND_OPTS2; + + typedef enum tagBIND_FLAGS { + BIND_MAYBOTHERUSER = 1, + BIND_JUSTTESTEXISTENCE = 2 + } BIND_FLAGS; + + HRESULT RegisterObjectBound( + [in, unique] IUnknown *punk); + + HRESULT RevokeObjectBound( + [in, unique] IUnknown *punk); + + HRESULT ReleaseBoundObjects(); + + [local] + HRESULT SetBindOptions( + [in] BIND_OPTS *pbindopts); + + [call_as(SetBindOptions)] + HRESULT RemoteSetBindOptions( + [in] BIND_OPTS2 *pbindopts); + + [local] + HRESULT GetBindOptions( + [in, out] BIND_OPTS *pbindopts); + + [call_as(GetBindOptions)] + HRESULT RemoteGetBindOptions( + [in, out] BIND_OPTS2 *pbindopts); + + HRESULT GetRunningObjectTable( + [out] IRunningObjectTable **pprot); + + HRESULT RegisterObjectParam( + [in] LPOLESTR pszKey, + [in, unique] IUnknown *punk); + + HRESULT GetObjectParam( + [in] LPOLESTR pszKey, + [out] IUnknown **ppunk); + + HRESULT EnumObjectParam( + [out] IEnumString **ppenum); + + HRESULT RevokeObjectParam( + [in] LPOLESTR pszKey); +} + +[ + object, + uuid(00000102-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IEnumMoniker : IUnknown +{ + typedef [unique] IEnumMoniker *LPENUMMONIKER; + + [local] + HRESULT Next( + [in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] + IMoniker **rgelt, + [out] ULONG *pceltFetched); + + [call_as(Next)] + HRESULT RemoteNext( + [in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] + IMoniker **rgelt, + [out] ULONG *pceltFetched); + + HRESULT Skip( + [in] ULONG celt); + + HRESULT Reset(); + + HRESULT Clone( + [out] IEnumMoniker **ppenum); +} + +[ + object, + uuid(00000126-0000-0000-C000-000000000046) +] +interface IRunnableObject : IUnknown +{ + typedef [unique] IRunnableObject *LPRUNNABLEOBJECT; + + HRESULT GetRunningClass( + [out] LPCLSID lpClsid); + + HRESULT Run( + [in] LPBINDCTX pbc); + + [local] + BOOL IsRunning(); + + [call_as(IsRunning)] + HRESULT RemoteIsRunning(); + + HRESULT LockRunning( + [in] BOOL fLock, + [in] BOOL fLastUnlockCloses); + + HRESULT SetContainedObject( + [in] BOOL fContained); +} + +/* GetObject is defined in wingdi.h as WINELIB_NAME_AW(GetObject), + * which resolves to a compilation failure if __WINE__ is defined, + * but GetObject is used as a valid method name below, so we have + * to undefine it if __WINE__ is defined */ +cpp_quote("#ifdef __WINE__") +cpp_quote("#undef GetObject") +cpp_quote("#endif") + +[ + object, + uuid(00000010-0000-0000-C000-000000000046) +] +interface IRunningObjectTable : IUnknown +{ + typedef [unique] IRunningObjectTable *LPRUNNINGOBJECTTABLE; + + HRESULT Register( + [in] DWORD grfFlags, + [in, unique] IUnknown *punkObject, + [in, unique] IMoniker *pmkObjectName, + [out] DWORD *pdwRegister); + + HRESULT Revoke( + [in] DWORD dwRegister); + + HRESULT IsRunning( + [in, unique] IMoniker *pmkObjectName); + + HRESULT GetObject( + [in, unique] IMoniker *pmkObjectName, + [out] IUnknown **ppunkObject); + + HRESULT NoteChangeTime( + [in] DWORD dwRegister, + [in] FILETIME *pfiletime); + + HRESULT GetTimeOfLastChange( + [in, unique] IMoniker *pmkObjectName, + [out] FILETIME *pfiletime); + + HRESULT EnumRunning( + [out] IEnumMoniker **ppenumMoniker); +} + +[ + object, + uuid(0000010c-0000-0000-C000-000000000046) +] +interface IPersist : IUnknown +{ + typedef [unique] IPersist *LPPERSIST; + + HRESULT GetClassID( + [out] CLSID *pClassID); +} + +[ + object, + uuid(00000109-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IPersistStream : IPersist +{ + typedef [unique] IPersistStream *LPPERSISTSTREAM; + + HRESULT IsDirty(); + + HRESULT Load( + [in, unique] IStream *pStm); + + HRESULT Save( + [in, unique] IStream *pStm, + [in] BOOL fClearDirty); + + HRESULT GetSizeMax( + [out] ULARGE_INTEGER *pcbSize); +} + +[ + object, + uuid(0000000f-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IMoniker : IPersistStream +{ + typedef [unique] 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 [v1_enum] enum tagMKREDUCE { + MKRREDUCE_ONE = 3 << 16, + MKRREDUCE_TOUSER = 2 << 16, + MKRREDUCE_THROUGHUSER = 1 << 16, + MKRREDUCE_ALL = 0 + } MKRREDUCE; + + [local] + HRESULT BindToObject( + [in, unique] IBindCtx *pbc, + [in, unique] IMoniker *pmkToLeft, + [in] REFIID riidResult, + [out, iid_is(riidResult)] void **ppvResult); + + [call_as(BindToObject)] + HRESULT RemoteBindToObject( + [in, unique] IBindCtx *pbc, + [in, unique] IMoniker *pmkToLeft, + [in] REFIID riidResult, + [out, iid_is(riidResult)] IUnknown **ppvResult); + + [local] + HRESULT BindToStorage( + [in, unique] IBindCtx *pbc, + [in, unique] IMoniker *pmkToLeft, + [in] REFIID riid, + [out, iid_is(riid)] void **ppvObj); + + [call_as(BindToStorage)] + HRESULT RemoteBindToStorage( + [in, unique] IBindCtx *pbc, + [in, unique] IMoniker *pmkToLeft, + [in] REFIID riid, + [out, iid_is(riid)] IUnknown **ppvObj); + + HRESULT Reduce( + [in, unique] IBindCtx *pbc, + [in] DWORD dwReduceHowFar, + [in, out, unique] IMoniker **ppmkToLeft, + [out] IMoniker **ppmkReduced); + + HRESULT ComposeWith( + [in, unique] IMoniker *pmkRight, + [in] BOOL fOnlyIfNotGeneric, + [out] IMoniker **ppmkComposite); + + HRESULT Enum( + [in] BOOL fForward, + [out] IEnumMoniker **ppenumMoniker); + + HRESULT IsEqual( + [in, unique] IMoniker *pmkOtherMoniker); + + HRESULT Hash( + [out] DWORD *pdwHash); + + HRESULT IsRunning( + [in, unique] IBindCtx *pbc, + [in, unique] IMoniker *pmkToLeft, + [in, unique] IMoniker *pmkNewlyRunning); + + HRESULT GetTimeOfLastChange( + [in, unique] IBindCtx *pbc, + [in, unique] IMoniker *pmkToLeft, + [out] FILETIME *pFileTime); + + HRESULT Inverse( + [out] IMoniker **ppmk); + + HRESULT CommonPrefixWith( + [in, unique] IMoniker *pmkOther, + [out] IMoniker **ppmkPrefix); + + HRESULT RelativePathTo( + [in, unique] IMoniker *pmkOther, + [out] IMoniker **ppmkRelPath); + + HRESULT GetDisplayName( + [in, unique] IBindCtx *pbc, + [in, unique] IMoniker *pmkToLeft, + [out] LPOLESTR *ppszDisplayName); + + HRESULT ParseDisplayName( + [in, unique] IBindCtx *pbc, + [in, unique] IMoniker *pmkToLeft, + [in] LPOLESTR pszDisplayName, + [out] ULONG *pchEaten, + [out] IMoniker **ppmkOut); + + HRESULT IsSystemMoniker( + [out] DWORD *pdwMksys); +} + +[ + object, + uuid(f29f6bc0-5021-11ce-aa15-00006901293f), + pointer_default(unique) +] +interface IROTData : IUnknown +{ + HRESULT GetComparisonData( + [out, size_is(cbMax)] byte *pbData, + [in] ULONG cbMax, + [out] ULONG *pcbData); +} + +[ + object, + uuid(00000101-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IEnumString : IUnknown +{ + typedef [unique] IEnumString *LPENUMSTRING; + + [local] + HRESULT Next( + [in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] + LPOLESTR *rgelt, + [out] ULONG *pceltFetched); + + [call_as(Next)] + HRESULT RemoteNext( + [in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] + LPOLESTR *rgelt, + [out] ULONG *pceltFetched); + + HRESULT Skip( + [in] ULONG celt); + + HRESULT Reset(); + + HRESULT Clone( + [out] IEnumString **ppenum); +} + +[ + object, + uuid(00000140-0000-0000-C000-000000000046) +] +interface IClassActivator : IUnknown +{ + HRESULT GetClassObject( + [in] REFCLSID rclsid, + [in] DWORD dwClassContext, + [in] LCID locale, + [in] REFIID riid, + [out, iid_is(riid)] void **ppv); +} + +/******************** Storage ********************/ + +[ + object, + uuid(0c733a30-2a1c-11ce-ade5-00aa0044773d), + pointer_default(unique) +] +interface ISequentialStream : IUnknown +{ + [local] + HRESULT Read( + [out, size_is(cb), length_is(*pcbRead)] + void *pv, + [in] ULONG cb, + [out] ULONG *pcbRead); + + [call_as(Read)] + HRESULT RemoteRead( + [out, size_is(cb), length_is(*pcbRead)] + byte *pv, + [in] ULONG cb, + [out] ULONG *pcbRead); + + [local] + HRESULT Write( + [in, size_is(cb)] const void *pv, + [in] ULONG cb, + [out] ULONG *pcbWritten); + + [call_as(Write)] + HRESULT RemoteWrite( + [in, size_is(cb)] const byte *pv, + [in] ULONG cb, + [out] ULONG *pcbWritten); +} + +[ + object, + uuid(0000000c-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IStream : ISequentialStream +{ + typedef [unique] 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; + + /* these are defined in Linux's fcntl.h, + * undefine them to avoid conflicts */ + cpp_quote("#undef LOCK_MAND") + cpp_quote("#undef LOCK_READ") + cpp_quote("#undef LOCK_WRITE") + cpp_quote("#undef LOCK_RW") + + typedef enum tagLOCKTYPE { + LOCK_WRITE = 1, + LOCK_EXCLUSIVE = 2, + LOCK_ONLYONCE = 4 + } LOCKTYPE; + + [local] + HRESULT Seek( + [in] LARGE_INTEGER dlibMove, + [in] DWORD dwOrigin, + [out] ULARGE_INTEGER *plibNewPosition); + + [call_as(Seek)] + HRESULT RemoteSeek( + [in] LARGE_INTEGER dlibMove, + [in] DWORD dwOrigin, + [out] ULARGE_INTEGER *plibNewPosition); + + HRESULT SetSize( + [in] ULARGE_INTEGER libNewSize); + + [local] + HRESULT CopyTo( + [in, unique] IStream *pstm, + [in] ULARGE_INTEGER cb, + [out] ULARGE_INTEGER *pcbRead, + [out] ULARGE_INTEGER *pcbWritten); + + [call_as(CopyTo)] + HRESULT RemoteCopyTo( + [in, unique] IStream *pstm, + [in] ULARGE_INTEGER cb, + [out] ULARGE_INTEGER *pcbRead, + [out] ULARGE_INTEGER *pcbWritten); + + HRESULT Commit( + [in] DWORD grfCommitFlags); + + HRESULT Revert(); + + HRESULT LockRegion( + [in] ULARGE_INTEGER libOffset, + [in] ULARGE_INTEGER cb, + [in] DWORD dwLockType); + + HRESULT UnlockRegion( + [in] ULARGE_INTEGER libOffset, + [in] ULARGE_INTEGER cb, + [in] DWORD dwLockType); + + HRESULT Stat( + [out] STATSTG *pstatstg, + [in] DWORD grfStatFlag); + + HRESULT Clone( + [out] IStream **ppstm); +} + +[ + object, + pointer_default(unique) +] +interface IStream16 : ISequentialStream +{ + typedef [unique] IStream16 *LPSTREAM16; + + typedef struct tagSTATSTG16 { + LPOLESTR16 pwcsName; + DWORD type; + ULARGE_INTEGER cbSize; + FILETIME mtime; + FILETIME ctime; + FILETIME atime; + DWORD grfMode; + DWORD grfLocksSupported; + CLSID clsid; + DWORD grfStateBits; + DWORD reserved; + } STATSTG16; + + [local] + HRESULT Seek( + [in] LARGE_INTEGER dlibMove, + [in] DWORD dwOrigin, + [out] ULARGE_INTEGER *plibNewPosition); + + [call_as(Seek)] + HRESULT RemoteSeek( + [in] LARGE_INTEGER dlibMove, + [in] DWORD dwOrigin, + [out] ULARGE_INTEGER *plibNewPosition); + + HRESULT SetSize( + [in] ULARGE_INTEGER libNewSize); + + [local] + HRESULT CopyTo( + [in, unique] IStream16 *pstm, + [in] ULARGE_INTEGER cb, + [out] ULARGE_INTEGER *pcbRead, + [out] ULARGE_INTEGER *pcbWritten); + + [call_as(CopyTo)] + HRESULT RemoteCopyTo( + [in, unique] IStream16 *pstm, + [in] ULARGE_INTEGER cb, + [out] ULARGE_INTEGER *pcbRead, + [out] ULARGE_INTEGER *pcbWritten); + + HRESULT Commit( + [in] DWORD grfCommitFlags); + + HRESULT Revert(); + + HRESULT LockRegion( + [in] ULARGE_INTEGER libOffset, + [in] ULARGE_INTEGER cb, + [in] DWORD dwLockType); + + HRESULT UnlockRegion( + [in] ULARGE_INTEGER libOffset, + [in] ULARGE_INTEGER cb, + [in] DWORD dwLockType); + + HRESULT Stat( + [out] STATSTG *pstatstg, + [in] DWORD grfStatFlag); + + HRESULT Clone( + [out] IStream16 **ppstm); +} + +[ + object, + uuid(0000000d-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IEnumSTATSTG : IUnknown +{ + typedef [unique] IEnumSTATSTG *LPENUMSTATSTG; + + [local] + HRESULT Next( + [in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] + STATSTG *rgelt, + [out] ULONG *pceltFetched); + + [call_as(Next)] + HRESULT RemoteNext( + [in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] + STATSTG *rgelt, + [out] ULONG *pceltFetched); + + HRESULT Skip( + [in] ULONG celt); + + HRESULT Reset(); + + HRESULT Clone( + [out] IEnumSTATSTG **ppenum); +} + +[ + object, + uuid(0000000b-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IStorage : IUnknown +{ + typedef [unique] IStorage *LPSTORAGE; + + typedef struct tagRemSNB { + unsigned long ulCntStr; + unsigned long ulCntChar; + [size_is(ulCntChar)] OLECHAR rgString[]; + } RemSNB; + + typedef [unique] RemSNB *wireSNB; + typedef [wire_marshal(wireSNB)] OLECHAR **SNB; + + HRESULT CreateStream( + [in] LPCOLESTR pwcsName, + [in] DWORD grfMode, + [in] DWORD reserved1, + [in] DWORD reserved2, + [out] IStream **ppstm); + + [local] + HRESULT OpenStream( + [in] LPCOLESTR pwcsName, + [in, unique] void *reserved1, + [in] DWORD grfMode, + [in] DWORD reserved2, + [out] IStream **ppstm); + + [call_as(OpenStream)] + HRESULT RemoteOpenStream( + [in] LPCOLESTR pwcsName, + [in] unsigned long cbReserved1, + [in, unique, size_is(cbReserved1)] byte *reserved1, + [in] DWORD grfMode, + [in] DWORD reserved2, + [out] IStream **ppstm); + + HRESULT CreateStorage( + [in] LPCOLESTR pwcsName, + [in] DWORD grfMode, + [in] DWORD dwStgFmt, + [in] DWORD reserved2, + [out] IStorage **ppstg); + + HRESULT OpenStorage( + [in, unique] LPCOLESTR pwcsName, + [in, unique] IStorage *pstgPriority, + [in] DWORD grfMode, + [in, unique] SNB snbExclude, + [in] DWORD reserved, + [out] IStorage **ppstg); + + HRESULT CopyTo( + [in] DWORD ciidExclude, + [in, unique, size_is(ciidExclude)] const IID *rgiidExclude, + [in, unique] SNB snbExclude, + [in, unique] IStorage *pstgDest); + + HRESULT MoveElementTo( + [in] LPCOLESTR pwcsName, + [in, unique] IStorage *pstgDest, + [in] LPCOLESTR pwcsNewName, + [in] DWORD grfFlags); + + HRESULT Commit( + [in] DWORD grfCommitFlags); + + HRESULT Revert(); + + [local] + HRESULT EnumElements( + [in] DWORD reserved1, + [in, unique, size_is(1)] void *reserved2, + [in] DWORD reserved3, + [out] IEnumSTATSTG **ppenum); + + [call_as(EnumElements)] + HRESULT RemoteEnumElements( + [in] DWORD reserved1, + [in] unsigned long cbReserved2, + [in, unique, size_is(cbReserved2)] byte *reserved2, + [in] DWORD reserved3, + [out] IEnumSTATSTG **ppenum); + + HRESULT DestroyElement( + [in] LPCOLESTR pwcsName); + + HRESULT RenameElement( + [in] LPCOLESTR pwcsOldName, + [in] LPCOLESTR pwcsNewName); + + HRESULT SetElementTimes( + [in, unique] LPCOLESTR pwcsName, + [in, unique] const FILETIME *pctime, + [in, unique] const FILETIME *patime, + [in, unique] const FILETIME *pmtime); + + HRESULT SetClass( + [in] REFCLSID clsid); + + HRESULT SetStateBits( + [in] DWORD grfStateBits, + [in] DWORD grfMask); + + HRESULT Stat( + [out] STATSTG *pstatstg, + [in] DWORD grfStatFlag); +} + +[ + object, + pointer_default(unique) +] +interface IStorage16 : IUnknown +{ + typedef [unique] IStorage16 *LPSTORAGE16; + + typedef struct tagRemSNB16 { + unsigned long ulCntStr; + unsigned long ulCntChar; + [size_is(ulCntChar)] OLECHAR16 rgString[]; + } RemSNB16; + + typedef [unique] RemSNB16 *wireSNB16; + typedef [wire_marshal(wireSNB16)] OLECHAR16 **SNB16; + + HRESULT CreateStream( + [in] LPCOLESTR16 pwcsName, + [in] DWORD grfMode, + [in] DWORD reserved1, + [in] DWORD reserved2, + [out] IStream16 **ppstm); + + [local] + HRESULT OpenStream( + [in] LPCOLESTR16 pwcsName, + [in, unique] void *reserved1, + [in] DWORD grfMode, + [in] DWORD reserved2, + [out] IStream16 **ppstm); + + [call_as(OpenStream)] + HRESULT RemoteOpenStream( + [in] LPCOLESTR16 pwcsName, + [in] unsigned long cbReserved1, + [in, unique, size_is(cbReserved1)] byte *reserved1, + [in] DWORD grfMode, + [in] DWORD reserved2, + [out] IStream16 **ppstm); + + HRESULT CreateStorage( + [in] LPCOLESTR16 pwcsName, + [in] DWORD grfMode, + [in] DWORD dwStgFmt, + [in] DWORD reserved2, + [out] IStorage16 **ppstg); + + HRESULT OpenStorage( + [in, unique] LPCOLESTR16 pwcsName, + [in, unique] IStorage16 *pstgPriority, + [in] DWORD grfMode, + [in, unique] SNB16 snbExclude, + [in] DWORD reserved, + [out] IStorage16 **ppstg); + + HRESULT CopyTo( + [in] DWORD ciidExclude, + [in, unique, size_is(ciidExclude)] const IID *rgiidExclude, + [in, unique] SNB16 snbExclude, + [in, unique] IStorage16 *pstgDest); + + HRESULT MoveElementTo( + [in] LPCOLESTR16 pwcsName, + [in, unique] IStorage16 *pstgDest, + [in] LPCOLESTR16 pwcsNewName, + [in] DWORD grfFlags); + + HRESULT Commit( + [in] DWORD grfCommitFlags); + + HRESULT Revert(); + + [local] + HRESULT EnumElements( + [in] DWORD reserved1, + [in, unique, size_is(1)] void *reserved2, + [in] DWORD reserved3, + [out] IEnumSTATSTG **ppenum); + + [call_as(EnumElements)] + HRESULT RemoteEnumElements( + [in] DWORD reserved1, + [in] unsigned long cbReserved2, + [in, unique, size_is(cbReserved2)] byte *reserved2, + [in] DWORD reserved3, + [out] IEnumSTATSTG **ppenum); + + HRESULT DestroyElement( + [in] LPCOLESTR16 pwcsName); + + HRESULT RenameElement( + [in] LPCOLESTR16 pwcsOldName, + [in] LPCOLESTR16 pwcsNewName); + + HRESULT SetElementTimes( + [in, unique] LPCOLESTR16 pwcsName, + [in, unique] const FILETIME *pctime, + [in, unique] const FILETIME *patime, + [in, unique] const FILETIME *pmtime); + + HRESULT SetClass( + [in] REFCLSID clsid); + + HRESULT SetStateBits( + [in] DWORD grfStateBits, + [in] DWORD grfMask); + + HRESULT Stat( + [out] STATSTG *pstatstg, + [in] DWORD grfStatFlag); +} + +[ + object, + uuid(0000010b-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IPersistFile : IPersist +{ + typedef [unique] IPersistFile *LPPERSISTFILE; + + HRESULT IsDirty(); + + HRESULT Load( + [in] LPCOLESTR pszFileName, + [in] DWORD dwMode); + + HRESULT Save( + [in, unique] LPCOLESTR pszFileName, + [in] BOOL fRemember); + + HRESULT SaveCompleted( + [in, unique] LPCOLESTR pszFileName); + + HRESULT GetCurFile( + [out] LPOLESTR *ppszFileName); +} + +[ + object, + uuid(0000010a-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IPersistStorage : IPersist +{ + typedef [unique] IPersistStorage *LPPERSISTSTORAGE; + + HRESULT IsDirty(); + + HRESULT InitNew( + [in, unique] IStorage *pStg); + + HRESULT Load( + [in, unique] IStorage *pStg); + + HRESULT Save( + [in, unique] IStorage *pStgSave, + [in] BOOL fSameAsLoad); + + HRESULT SaveCompleted( + [in, unique] IStorage *pStgNew); + + HRESULT HandsOffStorage(); +} + +[ + object, + uuid(00000012-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IRootStorage : IUnknown +{ + typedef [unique] IRootStorage *LPROOTSTORAGE; + + HRESULT SwitchToFile( + [in] LPOLESTR pszFile); +} + +[ + object, + uuid(0000000a-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ILockBytes : IUnknown +{ + typedef [unique] ILockBytes *LPLOCKBYTES; + + [local] + HRESULT ReadAt( + [in] ULARGE_INTEGER ulOffset, + [out, size_is(cb), length_is(*pcbRead)] + void *pv, + [in] ULONG cb, + [out] ULONG *pcbRead); + + [call_as(ReadAt)] + HRESULT RemoteReadAt( + [in] ULARGE_INTEGER ulOffset, + [out, size_is(cb), length_is(*pcbRead)] + byte *pv, + [in] ULONG cb, + [out] ULONG *pcbRead); + + [local] + HRESULT WriteAt( + [in] ULARGE_INTEGER ulOffset, + [in, size_is(cb)] const void *pv, + [in] ULONG cb, + [out] ULONG *pcbWritten); + + [call_as(WriteAt)] + HRESULT RemoteWriteAt( + [in] ULARGE_INTEGER ulOffset, + [in, size_is(cb)] const byte *pv, + [in] ULONG cb, + [out] ULONG *pcbWritten); + + HRESULT Flush(); + + HRESULT SetSize( + [in] ULARGE_INTEGER cb); + + HRESULT LockRegion( + [in] ULARGE_INTEGER libOffset, + [in] ULARGE_INTEGER cb, + [in] DWORD dwLockType); + + HRESULT UnlockRegion( + [in] ULARGE_INTEGER libOffset, + [in] ULARGE_INTEGER cb, + [in] DWORD dwLockType); + + HRESULT Stat( + [out] STATSTG *pstatstg, + [in] DWORD grfStatFlag); +} + +[ + object, + uuid(99caf010-415e-11cf-8814-00aa00b569f5), + pointer_default(unique) +] +interface IFillLockBytes : IUnknown +{ + [local] + HRESULT FillAppend( + [in, size_is(cb)] const void *pv, + [in] ULONG cb, + [out] ULONG *pcbWritten); + + [call_as(FillAppend)] + HRESULT RemoteFillAppend( + [in, size_is(cb)] const byte *pv, + [in] ULONG cb, + [out] ULONG *pcbWritten); + + [local] + HRESULT FillAt( + [in] ULARGE_INTEGER ulOffset, + [in, size_is(cb)] const void *pv, + [in] ULONG cb, + [out] ULONG *pcbWritten); + + [call_as(FillAt)] + HRESULT RemoteFillAt( + [in] ULARGE_INTEGER ulOffset, + [in, size_is(cb)] const byte *pv, + [in] ULONG cb, + [out] ULONG *pcbWritten); + + HRESULT SetFillSize( + [in] ULARGE_INTEGER ulSize); + + HRESULT Terminate( + [in] BOOL bCanceled); +} + +[ + object, + uuid(a9d758a0-4617-11cf-95fc-00aa00680db4), + pointer_default(unique) +] +interface IProgressNotify : IUnknown +{ + HRESULT OnProgress( + [in] DWORD dwProgressCurrent, + [in] DWORD dwProgressMaximum, + [in] BOOL fAccurate, + [in] BOOL fOwner); +} + +[ + local, + object, + uuid(0e6d4d90-6738-11cf-9608-00aa00680db4), + pointer_default(unique) +] +interface ILayoutStorage : IUnknown +{ + typedef struct tagStorageLayout { + DWORD LayoutType; + OLECHAR *pwcsElementName; + LARGE_INTEGER cOffset; + LARGE_INTEGER cBytes; + } StorageLayout; + + HRESULT LayoutScript( + [in] StorageLayout *pStorageLayout, + [in] DWORD nEntries, + [in] DWORD glfInterleavedFlag); + + HRESULT BeginMonitor(); + + HRESULT EndMonitor(); + + HRESULT ReLayoutDocfile( + [in] OLECHAR *pwcsNewDfName); + + HRESULT ReLayoutDocfileOnILockBytes( + [in] ILockBytes *pILockBytes); +} + +/******************** Data Object ********************/ + +[ + object, + uuid(00000103-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IEnumFORMATETC : IUnknown +{ + typedef [unique] IEnumFORMATETC *LPENUMFORMATETC; + + typedef struct tagDVTARGETDEVICE { + DWORD tdSize; + WORD tdDriverNameOffset; + WORD tdDeviceNameOffset; + WORD tdPortNameOffset; + WORD tdExtDevmodeOffset; + [size_is(tdSize - sizeof(DWORD) - 4*sizeof(WORD))] + BYTE tdData[]; + } DVTARGETDEVICE; + + typedef CLIPFORMAT *LPCLIPFORMAT; + + typedef struct tagFORMATETC { + CLIPFORMAT cfFormat; + [unique] DVTARGETDEVICE *ptd; + DWORD dwAspect; + LONG lindex; + DWORD tymed; + } FORMATETC, *LPFORMATETC; + + [local] + HRESULT Next( + [in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] + FORMATETC *rgelt, + [out] ULONG *pceltFetched); + + [call_as(Next)] + HRESULT RemoteNext( + [in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] + FORMATETC *rgelt, + [out] ULONG *pceltFetched); + + HRESULT Skip( + [in] ULONG celt); + + HRESULT Reset(); + + HRESULT Clone( + [out] IEnumFORMATETC **ppenum); +} + +[ + object, + uuid(00000105-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IEnumSTATDATA : IUnknown +{ + typedef [unique] 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; + [unique] IAdviseSink *pAdvSink; + DWORD dwConnection; + } STATDATA, *LPSTATDATA; + + [local] + HRESULT Next( + [in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] + STATDATA *rgelt, + [out] ULONG *pceltFetched); + + [call_as(Next)] + HRESULT RemoteNext( + [in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] + STATDATA *rgelt, + [out] ULONG *pceltFetched); + + HRESULT Skip( + [in] ULONG celt); + + HRESULT Reset(); + + HRESULT Clone( + [out] IEnumSTATDATA **ppenum); +} + +[ + object, + uuid(0000010f-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IAdviseSink : IUnknown +{ + typedef IAdviseSink *LPADVISESINK; + + typedef [v1_enum] enum tagTYMED { + TYMED_HGLOBAL = 1, + TYMED_FILE = 2, + TYMED_ISTREAM = 4, + TYMED_ISTORAGE = 8, + TYMED_GDI = 16, + TYMED_MFPICT = 32, + TYMED_ENHMF = 64, + TYMED_NULL = 0 + } TYMED; + + typedef struct tagRemSTGMEDIUM { + DWORD tymed; + DWORD dwHandleType; + unsigned long pData; + unsigned long pUnkForRelease; + unsigned long cbData; + [size_is(cbData)] byte data[]; + } RemSTGMEDIUM; + + /* FIXME: C/C++ nameless union version */ + typedef struct tagSTGMEDIUM { + DWORD tymed; + [switch_is(tymed)] union { + [case(TYMED_GDI)] HBITMAP hBitmap; + [case(TYMED_MFPICT)] HMETAFILEPICT hMetaFilePict; + [case(TYMED_ENHMF)] HENHMETAFILE hEnhMetaFile; + [case(TYMED_HGLOBAL)] HGLOBAL hGlobal; + [case(TYMED_FILE)] LPOLESTR lpszFileName; + [case(TYMED_ISTREAM)] IStream *pstm; + [case(TYMED_ISTORAGE)] IStorage *pstg; + [default] ; + }; + [unique] IUnknown *pUnkForRelease; + } uSTGMEDIUM; + +/* copied from wingdi.h */ +#define OBJ_PEN 1 +#define OBJ_BRUSH 2 +#define OBJ_DC 3 +#define OBJ_METADC 4 +#define OBJ_PAL 5 +#define OBJ_FONT 6 +#define OBJ_BITMAP 7 +#define OBJ_REGION 8 +#define OBJ_METAFILE 9 +#define OBJ_MEMDC 10 +#define OBJ_EXTPEN 11 +#define OBJ_ENHMETADC 12 +#define OBJ_ENHMETAFILE 13 + + typedef union _GDI_OBJECT switch(DWORD ObjectType) u { + case OBJ_BITMAP: wireHBITMAP hBitmap; + case OBJ_PAL: wireHPALETTE hPalette; + default: wireHGLOBAL hGeneric; + } GDI_OBJECT; + + typedef struct _userSTGMEDIUM { + union _STGMEDIUM_UNION switch(DWORD tymed) u { + case TYMED_NULL: ; + case TYMED_MFPICT: wireHMETAFILEPICT hMetaFilePict; + case TYMED_ENHMF: wireHENHMETAFILE hHEnhMetaFile; + case TYMED_GDI: GDI_OBJECT *hGdiHandle; + case TYMED_HGLOBAL: wireHGLOBAL hGlobal; + case TYMED_FILE: LPOLESTR lpszFileName; + case TYMED_ISTREAM: BYTE_BLOB *pstm; + case TYMED_ISTORAGE: BYTE_BLOB *pstg; + }; + IUnknown *pUnkForRelease; + } userSTGMEDIUM; + + typedef [unique] userSTGMEDIUM *wireSTGMEDIUM; + typedef [wire_marshal(wireSTGMEDIUM)] uSTGMEDIUM STGMEDIUM; + + typedef [unique] userSTGMEDIUM *wireASYNC_STGMEDIUM; + typedef [wire_marshal(wireASYNC_STGMEDIUM)] STGMEDIUM ASYNC_STGMEDIUM; + + typedef STGMEDIUM *LPSTGMEDIUM; + + typedef struct _userFLAG_STGMEDIUM { + long ContextFlags; + long fPassOwnership; + userSTGMEDIUM Stgmed; + } userFLAG_STGMEDIUM; + + typedef [unique] userFLAG_STGMEDIUM *wireFLAG_STGMEDIUM; + + typedef [wire_marshal(wireFLAG_STGMEDIUM)] struct _FLAG_STGMEDIUM { + long ContextFlags; + long fPassOwnership; + STGMEDIUM Stgmed; + } FLAG_STGMEDIUM; + + [local] + void OnDataChange( + [in, unique] FORMATETC *pFormatetc, + [in, unique] STGMEDIUM *pStgmed); + + [call_as(OnDataChange), async] + HRESULT RemoteOnDataChange( + [in] IAsyncManager **ppIAM, + [in, unique] FORMATETC *pFormatetc, + [in, unique] ASYNC_STGMEDIUM *pStgmed); + + [local] + void OnViewChange( + [in] DWORD dwAspect, + [in] LONG lindex); + + [call_as(OnViewChange), async] + HRESULT RemoteOnViewChange( + [in] IAsyncManager **ppIAM, + [in] DWORD dwAspect, + [in] LONG lindex); + + [local] + void OnRename( + [in] IMoniker *pmk); + + [call_as(OnRename), async] + HRESULT RemoteOnRename( + [in] IAsyncManager **ppIAM, + [in] IMoniker *pmk); + + [local] + void OnSave(); + + [call_as(OnSave), async] + HRESULT RemoteOnSave( + [in] IAsyncManager **ppIAM); + + [local] + void OnClose(); + + [call_as(OnClose)] + HRESULT RemoteOnClose(); +} + +[ + object, + uuid(00000125-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IAdviseSink2 : IAdviseSink +{ + typedef [unique] IAdviseSink2 *LPADVISESINK2; + + [local] + void OnLinkSrcChange( + [in, unique] IMoniker *pmk); + + [call_as(OnLinkSrcChange), async] + HRESULT RemoteOnLinkSrcChange( + [in] IAsyncManager **ppIAM, + [in, unique] IMoniker *pmk); +} + +[ + object, + uuid(0000010e-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IDataObject : IUnknown +{ + typedef [unique] IDataObject *LPDATAOBJECT; + + typedef enum tagDATADIR { + DATADIR_GET = 1, + DATADIR_SET = 2 + } DATADIR; + + [local] + HRESULT GetData( + [in, unique] FORMATETC *pformatetcIn, + [out] STGMEDIUM *pmedium); + + [call_as(GetData)] + HRESULT RemoteGetData( + [in, unique] FORMATETC *pformatetcIn, + [out] STGMEDIUM *pRemoteMedium); + + [local] + HRESULT GetDataHere( + [in, unique] FORMATETC *pformatetc, + [in, out] STGMEDIUM *pmedium); + + [call_as(GetDataHere)] + HRESULT RemoteGetDataHere( + [in, unique] FORMATETC *pformatetc, + [in, out] STGMEDIUM *pRemoteMedium); + + HRESULT QueryGetData( + [in, unique] FORMATETC *pformatetc); + + HRESULT GetCanonicalFormatEtc( + [in, unique] FORMATETC *pformatectIn, + [out] FORMATETC *pformatetcOut); + + [local] + HRESULT SetData( + [in, unique] FORMATETC *pformatetc, + [in, unique] STGMEDIUM *pmedium, + [in] BOOL fRelease); + + [call_as(SetData)] + HRESULT RemoteSetData( + [in, unique] FORMATETC *pformatetc, + [in, unique] FLAG_STGMEDIUM *pmedium, + [in] BOOL fRelease); + + HRESULT EnumFormatEtc( + [in] DWORD dwDirection, + [out] IEnumFORMATETC **ppenumFormatEtc); + + HRESULT DAdvise( + [in] FORMATETC *pformatetc, + [in] DWORD advf, + [in, unique] IAdviseSink *pAdvSink, + [out] DWORD *pdwConnection); + + HRESULT DUnadvise( + [in] DWORD dwConnection); + + HRESULT EnumDAdvise( + [out] IEnumSTATDATA **ppenumAdvise); +} + +[ + local, + object, + uuid(00000110-0000-0000-C000-000000000046) +] +interface IDataAdviseHolder : IUnknown +{ + typedef [unique] IDataAdviseHolder *LPDATAADVISEHOLDER; + + HRESULT Advise( + [in, unique] IDataObject *pDataObject, + [in, unique] FORMATETC *pFetc, + [in] DWORD advf, + [in, unique] IAdviseSink *pAdvise, + [out] DWORD *pdwConnection); + + HRESULT Unadvise( + [in] DWORD dwConnection); + + HRESULT EnumAdvise( + [out] IEnumSTATDATA **ppenumAdvise); + + HRESULT SendOnDataChange( + [in, unique] IDataObject *pDataObject, + [in] DWORD dwReserved, + [in] DWORD advf); +} + +/******************** Remoting ********************/ + +[ + local, + object, + uuid(00000016-0000-0000-C000-000000000046) +] +interface IMessageFilter : IUnknown +{ + typedef [unique] IMessageFilter *LPMESSAGEFILTER; + + typedef enum tagCALLTYPE { + CALLTYPE_TOPLEVEL = 1, + CALLTYPE_NESTED = 2, + CALLTYPE_ASYNC = 3, + CALLTYPE_TOPLEVEL_CALLPENDING = 4, + CALLTYPE_ASYNC_CALLPENDING = 5 + } CALLTYPE; + + typedef enum tagSERVERCALL { + SERVERCALL_ISHANDLED = 0, + SERVERCALL_REJECTED = 1, + SERVERCALL_RETRYLATER = 2 + } SERVERCALL; + + typedef enum tagPENDINGTYPE { + PENDINGTYPE_TOPLEVEL = 1, + PENDINGTYPE_NESTED = 2 + } PENDINGTYPE; + + typedef enum tagPENDINGMSG { + PENDINGMSG_CANCELCALL = 0, + PENDINGMSG_WAITNOPROCESS = 1, + PENDINGMSG_WAITDEFPROCESS = 2 + } PENDINGMSG; + + typedef struct tagINTERFACEINFO { + IUnknown *pUnk; + IID iid; + WORD wMethod; + } INTERFACEINFO, *LPINTERFACEINFO; + + DWORD HandleInComingCall( + [in] DWORD dwCallType, + [in] HTASK htaskCaller, + [in] DWORD dwTickCount, + [in] LPINTERFACEINFO lpInterfaceInfo); + + DWORD RetryRejectedCall( + [in] HTASK htaskCallee, + [in] DWORD dwTickCount, + [in] DWORD dwRejectType); + + DWORD MessagePending( + [in] HTASK htaskCallee, + [in] DWORD dwTickCount, + [in] DWORD dwPendingType); +} + +[ + local, + object, + uuid(D5F56B60-593B-101A-B569-08002B2DBF7A) +] +interface IRpcChannelBuffer : IUnknown +{ + typedef [unique] IRpcChannelBuffer *LPRPCCHANNELBUFFER; + + typedef unsigned long RPCOLEDATAREP; + + typedef struct tagRPCOLEMESSAGE { + void *reserved1; + RPCOLEDATAREP dataRepresentation; + void *Buffer; + ULONG cbBuffer; + ULONG iMethod; + void *reserved2[5]; + ULONG rpcFlags; + } RPCOLEMESSAGE; + + typedef RPCOLEMESSAGE *PRPCOLEMESSAGE; + + HRESULT GetBuffer( + [in] RPCOLEMESSAGE *pMessage, + [in] REFIID riid); + + HRESULT SendReceive( + [in,out] RPCOLEMESSAGE *pMessage, + [out] ULONG *pStatus); + + HRESULT FreeBuffer( + [in] RPCOLEMESSAGE *pMessage); + + HRESULT GetDestCtx( + [out] DWORD *pdwDestContext, + [out] void **ppvDestContext); + + HRESULT IsConnected(); +} + +[ + local, + object, + uuid(594f31d0-7f19-11d0-b194-00a0c90dc8bf) +] +interface IRpcChannelBuffer2 : IRpcChannelBuffer +{ + typedef [unique] IRpcChannelBuffer2 *LPRPCCHANNELBUFFER2; + + HRESULT GetProtocolVersion( + [in,out] DWORD *pdwVersion); +} + +[ + local, + object, + uuid(25B15600-0115-11d0-BF0D-00AA00B8DFD2) +] +interface IRpcChannelBuffer3 : IRpcChannelBuffer2 +{ + typedef [unique] IRpcChannelBuffer3 *LPRPCCHANNELBUFFER3; + + HRESULT Send( + [in,out] RPCOLEMESSAGE *pMsg, + [out] ULONG *pulStatus); + + HRESULT Receive( + [in,out] RPCOLEMESSAGE *pMsg, + [in] ULONG ulSize, + [out] ULONG *pulStatus); + + HRESULT Cancel( + [in] RPCOLEMESSAGE *pMsg); + + HRESULT GetCallContext( + [in] RPCOLEMESSAGE *pMsg, + [in] REFIID riid, + [out] void **pInterface); + + HRESULT GetDestCtxEx( + [in] RPCOLEMESSAGE *pMsg, + [out] DWORD *pdwDestContext, + [out] void **ppvDestContext); + + HRESULT GetState( + [in] RPCOLEMESSAGE *pMsg, + [out] DWORD *pState); + + HRESULT RegisterAsync( + [in] RPCOLEMESSAGE *pMsg, + [in] IAsyncManager *pAsyncMgr); +} + +[ + local, + object, + uuid(D5F56A34-593B-101A-B569-08002B2DBF7A) +] +interface IRpcProxyBuffer : IUnknown +{ + typedef [unique] IRpcProxyBuffer *LPRPCPROXYBUFFER; + + HRESULT Connect( + [in, unique] IRpcChannelBuffer *pRpcChannelBuffer); + + void Disconnect(); +} + +[ + local, + object, + uuid(D5F56AFC-593B-101A-B569-08002B2DBF7A) +] +interface IRpcStubBuffer : IUnknown +{ + typedef [unique] IRpcStubBuffer *LPRPCSTUBBUFFER; + + HRESULT Connect( + [in] IUnknown *pUnkServer); + + void Disconnect(); + + HRESULT Invoke( + [in] RPCOLEMESSAGE *_prpcmsg, + [in] IRpcChannelBuffer *_pRpcChannelBuffer); + + IRpcStubBuffer *IsIIDSupported( + [in] REFIID riid); + + ULONG CountRefs(); + + HRESULT DebugServerQueryInterface( + void **ppv); + + void DebugServerRelease( + void *pv); +} + +[ + local, + object, + uuid(D5F569D0-593B-101A-B569-08002B2DBF7A) +] +interface IPSFactoryBuffer : IUnknown +{ + typedef [unique] IPSFactoryBuffer *LPPSFACTORYBUFFER; + + HRESULT CreateProxy( + [in] IUnknown *pUnkOuter, + [in] REFIID riid, + [out] IRpcProxyBuffer **ppProxy, + [out] void **ppv); + + HRESULT CreateStub( + [in] REFIID riid, + [in, unique] IUnknown *pUnkServer, + [out] IRpcStubBuffer **ppStub); +} + +[ + local, + object, + uuid(1008c4a0-7613-11cf-9af1-0020af6e72f4) +] +interface IChannelHook : IUnknown +{ + typedef [unique] IChannelHook *LPCHANNELHOOK; + + typedef struct SChannelHookCallInfo { + IID iid; + DWORD cbSize; + GUID uCausality; + DWORD dwServerPid; + DWORD iMethod; + void *pObject; + } SChannelHookCallInfo; + + void ClientGetSize( + [in] REFGUID uExtent, + [in] REFIID riid, + [out] ULONG *pDataSize); + + void ClientFillBuffer( + [in] REFGUID uExtent, + [in] REFIID riid, + [in, out] ULONG *pDataSize, + [in] void *pDataBuffer); + + void ClientNotify( + [in] REFGUID uExtent, + [in] REFIID riid, + [in] ULONG cbDataSize, + [in] void *pDataBuffer, + [in] DWORD lDataRep, + [in] HRESULT hrFault); + + void ServerNotify( + [in] REFGUID uExtent, + [in] REFIID riid, + [in] ULONG cbDataSize, + [in] void *pDataBuffer, + [in] DWORD lDataRep); + + void ServerGetSize( + [in] REFGUID uExtent, + [in] REFIID riid, + [in] HRESULT hrFault, + [out] ULONG *pDataSize); + + void ServerFillBuffer( + [in] REFGUID uExtent, + [in] REFIID riid, + [in, out] ULONG *pDataSize, + [in] void *pDataBuffer, + [in] HRESULT hrFault ); +} + +/******************** Property Storage ********************/ + +interface IEnumSTATPROPSTG; +interface IEnumSTATPROPSETSTG; + +[ + object, + uuid(00000138-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IPropertyStorage : IUnknown +{ + typedef [unique] IPropertyStorage *LPPROPERTYSTORAGE; + + extern const FMTID FMTID_SummaryInformation; + extern const FMTID FMTID_DocSummaryInformation; + extern const FMTID FMTID_UserDefinedProperties; + + const DWORD PROPSETFLAG_DEFAULT = 0; + const DWORD PROPSETFLAG_NONSIMPLE = 1; + const DWORD PROPSETFLAG_ANSI = 2; + const DWORD PROPSETFLAG_UNBUFFERED = 4; + + typedef struct tagPROPVARIANT PROPVARIANT; + + #define TYPEDEF_CA(type, name) \ + typedef struct tag##name { \ + ULONG cElems; \ + [size_is(cElems)] \ + type *pElems; \ + } name + + TYPEDEF_CA(unsigned char, CAUB); + TYPEDEF_CA(short, CAI); + TYPEDEF_CA(USHORT, CAUI); + TYPEDEF_CA(long, CAL); + TYPEDEF_CA(ULONG, CAUL); + TYPEDEF_CA(float, CAFLT); + TYPEDEF_CA(double, CADBL); + TYPEDEF_CA(CY, CACY); + TYPEDEF_CA(DATE, CADATE); + TYPEDEF_CA(BSTR, CABSTR); + TYPEDEF_CA(BSTRBLOB, CABSTRBLOB); + TYPEDEF_CA(VARIANT_BOOL, CABOOL); + TYPEDEF_CA(SCODE, CASCODE); + TYPEDEF_CA(PROPVARIANT, CAPROPVARIANT); + TYPEDEF_CA(LARGE_INTEGER, CAH); + TYPEDEF_CA(ULARGE_INTEGER, CAUH); + TYPEDEF_CA(LPSTR, CALPSTR); + TYPEDEF_CA(LPWSTR, CALPWSTR); + TYPEDEF_CA(FILETIME, CAFILETIME); + TYPEDEF_CA(CLIPDATA, CACLIPDATA); + TYPEDEF_CA(CLSID, CACLSID); + + struct tagPROPVARIANT { + VARTYPE vt; + WORD wReserved1; + WORD wReserved2; + WORD wReserved3; + [switch_is(vt & 0x1fff)] union { + [case(VT_EMPTY, VT_NULL)] ; + [case(VT_UI1)] UCHAR bVal; + [case(VT_I2)] short iVal; + [case(VT_UI2)] USHORT uiVal; + [case(VT_BOOL)] VARIANT_BOOL boolVal; +#if 0 /* illegal in C++ */ + [case(VT_ILLEGAL)] _VARIANT_BOOL bool; +#endif + [case(VT_I4)] long lVal; + [case(VT_UI4)] ULONG ulVal; + [case(VT_R4)] float fltVal; + [case(VT_ERROR)] SCODE scode; + [case(VT_I8)] LARGE_INTEGER hVal; + [case(VT_UI8)] ULARGE_INTEGER uhVal; + [case(VT_R8)] double dblVal; + [case(VT_CY)] CY cyVal; + [case(VT_DATE)] DATE date; + [case(VT_FILETIME)] FILETIME filetime; + [case(VT_CLSID)] CLSID *puuid; + [case(VT_BLOB, VT_BLOB_OBJECT)] BLOB blob; + [case(VT_CF)] CLIPDATA *pclipdata; + [case(VT_STREAM, VT_STREAMED_OBJECT)] IStream *pStream; + [case(VT_STORAGE, VT_STORED_OBJECT)] IStorage *pStorage; + [case(VT_BSTR)] BSTR bstrVal; + [case(VT_BSTR_BLOB)] BSTRBLOB bstrblobVal; + [case(VT_LPSTR)] LPSTR pszVal; + [case(VT_LPWSTR)] LPWSTR pwszVal; + [case(VT_UI1|VT_VECTOR)] CAUB caub; + [case(VT_I2|VT_VECTOR)] CAI cai; + [case(VT_UI2|VT_VECTOR)] CAUI caui; + [case(VT_BOOL|VT_VECTOR)] CABOOL cabool; + [case(VT_I4|VT_VECTOR)] CAL cal; + [case(VT_UI4|VT_VECTOR)] CAUL caul; + [case(VT_R4|VT_VECTOR)] CAFLT caflt; + [case(VT_ERROR|VT_VECTOR)] CASCODE cascode; + [case(VT_I8|VT_VECTOR)] CAH cah; + [case(VT_UI8|VT_VECTOR)] CAUH cauh; + [case(VT_R8|VT_VECTOR)] CADBL cadbl; + [case(VT_CY|VT_VECTOR)] CACY cacy; + [case(VT_DATE|VT_VECTOR)] CADATE cadate; + [case(VT_FILETIME|VT_VECTOR)] CAFILETIME cafiletime; + [case(VT_CLSID|VT_VECTOR)] CACLSID cauuid; + [case(VT_CF|VT_VECTOR)] CACLIPDATA caclipdata; + [case(VT_BSTR|VT_VECTOR)] CABSTR cabstr; + [case(VT_BSTR_BLOB|VT_VECTOR)] CABSTRBLOB cabstrblob; + [case(VT_LPSTR|VT_VECTOR)] CALPSTR calpstr; + [case(VT_LPWSTR|VT_VECTOR)] CALPWSTR calpwstr; + [case(VT_VARIANT|VT_VECTOR)] CAPROPVARIANT capropvar; + }; + }; + + typedef struct tagPROPVARIANT *LPPROPVARIANT; + + /* FIXME: bunches of property IDs */ + + const ULONG PRSPEC_INVALID = 0xffffffff; + const ULONG PRSPEC_LPWSTR = 0; + const ULONG PRSPEC_PROPID = 1; + + typedef struct tagPROPSPEC { + ULONG ulKind; + [switch_is(ulKind)] union { + [case(PRSPEC_PROPID)] PROPID propid; + [case(PRSPEC_LPWSTR)] LPOLESTR lpwstr; + [default] ; + }; + } PROPSPEC; + + typedef struct tagSTATPROPSTG { + LPOLESTR lpwstrName; + PROPID propid; + VARTYPE vt; + } STATPROPSTG; + + /* FIXME: macros */ + + typedef struct tagSTATPROPSETSTG { + FMTID fmtid; + CLSID clsid; + DWORD grfFlags; + FILETIME mtime; + FILETIME ctime; + FILETIME atime; + DWORD dwOSVersion; + } STATPROPSETSTG; + + HRESULT ReadMultiple( + [in] ULONG cpspec, + [in, size_is(cpspec)] const PROPSPEC rgpspec[], + [out, size_is(cpspec)] PROPVARIANT rgpropvar[]); + + HRESULT WriteMultiple( + [in] ULONG cpspec, + [in, size_is(cpspec)] const PROPSPEC rgpspec[], + [in, size_is(cpspec)] const PROPVARIANT rgpropvar[], + [in] PROPID propidNameFirst); + + HRESULT DeleteMultiple( + [in] ULONG cpspec, + [in, size_is(cpspec)] const PROPSPEC rgpspec[]); + + HRESULT ReadPropertyNames( + [in] ULONG cpropid, + [in, size_is(cpropid)] const PROPID rgpropid[], + [out, size_is(cpropid)] LPOLESTR rglpwstrName[]); + + HRESULT WritePropertyNames( + [in] ULONG cpropid, + [in, size_is(cpropid)] const PROPID rgpropid[], + [in, size_is(cpropid)] const LPOLESTR rglpwstrName[]); + + HRESULT DeletePropertyNames( + [in] ULONG cpropid, + [in, size_is(cpropid)] const PROPID rgpropid[]); + + HRESULT Commit( + [in] DWORD grfCommitFlags); + + HRESULT Revert(); + + HRESULT Enum( + [out] IEnumSTATPROPSTG **ppenum); + + HRESULT SetTimes( + [in] const FILETIME *pctime, + [in] const FILETIME *patime, + [in] const FILETIME *pmtime); + + HRESULT SetClass( + [in] REFCLSID clsid); + + HRESULT Stat( + [out] STATPROPSETSTG *statpsstg); +} + +[ + object, + uuid(0000013A-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IPropertySetStorage : IUnknown +{ + typedef [unique] IPropertySetStorage *LPPROPERTYSETSTORAGE; + + HRESULT Create( + [in] REFFMTID rfmtid, + [in, unique] const CLSID *pclsid, + [in] DWORD grfFlags, + [in] DWORD grfMode, + [out] IPropertyStorage **ppprstg); + + HRESULT Open( + [in] REFFMTID rfmtid, + [in] DWORD grfMode, + [out] IPropertyStorage **ppprstg); + + HRESULT Delete( + [in] REFFMTID rfmtid); + + HRESULT Enum( + [out] IEnumSTATPROPSETSTG **ppenum); +} + +[ + object, + uuid(00000139-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IEnumSTATPROPSTG : IUnknown +{ + typedef [unique] IEnumSTATPROPSTG *LPENUMSTATPROPSTG; + + [local] + HRESULT Next( + [in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] + STATPROPSTG *rgelt, + [out] ULONG *pceltFetched); + + [call_as(Next)] + HRESULT RemoteNext( + [in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] + STATPROPSTG *rgelt, + [out] ULONG *pceltFetched); + + HRESULT Skip( + [in] ULONG celt); + + HRESULT Reset(); + + HRESULT Clone( + [out] IEnumSTATPROPSTG **ppenum); +} + +[ + object, + uuid(0000013B-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IEnumSTATPROPSETSTG : IUnknown +{ + typedef [unique] IEnumSTATPROPSETSTG *LPENUMSTATPROPSETSTG; + + [local] + HRESULT Next( + [in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] + STATPROPSETSTG *rgelt, + [out] ULONG *pceltFetched); + + [call_as(Next)] + HRESULT RemoteNext( + [in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] + STATPROPSETSTG *rgelt, + [out] ULONG *pceltFetched); + + HRESULT Skip( + [in] ULONG celt); + + HRESULT Reset(); + + HRESULT Clone( + [out] IEnumSTATPROPSETSTG **ppenum); +} + +/******************** Connection Points ********************/ +/* FIXME */ + +/******************** DCOM ********************/ + +[ + local, + object, + uuid(0000013D-0000-0000-C000-000000000046) +] +interface IClientSecurity : IUnknown +{ + typedef struct tagSOLE_AUTHENTICATION_SERVICE { + DWORD dwAuthnSvc; + DWORD dwAuthzSvc; + OLECHAR *pPrincipalName; + HRESULT hr; + } SOLE_AUTHENTICATION_SERVICE; + + typedef SOLE_AUTHENTICATION_SERVICE *PSOLE_AUTHENTICATION_SERVICE; + + typedef enum tagEOLE_AUTHENTICATION_CAPABILITIES { + EOAC_NONE = 0x0, + EOAC_MUTUAL_AUTH = 0x1, + EOAC_CLOAKING = 0x10, + EOAC_SECURE_REFS = 0x2, + EOAC_ACCESS_CONTROL = 0x4, + EOAC_APPID = 0x8 + } EOLE_AUTHENTICATION_CAPABILITIES; + + HRESULT QueryBlanket( + [in] IUnknown *pProxy, + [out] DWORD *pAuthnSvc, + [out] DWORD *pAuthzSvc, + [out] OLECHAR **pServerPrincName, + [out] DWORD *pAuthnLevel, + [out] DWORD *pImpLevel, + [out] void **pAuthInfo, + [out] DWORD *pCapabilites); + + HRESULT SetBlanket( + [in] IUnknown *pProxy, + [in] DWORD AuthnSvc, + [in] DWORD AuthzSvc, + [in] OLECHAR *pServerPrincName, + [in] DWORD AuthnLevel, + [in] DWORD ImpLevel, + [in] void *pAuthInfo, + [in] DWORD Capabilities); + + HRESULT CopyProxy( + [in] IUnknown *pProxy, + [out] IUnknown **ppCopy); +} + +[ + local, + object, + uuid(0000013E-0000-0000-C000-000000000046) +] +interface IServerSecurity : IUnknown +{ + HRESULT QueryBlanket( + [out] DWORD *pAuthnSvc, + [out] DWORD *pAuthzSvc, + [out] OLECHAR **pServerPrincName, + [out] DWORD *pAuthnLevel, + [out] DWORD *pImpLevel, + [out] void **pPrivs, + [out] DWORD *pCapabilities); + + HRESULT ImpersonateClient(); + + HRESULT RevertToSelf(); + + BOOL IsImpersonating(); +} + +[ + local, + object, + uuid(00000024-0000-0000-C000-000000000046) +] +interface IAsyncSetup : IUnknown +{ + HRESULT GetAsyncManager( + [in] REFIID riid, + [in] IUnknown *pOuter, + [in] DWORD dwFlags, + [out] IUnknown **ppInner, + [out] IAsyncManager **ppAsyncMgr); +} + +[ + local, + object, + uuid(0000002A-0000-0000-C000-000000000046) +] +interface IAsyncManager : IUnknown +{ + typedef enum tagDCOM_CALL_STATE { + DCOM_NONE = 0, + DCOM_CALL_COMPLETE = 1, + DCOM_CALL_CANCELED = 2 + } DCOM_CALL_STATE; + + HRESULT CompleteCall( + [in] HRESULT Result); + HRESULT GetCallContext( + [in] REFIID riid, + [out] void **pInterface); + HRESULT GetState( + [out] ULONG *pulStateFlags); +} diff --git a/include/wine/obj_channel.h b/include/wine/obj_channel.h deleted file mode 100644 index 56f2357a7d5..00000000000 --- a/include/wine/obj_channel.h +++ /dev/null @@ -1,201 +0,0 @@ -/* - * Defines undocumented Microsoft COM interfaces and APIs seemingly - * related to some 'channel' notion. - * - * Copyright (C) 1999 Francois Gouget - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __WINE_WINE_OBJ_CHANNEL_H -#define __WINE_WINE_OBJ_CHANNEL_H - -#ifdef __cplusplus -extern "C" { -#endif /* defined(__cplusplus) */ - -/***************************************************************************** - * Predeclare the interfaces - */ -DEFINE_GUID (IID_IChannelHook, 0x1008c4a0L, 0x7613, 0x11cf, 0x9a, 0xf1, 0x00, 0x20, 0xaf, 0x6e, 0x72, 0xf4); -typedef struct IChannelHook IChannelHook,*LPCHANNELHOOK; - -DEFINE_GUID (IID_IPSFactoryBuffer, 0xd5f569d0L, 0x593b, 0x101a, 0xb5, 0x69, 0x08, 0x00, 0x2b, 0x2d, 0xbf, 0x7a); -typedef struct IPSFactoryBuffer IPSFactoryBuffer,*LPPSFACTORYBUFFER; - -DEFINE_GUID (IID_IRpcChannelBuffer, 0xd5f56b60L, 0x593b, 0x101a, 0xb5, 0x69, 0x08, 0x00, 0x2b, 0x2d, 0xbf, 0x7a); -typedef struct IRpcChannelBuffer IRpcChannelBuffer,*LPRPCCHANNELBUFFER; - -DEFINE_GUID (IID_IRpcProxyBuffer, 0xd5f56a34L, 0x593b, 0x101a, 0xb5, 0x69, 0x08, 0x00, 0x2b, 0x2d, 0xbf, 0x7a); -typedef struct IRpcProxyBuffer IRpcProxyBuffer,*LPRPCPROXYBUFFER; - -DEFINE_GUID (IID_IRpcStubBuffer, 0xd5f56afcL, 0x593b, 0x101a, 0xb5, 0x69, 0x08, 0x00, 0x2b, 0x2d, 0xbf, 0x7a); -typedef struct IRpcStubBuffer IRpcStubBuffer,*LPRPCSTUBBUFFER; - - -DEFINE_GUID (CLSID_PSFactoryBuffer, 0x00000320L, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46); - - -/***************************************************************************** - * IChannelHook interface - */ -#define ICOM_INTERFACE IChannelHook -#define IChannelHook_METHODS \ - ICOM_VMETHOD3(ClientGetSize, REFGUID,uExtent, REFIID,riid, ULONG*,pDataSize) \ - ICOM_VMETHOD4(ClientFillBuffer, REFGUID,uExtent, REFIID,riid, ULONG*,pDataSize, void*,pDataBuffer) \ - ICOM_VMETHOD6(ClientNotify, REFGUID,uExtent, REFIID,riid, ULONG,cbDataSize, void*,pDataBuffer, DWORD,lDataRep, HRESULT,hrFault) \ - ICOM_VMETHOD5(ServerNotify, REFGUID,uExtent, REFIID,riid, ULONG,cbDataSize, void*,pDataBuffer, DWORD,lDataRep) \ - ICOM_VMETHOD4(ServerGetSize, REFGUID,uExtent, REFIID,riid, HRESULT,hrFault, ULONG*,pDataSize) \ - ICOM_VMETHOD5(ServerFillBuffer, REFGUID,uExtent, REFIID,riid, ULONG*,pDataSize, void*,pDataBuffer, HRESULT,hrFault) -#define IChannelHook_IMETHODS \ - IUnknown_IMETHODS \ - IChannelHook_METHODS -ICOM_DEFINE(IChannelHook,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IChannelHook_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IChannelHook_AddRef(p) ICOM_CALL (AddRef,p) -#define IChannelHook_Release(p) ICOM_CALL (Release,p) -/*** IChannelHook methods ***/ -#define IChannelHook_ClientGetSize(p,a,b,c) ICOM_CALL(ClientGetSize,p,a,b,c) -#define IChannelHook_ClientFillBuffer(p,a,b,c,d) ICOM_CALL(ClientFillBuffer,p,a,b,c,d) -#define IChannelHook_ClientNotify(p,a,b,c,d,e,f) ICOM_CALL(ClientNotify,p,a,b,c,d,e,f) -#define IChannelHook_ServerNotify(p,a,b,c,d,e) ICOM_CALL(ServerNotify,p,a,b,c,d,e) -#define IChannelHook_ServerGetSize(p,a,b,c,d) ICOM_CALL(ServerGetSize,p,a,b,c,d) -#define IChannelHook_ServerFillBuffer(p,a,b,c,d,e) ICOM_CALL(ServerFillBuffer,p,a,b,c,d,e) - - -/***************************************************************************** - * IPSFactoryBuffer interface - */ -#define ICOM_INTERFACE IPSFactoryBuffer -#define IPSFactoryBuffer_METHODS \ - ICOM_METHOD4(HRESULT,CreateProxy, IUnknown*,pUnkOuter, REFIID,riid, IRpcProxyBuffer**,ppProxy, void**,ppv) \ - ICOM_METHOD3(HRESULT,CreateStub, REFIID,riid, IUnknown*,pUnkServer, IRpcStubBuffer**,ppStub) -#define IPSFactoryBuffer_IMETHODS \ - IUnknown_IMETHODS \ - IPSFactoryBuffer_METHODS -ICOM_DEFINE(IPSFactoryBuffer,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IPSFactoryBuffer_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IPSFactoryBuffer_AddRef(p) ICOM_CALL (AddRef,p) -#define IPSFactoryBuffer_Release(p) ICOM_CALL (Release,p) -/*** IPSFactoryBuffer methods ***/ -#define IPSFactoryBuffer_CreateProxy(p,a,b,c,d) ICOM_CALL4(CreateProxy,p,a,b,c,d) -#define IPSFactoryBuffer_CreateStub(p,a,b,c) ICOM_CALL3(CreateStub,p,a,b,c) - - -/***************************************************************************** - * IRpcChannelBuffer interface - */ -typedef unsigned long RPCOLEDATAREP; - -typedef struct tagRPCOLEMESSAGE -{ - void* reserved1; - RPCOLEDATAREP dataRepresentation; - void* Buffer; - ULONG cbBuffer; - ULONG iMethod; - void* reserved2[5]; - ULONG rpcFlags; -} RPCOLEMESSAGE, *PRPCOLEMESSAGE; - -#define ICOM_INTERFACE IRpcChannelBuffer -#define IRpcChannelBuffer_METHODS \ - ICOM_METHOD2(HRESULT,GetBuffer, RPCOLEMESSAGE*,pMessage, REFIID,riid) \ - ICOM_METHOD2(HRESULT,SendReceive, RPCOLEMESSAGE*,pMessage, ULONG*,pStatus) \ - ICOM_METHOD1(HRESULT,FreeBuffer, RPCOLEMESSAGE*,pMessage) \ - ICOM_METHOD2(HRESULT,GetDestCtx, DWORD*,pdwDestContext, void**,ppvDestContext) \ - ICOM_METHOD (HRESULT,IsConnected) -#define IRpcChannelBuffer_IMETHODS \ - IUnknown_IMETHODS \ - IRpcChannelBuffer_METHODS -ICOM_DEFINE(IRpcChannelBuffer,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IRpcChannelBuffer_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IRpcChannelBuffer_AddRef(p) ICOM_CALL (AddRef,p) -#define IRpcChannelBuffer_Release(p) ICOM_CALL (Release,p) -/*** IRpcChannelBuffer methods ***/ -#define IRpcChannelBuffer_GetBuffer(p,a,b) ICOM_CALL2(GetBuffer,p,a,b) -#define IRpcChannelBuffer_SendReceive(p,a,b) ICOM_CALL2(SendReceive,p,a,b) -#define IRpcChannelBuffer_FreeBuffer(p,a) ICOM_CALL1(FreeBuffer,p,a) -#define IRpcChannelBuffer_GetDestCtx(p,a,b) ICOM_CALL2(GetDestCtx,p,a,b) -#define IRpcChannelBuffer_IsConnected(p) ICOM_CALL (IsConnected,p) - - -/***************************************************************************** - * IRpcProxyBuffer interface - */ -#define ICOM_INTERFACE IRpcProxyBuffer -#define IRpcProxyBuffer_METHODS \ - ICOM_METHOD1(HRESULT,Connect, IRpcChannelBuffer*,pRpcChannelBuffer) \ - ICOM_VMETHOD( Disconnect) -#define IRpcProxyBuffer_IMETHODS \ - IUnknown_IMETHODS \ - IRpcProxyBuffer_METHODS -ICOM_DEFINE(IRpcProxyBuffer,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IRpcProxyBuffer_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IRpcProxyBuffer_AddRef(p) ICOM_CALL (AddRef,p) -#define IRpcProxyBuffer_Release(p) ICOM_CALL (Release,p) -/*** IRpcProxyBuffer methods ***/ -#define IRpcProxyBuffer_Connect(p,a) ICOM_CALL1(Connect,p,a) -#define IRpcProxyBuffer_Disconnect(p) ICOM_CALL (Disconnect,p) - - -/***************************************************************************** - * IRpcStubBuffer interface - */ -#define ICOM_INTERFACE IRpcStubBuffer -#define IRpcStubBuffer_METHODS \ - ICOM_METHOD1 (HRESULT, Connect, IUnknown*,pUnkServer) \ - ICOM_VMETHOD ( Disconnect) \ - ICOM_METHOD2 (HRESULT, Invoke, RPCOLEMESSAGE*,_prpcmsg, IRpcChannelBuffer*,_pRpcChannelBuffer) \ - ICOM_METHOD1 (LPRPCSTUBBUFFER,IsIIDSupported, REFIID,riid) \ - ICOM_METHOD (ULONG, CountRefs) \ - ICOM_METHOD1 (HRESULT, DebugServerQueryInterface, void**,ppv) \ - ICOM_VMETHOD1( DebugServerRelease, void*,pv) -#define IRpcStubBuffer_IMETHODS \ - IUnknown_IMETHODS \ - IRpcStubBuffer_METHODS -ICOM_DEFINE(IRpcStubBuffer,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IRpcStubBuffer_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IRpcStubBuffer_AddRef(p) ICOM_CALL (AddRef,p) -#define IRpcStubBuffer_Release(p) ICOM_CALL (Release,p) -/*** IRpcStubBuffer methods ***/ -#define IRpcStubBuffer_Connect(p,a) ICOM_CALL1(Connect,p,a) -#define IRpcStubBuffer_Disconnect(p) ICOM_CALL (Disconnect,p) -#define IRpcStubBuffer_Invoke(p,a,b) ICOM_CALL2(Invoke,p,a,b) -#define IRpcStubBuffer_IsIIDSupported(p,a) ICOM_CALL1(IsIIDSupported,p,a) -#define IRpcStubBuffer_CountRefs(p) ICOM_CALL (CountRefs,p) -#define IRpcStubBuffer_DebugServerQueryInterface(p,a) ICOM_CALL1(DebugServerQueryInterface,p,a) -#define IRpcStubBuffer_DebugServerRelease(p,a) ICOM_CALL1(DebugServerRelease,p,a) - -#ifdef __cplusplus -} /* extern "C" */ -#endif /* defined(__cplusplus) */ - -#endif /* __WINE_WINE_OBJ_CHANNEL_H */ diff --git a/include/wine/obj_clientserver.h b/include/wine/obj_clientserver.h deleted file mode 100644 index 24f5db16331..00000000000 --- a/include/wine/obj_clientserver.h +++ /dev/null @@ -1,210 +0,0 @@ -/* - * Defines the COM interfaces and APIs related to client/server aspects. - * - * Copyright (C) the Wine project - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __WINE_WINE_OBJ_CLIENTSERVER_H -#define __WINE_WINE_OBJ_CLIENTSERVER_H - -#ifdef __cplusplus -extern "C" { -#endif /* defined(__cplusplus) */ - -/***************************************************************************** - * Predeclare the interfaces - */ -DEFINE_OLEGUID(IID_IClientSecurity, 0x0000013dL, 0, 0); -typedef struct IClientSecurity IClientSecurity,*LPCLIENTSECURITY; - -DEFINE_OLEGUID(IID_IExternalConnection, 0x00000019L, 0, 0); -typedef struct IExternalConnection IExternalConnection,*LPEXTERNALCONNECTION; - -DEFINE_OLEGUID(IID_IMessageFilter, 0x00000016L, 0, 0); -typedef struct IMessageFilter IMessageFilter,*LPMESSAGEFILTER; - -DEFINE_OLEGUID(IID_IServerSecurity, 0x0000013eL, 0, 0); -typedef struct IServerSecurity IServerSecurity,*LPSERVERSECURITY; - - -/***************************************************************************** - * IClientSecurity interface - */ -typedef struct tagSOLE_AUTHENTICATION_SERVICE -{ - DWORD dwAuthnSvc; - DWORD dwAuthzSvc; - OLECHAR* pPrincipalName; - HRESULT hr; -} SOLE_AUTHENTICATION_SERVICE, *PSOLE_AUTHENTICATION_SERVICE; - -typedef enum tagEOLE_AUTHENTICATION_CAPABILITIES -{ - EOAC_NONE = 0x0, - EOAC_MUTUAL_AUTH = 0x1, - EOAC_SECURE_REFS = 0x2, - EOAC_ACCESS_CONTROL = 0x4 -} EOLE_AUTHENTICATION_CAPABILITIES; - -#define ICOM_INTERFACE IClientSecurity -#define IClientSecurity_METHODS \ - ICOM_METHOD8(HRESULT,QueryBlanket, IUnknown*,pProxy, DWORD*,pAuthnSvc, DWORD*,pAuthzSvc, OLECHAR**,pServerPrincName, DWORD*,pAuthnLevel, DWORD*,pImpLevel, void**,pAuthInfo, DWORD*,pCapabilites) \ - ICOM_METHOD8(HRESULT,SetBlanket, IUnknown*,pProxy, DWORD,pAuthnSvc, DWORD,pAuthzSvc, OLECHAR*,pServerPrincName, DWORD,pAuthnLevel, DWORD,pImpLevel, void*,pAuthInfo, DWORD,pCapabilites) \ - ICOM_METHOD2(HRESULT,CopyProxy, IUnknown*,pProxy, IUnknown**,ppCopy) -#define IClientSecurity_IMETHODS \ - IUnknown_IMETHODS \ - IClientSecurity_METHODS -ICOM_DEFINE(IClientSecurity,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IClientSecurity_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IClientSecurity_AddRef(p) ICOM_CALL (AddRef,p) -#define IClientSecurity_Release(p) ICOM_CALL (Release,p) -/*** IClientSecurity methods ***/ -#define IClientSecurity_QueryBlanket(p,a,b,c,d,e,f,g,h) ICOM_CALL8(QueryBlanket,p,a,b,c,d,e,f,g,h) -#define IClientSecurity_SetBlanket(p,a,b,c,d,e,f,g,h) ICOM_CALL8(SetBlanket,p,a,b,c,d,e,f,g,h) -#define IClientSecurity_CopyProxy(p,a,b) ICOM_CALL2(CopyProxy,p,a,b) - - -/***************************************************************************** - * IExternalConnection interface - */ -typedef enum tagEXTCONN -{ - EXTCONN_STRONG = 0x1, - EXTCONN_WEAK = 0x2, - EXTCONN_CALLABLE = 0x4 -} EXTCONN; - -#define ICOM_INTERFACE IExternalConnection -#define IExternalConnection_METHODS \ - ICOM_METHOD2(DWORD,AddConnection, DWORD,extconn, DWORD,reserved) \ - ICOM_METHOD3(DWORD,ReleaseConnection, DWORD,extconn, DWORD,reserved, BOOL,fLastReleaseCloses) -#define IExternalConnection_IMETHODS \ - IUnknown_IMETHODS \ - IExternalConnection_METHODS -ICOM_DEFINE(IExternalConnection,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IExternalConnection_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IExternalConnection_AddRef(p) ICOM_CALL (AddRef,p) -#define IExternalConnection_Release(p) ICOM_CALL (Release,p) -/*** IExternalConnection methods ***/ -#define IExternalConnection_AddConnection(p,a,b) ICOM_CALL8(AddConnection,p,a,b) -#define IExternalConnection_ReleaseConnection(p,a,b,c) ICOM_CALL8(ReleaseConnection,p,a,b,c) - - -HRESULT WINAPI CoDisconnectObject(LPUNKNOWN lpUnk, DWORD reserved); - - -/***************************************************************************** - * IMessageFilter interface - */ -typedef enum tagCALLTYPE -{ - CALLTYPE_TOPLEVEL = 1, - CALLTYPE_NESTED = 2, - CALLTYPE_ASYNC = 3, - CALLTYPE_TOPLEVEL_CALLPENDING = 4, - CALLTYPE_ASYNC_CALLPENDING = 5 -} CALLTYPE; - -typedef enum tagSERVERCALL -{ - SERVERCALL_ISHANDLED = 0, - SERVERCALL_REJECTED = 1, - SERVERCALL_RETRYLATER = 2 -} SERVERCALL; - -typedef enum tagPENDINGTYPE -{ - PENDINGTYPE_TOPLEVEL = 1, - PENDINGTYPE_NESTED = 2 -} PENDINGTYPE; - -typedef enum tagPENDINGMSG -{ - PENDINGMSG_CANCELCALL = 0, - PENDINGMSG_WAITNOPROCESS = 1, - PENDINGMSG_WAITDEFPROCESS = 2 -} PENDINGMSG; - -typedef struct tagINTERFACEINFO -{ - IUnknown* pUnk; - IID iid; - WORD wMethod; -} INTERFACEINFO,*LPINTERFACEINFO; - -#define ICOM_INTERFACE IMessageFilter -#define IMessageFilter_METHODS \ - ICOM_METHOD4(DWORD,HandleInComingCall, DWORD,dwCallType, HTASK,htaskCaller, DWORD,dwTickCount, LPINTERFACEINFO,lpInterfaceInfo) \ - ICOM_METHOD3(DWORD,RetryRejectedCall, HTASK,htaskCallee, DWORD,dwTickCount, DWORD,dwRejectType) \ - ICOM_METHOD3(DWORD,MessagePending, HTASK,htaskCallee, DWORD,dwTickCount, DWORD,dwRejectType) -#define IMessageFilter_IMETHODS \ - IUnknown_IMETHODS \ - IMessageFilter_METHODS -ICOM_DEFINE(IMessageFilter,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IMessageFilter_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IMessageFilter_AddRef(p) ICOM_CALL (AddRef,p) -#define IMessageFilter_Release(p) ICOM_CALL (Release,p) -/*** IMessageFilter methods ***/ -#define IMessageFilter_HandleInComingCall(p,a,b,c,d) ICOM_CALL4(HandleInComingCall,p,a,b,c,d) -#define IMessageFilter_RetryRejectedCall(p,a,b,c) ICOM_CALL3(RetryRejectedCall,p,a,b,c) -#define IMessageFilter_MessagePending(p,a,b,c) ICOM_CALL3(MessagePending,p,a,b,c) - - -HRESULT WINAPI CoRegisterMessageFilter16(LPMESSAGEFILTER lpMessageFilter,LPMESSAGEFILTER *lplpMessageFilter); -HRESULT WINAPI CoRegisterMessageFilter(LPMESSAGEFILTER lpMessageFilter,LPMESSAGEFILTER *lplpMessageFilter); - - -/***************************************************************************** - * IServerSecurity interface - */ -#define ICOM_INTERFACE IServerSecurity -#define IServerSecurity_METHODS \ - ICOM_METHOD7(HRESULT,QueryBlanket, DWORD*,pAuthnSvc, DWORD*,pAuthzSvc, OLECHAR**,pServerPrincName, DWORD*,pAuthnLevel, DWORD*,pImpLevel, void**,pPrivs, DWORD*,pCapabilities) \ - ICOM_METHOD (HRESULT,ImpersonateClient) \ - ICOM_METHOD (HRESULT,RevertToSelf) \ - ICOM_METHOD (BOOL, IsImpersonating) -#define IServerSecurity_IMETHODS \ - IUnknown_IMETHODS \ - IServerSecurity_METHODS -ICOM_DEFINE(IServerSecurity,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IServerSecurity_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IServerSecurity_AddRef(p) ICOM_CALL (AddRef,p) -#define IServerSecurity_Release(p) ICOM_CALL (Release,p) -/*** IServerSecurity methods ***/ -#define IServerSecurity_QueryBlanket(p,a,b,c,d,e,f,g) ICOM_CALL7(QueryBlanket,p,a,b,c,d,e,f,g) -#define IServerSecurity_ImpersonateClient(p) ICOM_CALL (ImpersonateClient,p) -#define IServerSecurity_RevertToSelf(p) ICOM_CALL (RevertToSelf,p) -#define IServerSecurity_IsImpersonating(p) ICOM_CALL (IsImpersonating,p) - - -#ifdef __cplusplus -} /* extern "C" */ -#endif /* defined(__cplusplus) */ - -#endif /* __WINE_WINE_OBJ_CLIENTSERVER_H */ diff --git a/include/wine/obj_dataobject.h b/include/wine/obj_dataobject.h deleted file mode 100644 index 02cebc1dffd..00000000000 --- a/include/wine/obj_dataobject.h +++ /dev/null @@ -1,328 +0,0 @@ -/* - * Defines the COM interfaces and APIs related to IDataObject. - * - * Copyright (C) the Wine project - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __WINE_WINE_OBJ_DATAOBJECT_H -#define __WINE_WINE_OBJ_DATAOBJECT_H - -#ifdef __cplusplus -extern "C" { -#endif /* defined(__cplusplus) */ - -/***************************************************************************** - * Predeclare the structures - */ -typedef enum tagDATADIR -{ - DATADIR_GET = 1, - DATADIR_SET = 2 -} DATADIR; - -typedef struct DVTARGETDEVICE16 DVTARGETDEVICE16, *LPDVTARGETDEVICE16; -typedef struct DVTARGETDEVICE DVTARGETDEVICE, *LPDVTARGETDEVICE; - -typedef struct FORMATETC16 FORMATETC16, *LPFORMATETC16; -typedef struct FORMATETC FORMATETC, *LPFORMATETC; - -typedef struct STGMEDIUM STGMEDIUM, *LPSTGMEDIUM; - - -/***************************************************************************** - * Predeclare the interfaces - */ -DEFINE_OLEGUID(IID_IAdviseSink, 0x0000010fL, 0, 0); -typedef struct IAdviseSink IAdviseSink,*LPADVISESINK; - -DEFINE_OLEGUID(IID_IAdviseSink2, 0x00000125L, 0, 0); -typedef struct IAdviseSink2 IAdviseSink2,*LPADVISESINK2; - -DEFINE_OLEGUID(IID_IDataAdviseHolder, 0x00000110L, 0, 0); -typedef struct IDataAdviseHolder IDataAdviseHolder,*LPDATAADVISEHOLDER; - -DEFINE_OLEGUID(IID_IDataObject, 0x0000010EL, 0, 0); -typedef struct IDataObject IDataObject,*LPDATAOBJECT; - -DEFINE_OLEGUID(IID_IEnumFORMATETC, 0x00000103L, 0, 0); -typedef struct IEnumFORMATETC IEnumFORMATETC,*LPENUMFORMATETC; - -DEFINE_OLEGUID(IID_IEnumSTATDATA, 0x00000105L, 0, 0); -typedef struct IEnumSTATDATA IEnumSTATDATA,*LPENUMSTATDATA; - - -/***************************************************************************** - * DVTARGETDEVICE structure - */ -struct DVTARGETDEVICE -{ - DWORD tdSize; - WORD tdDriverNameOffset; - WORD tdDeviceNameOffset; - WORD tdPortNameOffset; - WORD tdExtDevmodeOffset; - BYTE tdData[1]; -}; - - -/***************************************************************************** - * FORMATETC structure - */ -/* wished data format */ -struct FORMATETC -{ - CLIPFORMAT cfFormat; - DVTARGETDEVICE* ptd; - DWORD dwAspect; - LONG lindex; - DWORD tymed; -}; - - -/***************************************************************************** - * STGMEDIUM structure - */ -typedef enum tagTYMED -{ - TYMED_HGLOBAL = 1, - TYMED_FILE = 2, - TYMED_ISTREAM = 4, - TYMED_ISTORAGE = 8, - TYMED_GDI = 16, - TYMED_MFPICT = 32, - TYMED_ENHMF = 64, - TYMED_NULL = 0 -} TYMED; - -typedef struct tagRemSTGMEDIUM -{ - DWORD tymed; - DWORD dwHandleType; - unsigned long pData; - unsigned long pUnkForRelease; - unsigned long cbData; - byte data[1]; -} RemSTGMEDIUM; - -/* dataobject as answer to a request */ -struct STGMEDIUM -{ - DWORD tymed; - union { - HBITMAP hBitmap; - HMETAFILEPICT hMetaFilePict; - HENHMETAFILE hEnhMetaFile; - HGLOBAL hGlobal; - LPOLESTR lpszFileName; - IStream *pstm; - IStorage *pstg; - } DUMMYUNIONNAME; - IUnknown *pUnkForRelease; -}; - -typedef enum tagADVF -{ - ADVF_NODATA = 1, - ADVF_PRIMEFIRST = 2, - ADVF_ONLYONCE = 4, - ADVF_DATAONSTOP = 64, - ADVFCACHE_NOHANDLER = 8, - ADVFCACHE_FORCEBUILTIN = 16, - ADVFCACHE_ONSAVE = 32 -} ADVF; - -typedef struct tagSTATDATA -{ - FORMATETC formatetc; - DWORD advf; - IAdviseSink *pAdvSink; - DWORD dwConnection; -} STATDATA, *LPSTATDATA; - -/***************************************************************************** - * IAdviseSink interface - */ -#define ICOM_INTERFACE IAdviseSink -#define IAdviseSink_METHODS \ - ICOM_VMETHOD2(OnDataChange, FORMATETC*,pFormatetc, STGMEDIUM*,pStgmed) \ - ICOM_VMETHOD2(OnViewChange, DWORD,dwAspect, LONG,lindex) \ - ICOM_VMETHOD1(OnRename, IMoniker*,pmk) \ - ICOM_VMETHOD (OnSave) \ - ICOM_VMETHOD (OnClose) -#define IAdviseSink_IMETHODS \ - IUnknown_IMETHODS \ - IAdviseSink_METHODS -ICOM_DEFINE(IAdviseSink,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IAdviseSink_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IAdviseSink_AddRef(p) ICOM_CALL (AddRef,p) -#define IAdviseSink_Release(p) ICOM_CALL (Release,p) -/*** IAdviseSink methods ***/ -#define IAdviseSink_OnDataChange(p,a,b) ICOM_CALL2(OnDataChange,p,a,b) -#define IAdviseSink_OnViewChange(p,a,b) ICOM_CALL2(OnViewChange,p,a,b) -#define IAdviseSink_OnRename(p,a) ICOM_CALL1(OnRename,p,a) -#define IAdviseSink_OnSave(p) ICOM_CALL (OnSave,p) -#define IAdviseSink_OnClose(p) ICOM_CALL (OnClose,p) - - -/***************************************************************************** - * IAdviseSink2 interface - */ -#define ICOM_INTERFACE IAdviseSink2 -#define IAdviseSink2_METHODS \ - ICOM_VMETHOD1(OnLinkSrcChange, IMoniker*,pmk) -#define IAdviseSink2_IMETHODS \ - IAdviseSink_IMETHODS \ - IAdviseSink2_METHODS -ICOM_DEFINE(IAdviseSink2,IAdviseSink) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IAdviseSink2_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IAdviseSink2_AddRef(p) ICOM_CALL (AddRef,p) -#define IAdviseSink2_Release(p) ICOM_CALL (Release,p) -/*** IAdviseSink methods ***/ -#define IAdviseSink2_OnDataChange(p,a,b) ICOM_CALL2(IAdviseSink,OnDataChange,p,a,b) -#define IAdviseSink2_OnViewChange(p,a,b) ICOM_CALL2(IAdviseSink,OnViewChange,p,a,b) -#define IAdviseSink2_OnRename(p,a) ICOM_CALL1(IAdviseSink,OnRename,p,a) -#define IAdviseSink2_OnSave(p) ICOM_CALL (IAdviseSink,OnSave,p) -#define IAdviseSink2_OnClose(p) ICOM_CALL (IAdviseSink,OnClose,p) -/*** IAdviseSink2 methods ***/ -#define IAdviseSink2_OnLinkSrcChange(p,a) ICOM_CALL(OnLinkSrcChange,p,a) - - -/***************************************************************************** - * IDataAdviseHolder interface - */ -#define ICOM_INTERFACE IDataAdviseHolder -#define IDataAdviseHolder_METHODS \ - ICOM_METHOD5(HRESULT,Advise, IDataObject*,pDataObject, FORMATETC*,pFetc, DWORD,advf, IAdviseSink*,pAdvise, DWORD*,pdwConnection) \ - ICOM_METHOD1(HRESULT,Unadvise, DWORD,dwConnection) \ - ICOM_METHOD1(HRESULT,EnumAdvise, IEnumSTATDATA**,ppenumAdvise) \ - ICOM_METHOD3(HRESULT,SendOnDataChange, IDataObject*,pDataObject, DWORD,dwReserved, DWORD,advf) -#define IDataAdviseHolder_IMETHODS \ - IUnknown_IMETHODS \ - IDataAdviseHolder_METHODS -ICOM_DEFINE(IDataAdviseHolder,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IDataAdviseHolder_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IDataAdviseHolder_AddRef(p) ICOM_CALL (AddRef,p) -#define IDataAdviseHolder_Release(p) ICOM_CALL (Release,p) -/*** IDataAdviseHolder methods ***/ -#define IDataAdviseHolder_Advise(p,a,b,c,d,e) ICOM_CALL5(Advise,p,a,b,c,d,e) -#define IDataAdviseHolder_Unadvise(p,a) ICOM_CALL1(Unadvise,p,a) -#define IDataAdviseHolder_EnumAdvise(p,a) ICOM_CALL1(EnumAdvise,p,a) -#define IDataAdviseHolder_SendOnDataChange(p,a,b,c) ICOM_CALL3(SendOnDataChange,p,a,b,c) - - -/***************************************************************************** - * IDataObject interface - */ -#define ICOM_INTERFACE IDataObject -#define IDataObject_METHODS \ - ICOM_METHOD2(HRESULT,GetData, LPFORMATETC,pformatetcIn, STGMEDIUM*,pmedium) \ - ICOM_METHOD2(HRESULT,GetDataHere, LPFORMATETC,pformatetc, STGMEDIUM*,pmedium) \ - ICOM_METHOD1(HRESULT,QueryGetData, LPFORMATETC,pformatetc) \ - ICOM_METHOD2(HRESULT,GetCanonicalFormatEtc, LPFORMATETC,pformatectIn, LPFORMATETC,pformatetcOut) \ - ICOM_METHOD3(HRESULT,SetData, LPFORMATETC,pformatetc, STGMEDIUM*,pmedium, BOOL,fRelease) \ - ICOM_METHOD2(HRESULT,EnumFormatEtc, DWORD,dwDirection, IEnumFORMATETC**,ppenumFormatEtc) \ - ICOM_METHOD4(HRESULT,DAdvise, FORMATETC*,pformatetc, DWORD,advf, IAdviseSink*,pAdvSink, DWORD*,pdwConnection) \ - ICOM_METHOD1(HRESULT,DUnadvise, DWORD,dwConnection) \ - ICOM_METHOD1(HRESULT,EnumDAdvise, IEnumSTATDATA**,ppenumAdvise) -#define IDataObject_IMETHODS \ - IUnknown_IMETHODS \ - IDataObject_METHODS -ICOM_DEFINE(IDataObject,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IDataObject_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IDataObject_AddRef(p) ICOM_CALL (AddRef,p) -#define IDataObject_Release(p) ICOM_CALL (Release,p) -/*** IDataObject methods ***/ -#define IDataObject_GetData(p,a,b) ICOM_CALL2(GetData,p,a,b) -#define IDataObject_GetDataHere(p,a,b) ICOM_CALL2(GetDataHere,p,a,b) -#define IDataObject_QueryGetData(p,a) ICOM_CALL1(QueryGetData,p,a) -#define IDataObject_GetCanonicalFormatEtc(p,a,b) ICOM_CALL2(GetCanonicalFormatEtc,p,a,b) -#define IDataObject_SetData(p,a,b,c) ICOM_CALL3(SetData,p,a,b,c) -#define IDataObject_EnumFormatEtc(p,a,b) ICOM_CALL2(EnumFormatEtc,p,a,b) -#define IDataObject_DAdvise(p,a,b,c,d) ICOM_CALL4(DAdvise,p,a,b,c,d) -#define IDataObject_DUnadvise(p,a) ICOM_CALL1(DUnadvise,p,a) -#define IDataObject_EnumDAdvise(p,a) ICOM_CALL1(EnumDAdvise,p,a) - - -/***************************************************************************** - * IEnumFORMATETC interface - */ -#define ICOM_INTERFACE IEnumFORMATETC -#define IEnumFORMATETC_METHODS \ - ICOM_METHOD3(HRESULT,Next, ULONG,celt, FORMATETC*,rgelt, ULONG*,pceltFethed) \ - ICOM_METHOD1(HRESULT,Skip, ULONG,celt) \ - ICOM_METHOD (HRESULT,Reset) \ - ICOM_METHOD1(HRESULT,Clone, IEnumFORMATETC**,ppenum) -#define IEnumFORMATETC_IMETHODS \ - IUnknown_IMETHODS \ - IEnumFORMATETC_METHODS -ICOM_DEFINE(IEnumFORMATETC,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IEnumFORMATETC_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IEnumFORMATETC_AddRef(p) ICOM_CALL (AddRef,p) -#define IEnumFORMATETC_Release(p) ICOM_CALL (Release,p) -/*** IEnumFORMATETC methods ***/ -#define IEnumFORMATETC_Next(p,a,b,c) ICOM_CALL3(Next,p,a,b,c) -#define IEnumFORMATETC_Skip(p,a) ICOM_CALL1(Skip,p,a) -#define IEnumFORMATETC_Reset(p) ICOM_CALL (Reset,p) -#define IEnumFORMATETC_Clone(p,a) ICOM_CALL1(Clone,p,a) - - -/***************************************************************************** - * IEnumSTATDATA interface - */ -#define ICOM_INTERFACE IEnumSTATDATA -#define IEnumSTATDATA_METHODS \ - ICOM_METHOD3(HRESULT,Next, ULONG,celt, STATDATA*,rgelt, ULONG*,pceltFethed) \ - ICOM_METHOD1(HRESULT,Skip, ULONG,celt) \ - ICOM_METHOD (HRESULT,Reset) \ - ICOM_METHOD1(HRESULT,Clone, IEnumSTATDATA**,ppenum) -#define IEnumSTATDATA_IMETHODS \ - IUnknown_IMETHODS \ - IEnumSTATDATA_METHODS -ICOM_DEFINE(IEnumSTATDATA,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IEnumSTATDATA_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IEnumSTATDATA_AddRef(p) ICOM_CALL (AddRef,p) -#define IEnumSTATDATA_Release(p) ICOM_CALL (Release,p) -/*** IEnumSTATDATA methods ***/ -#define IEnumSTATDATA_Next(p,a,b,c) ICOM_CALL3(Next,p,a,b,c) -#define IEnumSTATDATA_Skip(p,a) ICOM_CALL1(Skip,p,a) -#define IEnumSTATDATA_Reset(p) ICOM_CALL (Reset,p) -#define IEnumSTATDATA_Clone(p,a) ICOM_CALL1(Clone,p,a) - - -#ifdef __cplusplus -} /* extern "C" */ -#endif /* defined(__cplusplus) */ - -#endif /* __WINE_WINE_OBJ_DATAOBJECT_H */ diff --git a/include/wine/obj_marshal.h b/include/wine/obj_marshal.h deleted file mode 100644 index 4ede4e99bdc..00000000000 --- a/include/wine/obj_marshal.h +++ /dev/null @@ -1,95 +0,0 @@ -/* - * Defines the COM interfaces and APIs that allow an interface to - * specify a custom marshaling for its objects. - * - * Copyright (C) 1999 Francois Gouget - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __WINE_WINE_OBJ_MARSHAL_H -#define __WINE_WINE_OBJ_MARSHAL_H - -#ifdef __cplusplus -extern "C" { -#endif /* defined(__cplusplus) */ - -/***************************************************************************** - * Predeclare the interfaces - */ -DEFINE_OLEGUID(IID_IMarshal, 0x00000003L, 0, 0); -typedef struct IMarshal IMarshal,*LPMARSHAL; - -DEFINE_OLEGUID(IID_IStdMarshalInfo, 0x00000018L, 0, 0); -typedef struct IStdMarshalInfo IStdMarshalInfo,*LPSTDMARSHALINFO; - -DEFINE_OLEGUID(CLSID_DfMarshal, 0x0000030BL, 0, 0); - - -/***************************************************************************** - * IMarshal interface - */ -#define ICOM_INTERFACE IMarshal -#define IMarshal_METHODS \ - ICOM_METHOD6(HRESULT,GetUnmarshalClass, REFIID,riid, void*,pv, DWORD,dwDestContext, void*,pvDestContext, DWORD,mshlflags, CLSID*,pCid) \ - ICOM_METHOD6(HRESULT,GetMarshalSizeMax, REFIID,riid, void*,pv, DWORD,dwDestContext, void*,pvDestContext, DWORD,mshlflags, DWORD*,pSize) \ - ICOM_METHOD6(HRESULT,MarshalInterface, IStream*,pStm, REFIID,riid, void*,pv, DWORD,dwDestContext, void*,pvDestContext, DWORD,mshlflags) \ - ICOM_METHOD3(HRESULT,UnmarshalInterface, IStream*,pStm, REFIID,riid, void**,ppv) \ - ICOM_METHOD1(HRESULT,ReleaseMarshalData, IStream*,pStm) \ - ICOM_METHOD1(HRESULT,DisconnectObject, DWORD,dwReserved) -#define IMarshal_IMETHODS \ - IUnknown_IMETHODS \ - IMarshal_METHODS -ICOM_DEFINE(IMarshal,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IMarshal_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IMarshal_AddRef(p) ICOM_CALL (AddRef,p) -#define IMarshal_Release(p) ICOM_CALL (Release,p) -/*** IMarshal methods ***/ -#define IMarshal_GetUnmarshalClass(p,a,b,c,d,e,f) ICOM_CALL6(GetUnmarshalClass,p,a,b,c,d,e,f) -#define IMarshal_GetMarshalSizeMax(p,a,b,c,d,e,f) ICOM_CALL6(GetMarshalSizeMax,p,a,b,c,d,e,f) -#define IMarshal_MarshalInterface(p,a,b,c,d,e,f) ICOM_CALL6(MarshalInterface,p,a,b,c,d,e,f) -#define IMarshal_UnmarshalInterface(p,a,b,c) ICOM_CALL3(UnmarshalInterface,p,a,b,c) -#define IMarshal_ReleaseMarshalData(p,a) ICOM_CALL1(ReleaseMarshalData,p,a) -#define IMarshal_DisconnectObject(p,a) ICOM_CALL1(DisconnectObject,p,a) - - -/***************************************************************************** - * IStdMarshalInfo interface - */ -#define ICOM_INTERFACE IStdMarshalInfo -#define IStdMarshalInfo_METHODS \ - ICOM_METHOD3(HRESULT,GetClassForHandler, DWORD,dwDestContext, void*,pvDestContext, CLSID*,pClsid) -#define IStdMarshalInfo_IMETHODS \ - IUnknown_IMETHODS \ - IStdMarshalInfo_METHODS -ICOM_DEFINE(IStdMarshalInfo,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IStdMarshalInfo_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IStdMarshalInfo_AddRef(p) ICOM_CALL (AddRef,p) -#define IStdMarshalInfo_Release(p) ICOM_CALL (Release,p) -/*** IStdMarshalInfo methods ***/ -#define IStdMarshalInfo_GetClassForHandler(p,a,b,c) ICOM_CALL3(GetClassForHandler,p,a,b,c) - - -#ifdef __cplusplus -} /* extern "C" */ -#endif /* defined(__cplusplus) */ - -#endif /* __WINE_WINE_OBJ_MARSHAL_H */ diff --git a/include/wine/obj_misc.h b/include/wine/obj_misc.h deleted file mode 100644 index 3ef5ac4ab9d..00000000000 --- a/include/wine/obj_misc.h +++ /dev/null @@ -1,206 +0,0 @@ -/* - * Defines miscellaneous COM interfaces and APIs defined in objidl.h. - * These did not really fit into the other categories, whould have - * required their own specific category or are too rarely used to be - * put in 'obj_base.h'. - * - * Copyright (C) the Wine project - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __WINE_WINE_OBJ_MISC_H -#define __WINE_WINE_OBJ_MISC_H - -#ifdef __cplusplus -extern "C" { -#endif /* defined(__cplusplus) */ - -/***************************************************************************** - * Predeclare the interfaces - */ -DEFINE_OLEGUID(IID_IEnumString, 0x00000101L, 0, 0); -typedef struct IEnumString IEnumString,*LPENUMSTRING; - -DEFINE_OLEGUID(IID_IEnumUnknown, 0x00000100L, 0, 0); -typedef struct IEnumUnknown IEnumUnknown,*LPENUMUNKNOWN; - -DEFINE_OLEGUID(IID_IMalloc, 0x00000002L, 0, 0); -typedef struct IMalloc IMalloc,*LPMALLOC; - -DEFINE_OLEGUID(IID_IMallocSpy, 0x0000001dL, 0, 0); -typedef struct IMallocSpy IMallocSpy,*LPMALLOCSPY; - -DEFINE_OLEGUID(IID_IMultiQI, 0x00000020L, 0, 0); -typedef struct IMultiQI IMultiQI,*LPMULTIQI; - - -/***************************************************************************** - * IEnumString interface - */ -#define ICOM_INTERFACE IEnumString -#define IEnumString_METHODS \ - ICOM_METHOD3(HRESULT,Next, ULONG,celt, LPOLESTR*,rgelt, ULONG*,pceltFethed) \ - ICOM_METHOD1(HRESULT,Skip, ULONG,celt) \ - ICOM_METHOD (HRESULT,Reset) \ - ICOM_METHOD1(HRESULT, Clone, IEnumString**, ppenum) -#define IEnumString_IMETHODS \ - IUnknown_IMETHODS \ - IEnumString_METHODS -ICOM_DEFINE(IEnumString,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IEnumString_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IEnumString_AddRef(p) ICOM_CALL (AddRef,p) -#define IEnumString_Release(p) ICOM_CALL (Release,p) -/*** IEnumString methods ***/ -#define IEnumString_Next(p,a,b,c) ICOM_CALL3(Next,p,a,b,c) -#define IEnumString_Skip(p,a) ICOM_CALL1(Skip,p,a) -#define IEnumString_Reset(p) ICOM_CALL (Reset,p) -#define IEnumString_Clone(p,a) ICOM_CALL1(Clone,p,a) - - - -/***************************************************************************** - * IEnumUnknown interface - */ -#define ICOM_INTERFACE IEnumUnknown -#define IEnumUnknown_METHODS \ - ICOM_METHOD3(HRESULT,Next, ULONG,celt, IUnknown**,rgelt, ULONG*,pceltFethed) \ - ICOM_METHOD1(HRESULT,Skip, ULONG,celt) \ - ICOM_METHOD (HRESULT,Reset) \ - ICOM_METHOD1(HRESULT,Clone, IEnumUnknown**,ppenum) -#define IEnumUnknown_IMETHODS \ - IUnknown_IMETHODS \ - IEnumUnknown_METHODS -ICOM_DEFINE(IEnumUnknown,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IEnumUnknown_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IEnumUnknown_AddRef(p) ICOM_CALL (AddRef,p) -#define IEnumUnknown_Release(p) ICOM_CALL (Release,p) -/*** IEnumUnknown methods ***/ -#define IEnumUnknown_Next(p,a,b,c) ICOM_CALL3(Next,p,a,b,c) -#define IEnumUnknown_Skip(p,a) ICOM_CALL1(Skip,p,a) -#define IEnumUnknown_Reset(p) ICOM_CALL (Reset,p) -#define IEnumUnknown_Clone(p,a) ICOM_CALL1(Clone,p,a) - - -/***************************************************************************** - * IMalloc interface - */ -#define ICOM_INTERFACE IMalloc -#define IMalloc_METHODS \ - ICOM_METHOD1 (LPVOID,Alloc, DWORD,cb) \ - ICOM_METHOD2 (LPVOID,Realloc, LPVOID,pv, DWORD,cb) \ - ICOM_VMETHOD1( Free, LPVOID,pv) \ - ICOM_METHOD1(DWORD, GetSize, LPVOID,pv) \ - ICOM_METHOD1(INT, DidAlloc, LPVOID,pv) \ - ICOM_METHOD (VOID, HeapMinimize) -#define IMalloc_IMETHODS \ - IUnknown_IMETHODS \ - IMalloc_METHODS -ICOM_DEFINE(IMalloc,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IMalloc_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IMalloc_AddRef(p) ICOM_CALL (AddRef,p) -#define IMalloc_Release(p) ICOM_CALL (Release,p) -/*** IMalloc methods ***/ -#define IMalloc_Alloc(p,a) ICOM_CALL1(Alloc,p,a) -#define IMalloc_Realloc(p,a,b) ICOM_CALL2(Realloc,p,a,b) -#define IMalloc_Free(p,a) ICOM_CALL1(Free,p,a) -#define IMalloc_GetSize(p,a) ICOM_CALL1(GetSize,p,a) -#define IMalloc_DidAlloc(p,a) ICOM_CALL1(DidAlloc,p,a) -#define IMalloc_HeapMinimize(p) ICOM_CALL (HeapMinimize,p) - - -/***************************************************************************** - * IMallocSpy interface - */ -#define ICOM_INTERFACE IMallocSpy -#define IMallocSpy_METHODS \ - ICOM_METHOD1 (ULONG,PreAlloc, ULONG,cbRequest) \ - ICOM_METHOD1 (PVOID,PostAlloc, void*,pActual) \ - ICOM_METHOD2 (PVOID,PreFree, void*,pRequest, BOOL,fSpyed) \ - ICOM_VMETHOD1( PostFree, BOOL,fSpyed) \ - ICOM_METHOD4 (ULONG,PreRealloc, void*,pRequest, ULONG,cbRequest, void**,ppNewRequest, BOOL,fSpyed) \ - ICOM_METHOD2 (PVOID,PostRealloc, void*,pActual, BOOL,fSpyed) \ - ICOM_METHOD2 (PVOID,PreGetSize, void*,pRequest, BOOL,fSpyed) \ - ICOM_METHOD2 (ULONG,PostGetSize, ULONG,cbActual, BOOL,fSpyed) \ - ICOM_METHOD2 (PVOID,PreDidAlloc, void*,pRequest, BOOL,fSpyed) \ - ICOM_METHOD3 (int, PostDidAlloc, void*,pRequest, BOOL,fSpyed, int,fActual) \ - ICOM_METHOD (int, PreHeapMinimize) \ - ICOM_METHOD (int, PostHeapMinimize) -#define IMallocSpy_IMETHODS \ - IUnknown_IMETHODS \ - IMallocSpy_METHODS -ICOM_DEFINE(IMallocSpy,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IMallocSpy_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IMallocSpy_AddRef(p) ICOM_CALL (AddRef,p) -#define IMallocSpy_Release(p) ICOM_CALL (Release,p) -/*** IMallocSpy methods ***/ -#define IMallocSpy_PreAlloc(p,a) ICOM_CALL1(PreAlloc,p,a) -#define IMallocSpy_PostAlloc(p,a) ICOM_CALL1(PostAlloc,p,a) -#define IMallocSpy_PreFree(p,a,b) ICOM_CALL2(PreFree,p,a,b) -#define IMallocSpy_PostFree(p,a) ICOM_CALL1(PostFree,p,a) -#define IMallocSpy_PreRealloc(p,a,b,c,d) ICOM_CALL4(PreRealloc,p,a,b,c,d) -#define IMallocSpy_PostRealloc(p,a,b) ICOM_CALL2(PostRealloc,p,a,b) -#define IMallocSpy_PreGetSize(p,a,b) ICOM_CALL2(PreGetSize,p,a,b) -#define IMallocSpy_PostGetSize(p,a,b) ICOM_CALL2(PostGetSize,p,a,b) -#define IMallocSpy_PreDidAlloc(p,a,b) ICOM_CALL2(PreDidAlloc,p,a,b) -#define IMallocSpy_PostDidAlloc(p,a,b,c) ICOM_CALL3(PostDidAlloc,p,a,b,c) -#define IMallocSpy_PreHeapMinimize(p) ICOM_CALL (PreHeapMinimize,p) -#define IMallocSpy_PostHeapMinimize(p) ICOM_CALL (PostHeapMinimize,p) - - -/***************************************************************************** - * IMultiQI interface - */ -typedef struct tagMULTI_QI -{ - const IID* pIID; - IUnknown* pItf; - HRESULT hr; -} MULTI_QI; - -#define ICOM_INTERFACE IMultiQI -#define IMultiQI_METHODS \ - ICOM_METHOD2(HRESULT,QueryMultipleInterfaces, ULONG,cMQIs, MULTI_QI*,pMQIs) -#define IMultiQI_IMETHODS \ - IUnknown_IMETHODS \ - IMultiQI_METHODS -ICOM_DEFINE(IMultiQI,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IMultiQI_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IMultiQI_AddRef(p) ICOM_CALL (AddRef,p) -#define IMultiQI_Release(p) ICOM_CALL (Release,p) -/*** IMultiQI methods ***/ -#define IMultiQI_QueryMultipleInterfaces(p,a,b) ICOM_CALL2(QueryMultipleInterfaces,p,a,b) - - -#ifdef __cplusplus -} /* extern "C" */ -#endif /* defined(__cplusplus) */ - -#endif /* __WINE_WINE_OBJ_MISC_H */ diff --git a/include/wine/obj_moniker.h b/include/wine/obj_moniker.h deleted file mode 100644 index f3ff52caeea..00000000000 --- a/include/wine/obj_moniker.h +++ /dev/null @@ -1,323 +0,0 @@ -/* - * Defines the COM interfaces and APIs related to the moniker functionality. - * - * Copyright (C) the Wine project - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __WINE_WINE_OBJ_MONIKER_H -#define __WINE_WINE_OBJ_MONIKER_H - -#ifdef __cplusplus -extern "C" { -#endif /* defined(__cplusplus) */ - -/***************************************************************************** - * Predeclare the interfaces - */ -DEFINE_OLEGUID(IID_IBindCtx,0xe,0,0); -typedef struct IBindCtx IBindCtx,*LPBINDCTX; -typedef LPBINDCTX LPBC; - -DEFINE_OLEGUID(IID_IClassActivator, 0x00000140L, 0, 0); -typedef struct IClassActivator IClassActivator,*LPCLASSACTIVATOR; - -DEFINE_OLEGUID(IID_IEnumMoniker, 0x00000102L, 0, 0); -typedef struct IEnumMoniker IEnumMoniker,*LPENUMMONIKER; - -DEFINE_OLEGUID(IID_IMoniker, 0x0000000fL, 0, 0); -typedef struct IMoniker IMoniker,*LPMONIKER; - -DEFINE_GUID (IID_IROTData, 0xf29f6bc0L, 0x5021, 0x11ce, 0xaa, 0x15, 0x00, 0x00, 0x69, 0x01, 0x29, 0x3f); -typedef struct IROTData IROTData,*LPROTDATA; - -DEFINE_OLEGUID(IID_IRunnableObject, 0x00000126L, 0, 0); -typedef struct IRunnableObject IRunnableObject,*LPRUNNABLEOBJECT; - -DEFINE_OLEGUID(IID_IRunningObjectTable, 0x00000010L, 0, 0); -typedef struct IRunningObjectTable IRunningObjectTable,*LPRUNNINGOBJECTTABLE; - -/********************************************************************************* - * BIND_OPTS and BIND_OPTS2 structures definition - * These structures contain parameters used during a moniker-binding operation. - *********************************************************************************/ -typedef struct tagBIND_OPTS -{ - DWORD cbStruct; - DWORD grfFlags; - DWORD grfMode; - DWORD dwTickCountDeadline; -} BIND_OPTS, * LPBIND_OPTS; - -typedef struct tagBIND_OPTS2 -{ - DWORD cbStruct; - DWORD grfFlags; - DWORD grfMode; - DWORD dwTickCountDeadline; - DWORD dwTrackFlags; - DWORD dwClassContext; - LCID locale; - COSERVERINFO* pServerInfo; -} BIND_OPTS2, * LPBIND_OPTS2; - -/***************************************************************************** - * IBindCtx interface - */ -#define ICOM_INTERFACE IBindCtx -#define IBindCtx_METHODS \ - ICOM_METHOD1 (HRESULT, RegisterObjectBound, IUnknown*,punk) \ - ICOM_METHOD1 (HRESULT, RevokeObjectBound, IUnknown*,punk) \ - ICOM_METHOD (HRESULT, ReleaseBoundObjects) \ - ICOM_METHOD1 (HRESULT, SetBindOptions, LPBIND_OPTS2,pbindopts) \ - ICOM_METHOD1 (HRESULT, GetBindOptions, LPBIND_OPTS2,pbindopts) \ - ICOM_METHOD1 (HRESULT, GetRunningObjectTable,IRunningObjectTable**,pprot) \ - ICOM_METHOD2 (HRESULT, RegisterObjectParam, LPOLESTR,pszkey, IUnknown*,punk) \ - ICOM_METHOD2 (HRESULT, GetObjectParam, LPOLESTR,pszkey, IUnknown**,punk) \ - ICOM_METHOD1 (HRESULT, EnumObjectParam, IEnumString**,ppenum) \ - ICOM_METHOD1 (HRESULT, RevokeObjectParam, LPOLESTR,pszkey) -#define IBindCtx_IMETHODS \ - IUnknown_IMETHODS \ - IBindCtx_METHODS -ICOM_DEFINE(IBindCtx,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IBindCtx_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IBindCtxr_AddRef(p) ICOM_CALL (AddRef,p) -#define IBindCtx_Release(p) ICOM_CALL (Release,p) -/* IBindCtx methods*/ -#define IBindCtx_RegisterObjectBound(p,a) ICOM_CALL1(RegisterObjectBound,p,a) -#define IBindCtx_RevokeObjectBound(p,a) ICOM_CALL1(RevokeObjectBound,p,a) -#define IBindCtx_ReleaseBoundObjects(p) ICOM_CALL (ReleaseBoundObjects,p) -#define IBindCtx_SetBindOptions(p,a) ICOM_CALL1(SetBindOptions,p,a) -#define IBindCtx_GetBindOptions(p,a) ICOM_CALL1(GetBindOptions,p,a) -#define IBindCtx_GetRunningObjectTable(p,a) ICOM_CALL1(GetRunningObjectTable,p,a) -#define IBindCtx_RegisterObjectParam(p,a,b) ICOM_CALL2(RegisterObjectParam,p,a,b) -#define IBindCtx_GetObjectParam(p,a,b) ICOM_CALL2(GetObjectParam,p,a,b) -#define IBindCtx_EnumObjectParam(p,a) ICOM_CALL1(EnumObjectParam,p,a) -#define IBindCtx_RevokeObjectParam(p,a) ICOM_CALL1(RevokeObjectParam,p,a) - - -/***************************************************************************** - * IClassActivator interface - */ -#define ICOM_INTERFACE IClassActivator -#define IClassActivator_METHODS \ - ICOM_METHOD5(HRESULT,GetClassObject, REFCLSID,rclsid, DWORD,dwClassContext, LCID,locale, REFIID,riid, void**,ppv) -#define IClassActivator_IMETHODS \ - IUnknown_IMETHODS \ - IClassActivator_METHODS -ICOM_DEFINE(IClassActivator,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IClassActivator_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IClassActivator_AddRef(p) ICOM_CALL (AddRef,p) -#define IClassActivator_Release(p) ICOM_CALL (Release,p) -/*** IClassActivator methods ***/ -#define IClassActivator_GetClassObject(p,a,b,c,d,e) ICOM_CALL5(GetClassObject,p,a,b,c,d,e) - - -/***************************************************************************** - * IEnumMoniker interface - */ -#define ICOM_INTERFACE IEnumMoniker -#define IEnumMoniker_METHODS \ - ICOM_METHOD3(HRESULT,Next, ULONG,celt, IMoniker**,rgelt, ULONG*,pceltFethed) \ - ICOM_METHOD1(HRESULT,Skip, ULONG,celt) \ - ICOM_METHOD (HRESULT,Reset) \ - ICOM_METHOD1(HRESULT,Clone, IEnumMoniker**,ppenum) -#define IEnumMoniker_IMETHODS \ - IUnknown_IMETHODS \ - IEnumMoniker_METHODS -ICOM_DEFINE(IEnumMoniker,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IEnumMoniker_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IEnumMoniker_AddRef(p) ICOM_CALL (AddRef,p) -#define IEnumMoniker_Release(p) ICOM_CALL (Release,p) -/*** IEnumMoniker methods ***/ -#define IEnumMoniker_Next(p,a,b,c) ICOM_CALL3(Next,p,a,b,c) -#define IEnumMoniker_Skip(p,a) ICOM_CALL1(Skip,p,a) -#define IEnumMoniker_Reset(p) ICOM_CALL (Reset,p) -#define IEnumMoniker_Clone(p,a) ICOM_CALL1(Clone,p,a) - -/***************************************************************************** - * IMoniker interface - */ - -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 ICOM_INTERFACE IMoniker -#define IMoniker_METHODS \ - ICOM_METHOD4(HRESULT,BindToObject, IBindCtx*,pbc, IMoniker*,pmkToLeft, REFIID,riidResult, void**,ppvResult) \ - ICOM_METHOD4(HRESULT,BindToStorage, IBindCtx*,pbc, IMoniker*,pmkToLeft, REFIID,riid, void**,ppvObj) \ - ICOM_METHOD4(HRESULT,Reduce, IBindCtx*,pbc, DWORD,dwReduceHowFar, IMoniker**,ppmkToLeft, IMoniker**,ppmkReduced) \ - ICOM_METHOD3(HRESULT,ComposeWith, IMoniker*,pmkRight, BOOL,fOnlyIfNotGeneric, IMoniker**,ppmkComposite) \ - ICOM_METHOD2(HRESULT,Enum, BOOL,fForward, IEnumMoniker**,ppenumMoniker) \ - ICOM_METHOD1(HRESULT,IsEqual, IMoniker*,pmkOtherMoniker) \ - ICOM_METHOD1(HRESULT,Hash, DWORD*,pdwHash) \ - ICOM_METHOD3(HRESULT,IsRunning, IBindCtx*,pbc, IMoniker*,pmkToLeft, IMoniker*,pmkNewlyRunning) \ - ICOM_METHOD3(HRESULT,GetTimeOfLastChange, IBindCtx*,pbc, IMoniker*,pmkToLeft, FILETIME*,pFileTime) \ - ICOM_METHOD1(HRESULT,Inverse, IMoniker**,ppmk) \ - ICOM_METHOD2(HRESULT,CommonPrefixWith, IMoniker*,pmkOtherMoniker, IMoniker**,ppmkPrefix) \ - ICOM_METHOD2(HRESULT,RelativePathTo, IMoniker*,pmkOther, IMoniker**,ppmkRelPath) \ - ICOM_METHOD3(HRESULT,GetDisplayName, IBindCtx*,pbc, IMoniker*,pmkToLeft, LPOLESTR*,ppszDisplayName) \ - ICOM_METHOD5(HRESULT,ParseDisplayName, IBindCtx*,pbc, IMoniker*,pmkToLeft, LPOLESTR,pszDisplayName, ULONG*,pchEaten, IMoniker**,ppmkOut) \ - ICOM_METHOD1(HRESULT,IsSystemMoniker, DWORD*,pdwMksys) -#define IMoniker_IMETHODS \ - IPersistStream_IMETHODS \ - IMoniker_METHODS -ICOM_DEFINE(IMoniker,IPersistStream) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IMoniker_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IMoniker_AddRef(p) ICOM_CALL (AddRef,p) -#define IMoniker_Release(p) ICOM_CALL (Release,p) - -/*** IPersist methods ***/ -#define IMoniker_GetClassID(p,a) ICOM_CALL1(GetClassID,p,a) -/*** IPersistStream methods ***/ -#define IMoniker_IsDirty(p) ICOM_CALL (IsDirty,p) -#define IMoniker_Load(p,a) ICOM_CALL1(Load,p,a) -#define IMoniker_Save(p,a,b) ICOM_CALL2(Save,p,a,b) -#define IMoniker_GetSizeMax(p,a) ICOM_CALL1(GetSizeMax,p,a) -/*** IMoniker methods ***/ -#define IMoniker_BindToObject(p,a,b,c,d) ICOM_CALL4(BindToObject,p,a,b,c,d) -#define IMoniker_BindToStorage(p,a,b,c,d) ICOM_CALL4(BindToStorage,p,a,b,c,d) -#define IMoniker_Reduce(p,a,b,c,d) ICOM_CALL4(Reduce,p,a,b,c,d) -#define IMoniker_ComposeWith(p,a,b,c) ICOM_CALL3(ComposeWith,p,a,b,c) -#define IMoniker_Enum(p,a,b) ICOM_CALL2(Enum,p,a,b) -#define IMoniker_IsEqual(p,a) ICOM_CALL1(IsEqual,p,a) -#define IMoniker_Hash(p,a) ICOM_CALL1(Hash,p,a) -#define IMoniker_IsRunning(p,a,b,c) ICOM_CALL3(IsRunning,p,a,b,c) -#define IMoniker_GetTimeOfLastChange(p,a,b,c) ICOM_CALL3(GetTimeOfLastChange,p,a,b,c) -#define IMoniker_Inverse(p,a) ICOM_CALL1(Inverse,p,a) -#define IMoniker_CommonPrefixWith(p,a,b) ICOM_CALL2(CommonPrefixWith,p,a,b) -#define IMoniker_RelativePathTo(p,a,b) ICOM_CALL2(RelativePathTo,p,a,b) -#define IMoniker_GetDisplayName(p,a,b,c) ICOM_CALL3(GetDisplayName,p,a,b,c) -#define IMoniker_ParseDisplayName(p,a,b,c,d,e) ICOM_CALL5(ParseDisplayName,p,a,b,c,d,e) -#define IMoniker_IsSystemMoniker(p,a) ICOM_CALL1(IsSystemMoniker,p,a) - - -/***************************************************************************** - * IROTData interface - */ -#define ICOM_INTERFACE IROTData -#define IROTData_METHODS \ - ICOM_METHOD3(HRESULT,GetComparisonData, byte*,pbData, ULONG,cbMax, ULONG*,pcbData) -#define IROTData_IMETHODS \ - IUnknown_IMETHODS \ - IROTData_METHODS -ICOM_DEFINE(IROTData,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IROTData_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IROTData_AddRef(p) ICOM_CALL (AddRef,p) -#define IROTData_Release(p) ICOM_CALL (Release,p) -/*** IROTData methods ***/ -#define IROTData_GetComparisonData(p,a,b,c) ICOM_CALL3(GetComparisonData,p,a,b,c) - -/***************************************************************************** - * IRunnableObject interface - */ -#define ICOM_INTERFACE IRunnableObject -#define IRunnableObject_METHODS \ - ICOM_METHOD1(HRESULT,GetRunningClass, LPCLSID,lpClsid) \ - ICOM_METHOD1(HRESULT,Run, IBindCtx*,pbc) \ - ICOM_METHOD (BOOL,IsRunning) \ - ICOM_METHOD2(HRESULT,LockRunning, BOOL,fLock, BOOL,fLastUnlockCloses) \ - ICOM_METHOD1(HRESULT,SetContainedObject, BOOL,fContained) -#define IRunnableObject_IMETHODS \ - IUnknown_IMETHODS \ - IRunnableObject_METHODS -ICOM_DEFINE(IRunnableObject,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IRunnableObject_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IRunnableObject_AddRef(p) ICOM_CALL (AddRef,p) -#define IRunnableObject_Release(p) ICOM_CALL (Release,p) -/*** IRunnableObject methods ***/ -#define IRunnableObject_GetRunningClass(p,a) ICOM_CALL1(GetRunningClass,p,a) -#define IRunnableObject_Run(p,a) ICOM_CALL1(Run,p,a) -#define IRunnableObject_IsRunning(p) ICOM_CALL (IsRunning,p) -#define IRunnableObject_LockRunning(p,a,b) ICOM_CALL2(LockRunning,p,a,b) -#define IRunnableObject_SetContainedObject(p,a) ICOM_CALL1(SetContainedObject,p,a) - - -/***************************************************************************** - * IRunningObjectTable interface - */ -#ifdef __WINE__ -#undef GetObject -#endif - -#define ICOM_INTERFACE IRunningObjectTable -#define IRunningObjectTable_METHODS \ - ICOM_METHOD4(HRESULT,Register, DWORD,grfFlags, IUnknown*,punkObject, IMoniker*,pmkObjectName, DWORD*,pdwRegister) \ - ICOM_METHOD1(HRESULT,Revoke, DWORD,dwRegister) \ - ICOM_METHOD1(HRESULT,IsRunning, IMoniker*,pmkObjectName) \ - ICOM_METHOD2(HRESULT,GetObject, IMoniker*,pmkObjectName, IUnknown**,ppunkObject) \ - ICOM_METHOD2(HRESULT,NoteChangeTime, DWORD,dwRegister, FILETIME*,pfiletime) \ - ICOM_METHOD2(HRESULT,GetTimeOfLastChange, IMoniker*,pmkObjectName, FILETIME*,pfiletime) \ - ICOM_METHOD1(HRESULT,EnumRunning, IEnumMoniker**,ppenumMoniker) -#define IRunningObjectTable_IMETHODS \ - IUnknown_IMETHODS \ - IRunningObjectTable_METHODS -ICOM_DEFINE(IRunningObjectTable,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IRunningObjectTable_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IRunningObjectTable_AddRef(p) ICOM_CALL (AddRef,p) -#define IRunningObjectTable_Release(p) ICOM_CALL (Release,p) -/*** IRunningObjectTable methods ***/ -#define IRunningObjectTable_Register(p,a,b,c,d) ICOM_CALL4(Register,p,a,b,c,d) -#define IRunningObjectTable_Revoke(p,a) ICOM_CALL1(Revoke,p,a) -#define IRunningObjectTable_IsRunning(p,a) ICOM_CALL1(IsRunning,p,a) -#define IRunningObjectTable_GetObject(p,a,b) ICOM_CALL2(GetObject,p,a,b) -#define IRunningObjectTable_NoteChangeTime(p,a,b) ICOM_CALL2(NoteChangeTime,p,a,b) -#define IRunningObjectTable_GetTimeOfLastChange(p,a,b) ICOM_CALL2(GetTimeOfLastChange,p,a,b) -#define IRunningObjectTable_EnumRunning(p,a) ICOM_CALL1(EnumRunning,p,a) - - -#ifdef __cplusplus -} /* extern "C" */ -#endif /* defined(__cplusplus) */ - -#endif /* __WINE_WINE_OBJ_MONIKER_H */ diff --git a/include/wine/obj_propertystorage.h b/include/wine/obj_propertystorage.h deleted file mode 100644 index bbda9a04b5e..00000000000 --- a/include/wine/obj_propertystorage.h +++ /dev/null @@ -1,454 +0,0 @@ -/* - * Defines the COM interfaces and APIs related to saving properties to file. - * - * Copyright (C) the Wine project - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __WINE_WINE_OBJ_PROPERTYSTORAGE_H -#define __WINE_WINE_OBJ_PROPERTYSTORAGE_H - -#ifdef __cplusplus -extern "C" { -#endif /* defined(__cplusplus) */ - -/***************************************************************************** - * Predeclare the interfaces - */ -DEFINE_OLEGUID(IID_IEnumSTATPROPSETSTG, 0x0000013bL, 0, 0); -typedef struct IEnumSTATPROPSETSTG IEnumSTATPROPSETSTG,*LPENUMSTATPROPSETSTG; - -DEFINE_OLEGUID(IID_IEnumSTATPROPSTG, 0x00000139L, 0, 0); -typedef struct IEnumSTATPROPSTG IEnumSTATPROPSTG,*LPENUMSTATPROPSTG; - -DEFINE_OLEGUID(IID_IPropertySetStorage, 0x0000013aL, 0, 0); -typedef struct IPropertySetStorage IPropertySetStorage,*LPPROPERTYSETSTORAGE; - -DEFINE_OLEGUID(IID_IPropertyStorage, 0x00000138L, 0, 0); -typedef struct IPropertyStorage IPropertyStorage,*LPPROPERTYSTORAGE; - - -/***************************************************************************** - * Predeclare the structures - */ - -typedef struct tagSTATPROPSETSTG STATPROPSETSTG; -typedef struct tagSTATPROPSTG STATPROPSTG; - -extern const FMTID FMTID_SummaryInformation; -extern const FMTID FMTID_DocSummaryInformation; -extern const FMTID FMTID_UserDefinedProperties; - -/***************************************************************************** - * PROPSPEC structure - */ - -/* Reserved global Property IDs */ -#define PID_DICTIONARY ( 0 ) - -#define PID_CODEPAGE ( 0x1 ) - -#define PID_FIRST_USABLE ( 0x2 ) - -#define PID_FIRST_NAME_DEFAULT ( 0xfff ) - -#define PID_LOCALE ( 0x80000000 ) - -#define PID_MODIFY_TIME ( 0x80000001 ) - -#define PID_SECURITY ( 0x80000002 ) - -#define PID_ILLEGAL ( 0xffffffff ) - -/* Property IDs for the SummaryInformation Property Set */ - -#define PIDSI_TITLE 0x00000002L /* VT_LPSTR */ -#define PIDSI_SUBJECT 0x00000003L /* VT_LPSTR */ -#define PIDSI_AUTHOR 0x00000004L /* VT_LPSTR */ -#define PIDSI_KEYWORDS 0x00000005L /* VT_LPSTR */ -#define PIDSI_COMMENTS 0x00000006L /* VT_LPSTR */ -#define PIDSI_TEMPLATE 0x00000007L /* VT_LPSTR */ -#define PIDSI_LASTAUTHOR 0x00000008L /* VT_LPSTR */ -#define PIDSI_REVNUMBER 0x00000009L /* VT_LPSTR */ -#define PIDSI_EDITTIME 0x0000000aL /* VT_FILETIME (UTC) */ -#define PIDSI_LASTPRINTED 0x0000000bL /* VT_FILETIME (UTC) */ -#define PIDSI_CREATE_DTM 0x0000000cL /* VT_FILETIME (UTC) */ -#define PIDSI_LASTSAVE_DTM 0x0000000dL /* VT_FILETIME (UTC) */ -#define PIDSI_PAGECOUNT 0x0000000eL /* VT_I4 */ -#define PIDSI_WORDCOUNT 0x0000000fL /* VT_I4 */ -#define PIDSI_CHARCOUNT 0x00000010L /* VT_I4 */ -#define PIDSI_THUMBNAIL 0x00000011L /* VT_CF */ -#define PIDSI_APPNAME 0x00000012L /* VT_LPSTR */ -#define PIDSI_DOC_SECURITY 0x00000013L /* VT_I4 */ -#define PRSPEC_INVALID ( 0xffffffff ) - - -#define PRSPEC_LPWSTR ( 0 ) -#define PRSPEC_PROPID ( 1 ) - -typedef struct tagPROPSPEC -{ - ULONG ulKind; - union - { - PROPID propid; - LPOLESTR lpwstr; - } u; -} PROPSPEC; - - -/***************************************************************************** - * STATPROPSETSTG structure - */ -/* Macros for parsing the OS Version of the Property Set Header */ -#define PROPSETHDR_OSVER_KIND(dwOSVer) HIWORD( (dwOSVer) ) -#define PROPSETHDR_OSVER_MAJOR(dwOSVer) LOBYTE(LOWORD( (dwOSVer) )) -#define PROPSETHDR_OSVER_MINOR(dwOSVer) HIBYTE(LOWORD( (dwOSVer) )) -#define PROPSETHDR_OSVERSION_UNKNOWN 0xFFFFFFFF - -struct tagSTATPROPSETSTG -{ - FMTID fmtid; - CLSID clsid; - DWORD grfFlags; - FILETIME mtime; - FILETIME ctime; - FILETIME atime; - DWORD dwOSVersion; -}; - - -/***************************************************************************** - * STATPROPSTG structure - */ -struct tagSTATPROPSTG -{ - LPOLESTR lpwstrName; - PROPID propid; - VARTYPE vt; -}; - - -/***************************************************************************** - * IEnumSTATPROPSETSTG interface - */ -#define ICOM_INTERFACE IEnumSTATPROPSETSTG -#define IEnumSTATPROPSETSTG_METHODS \ - ICOM_METHOD3(HRESULT,Next, ULONG,celt, STATPROPSETSTG*,rgelt, ULONG*,pceltFethed) \ - ICOM_METHOD1(HRESULT,Skip, ULONG,celt) \ - ICOM_METHOD (HRESULT,Reset) \ - ICOM_METHOD1(HRESULT,Clone, IEnumSTATPROPSETSTG**,ppenum) -#define IEnumSTATPROPSETSTG_IMETHODS \ - IUnknown_IMETHODS \ - IEnumSTATPROPSETSTG_METHODS -ICOM_DEFINE(IEnumSTATPROPSETSTG,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IEnumSTATPROPSETSTG_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IEnumSTATPROPSETSTG_AddRef(p) ICOM_CALL (AddRef,p) -#define IEnumSTATPROPSETSTG_Release(p) ICOM_CALL (Release,p) -/*** IEnumSTATPROPSETSTG methods ***/ -#define IEnumSTATPROPSETSTG_Next(p,a,b,c) ICOM_CALL3(Next,p,a,b,c) -#define IEnumSTATPROPSETSTG_Skip(p,a) ICOM_CALL1(Skip,p,a) -#define IEnumSTATPROPSETSTG_Reset(p) ICOM_CALL (Reset,p) -#define IEnumSTATPROPSETSTG_Clone(p,a) ICOM_CALL1(Clone,p,a) - - -/***************************************************************************** - * IEnumSTATPROPSTG interface - */ -#define ICOM_INTERFACE IEnumSTATPROPSTG -#define IEnumSTATPROPSTG_METHODS \ - ICOM_METHOD3(HRESULT,Next, ULONG,celt, STATPROPSTG*,rgelt, ULONG*,pceltFethed) \ - ICOM_METHOD1(HRESULT,Skip, ULONG,celt) \ - ICOM_METHOD (HRESULT,Reset) \ - ICOM_METHOD1(HRESULT,Clone, IEnumSTATPROPSTG**,ppenum) -#define IEnumSTATPROPSTG_IMETHODS \ - IUnknown_IMETHODS \ - IEnumSTATPROPSTG_METHODS -ICOM_DEFINE(IEnumSTATPROPSTG,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IEnumSTATPROPSTG_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IEnumSTATPROPSTG_AddRef(p) ICOM_CALL (AddRef,p) -#define IEnumSTATPROPSTG_Release(p) ICOM_CALL (Release,p) -/*** IEnumSTATPROPSTG methods ***/ -#define IEnumSTATPROPSTG_Next(p,a,b,c) ICOM_CALL3(Next,p,a,b,c) -#define IEnumSTATPROPSTG_Skip(p,a) ICOM_CALL1(Skip,p,a) -#define IEnumSTATPROPSTG_Reset(p) ICOM_CALL (Reset,p) -#define IEnumSTATPROPSTG_Clone(p,a) ICOM_CALL1(Clone,p,a) - - -/***************************************************************************** - * IPropertySetStorage interface - */ -#define ICOM_INTERFACE IPropertySetStorage -#define IPropertySetStorage_METHODS \ - ICOM_METHOD5(HRESULT,Create, REFFMTID,rfmtid, const CLSID*,pclsid, DWORD,grfFlags, DWORD,grfMode, IPropertyStorage**,ppprstg) \ - ICOM_METHOD3(HRESULT,Open, REFFMTID,rfmtid, DWORD,grfMode, IPropertyStorage**,ppprstg) \ - ICOM_METHOD1(HRESULT,Delete, REFFMTID,rfmtid) \ - ICOM_METHOD1(HRESULT,Enum, IEnumSTATPROPSETSTG**,ppenum) -#define IPropertySetStorage_IMETHODS \ - IUnknown_IMETHODS \ - IPropertySetStorage_METHODS -ICOM_DEFINE(IPropertySetStorage,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IPropertySetStorage_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IPropertySetStorage_AddRef(p) ICOM_CALL (AddRef,p) -#define IPropertySetStorage_Release(p) ICOM_CALL (Release,p) -/*** IPropertySetStorage methods ***/ -#define IPropertySetStorage_Create(p,a,b,c,d,e) ICOM_CALL5(Create,p,a,b,c,d,e) -#define IPropertySetStorage_Open(p,a,b,c) ICOM_CALL3(Open,p,a,b,c) -#define IPropertySetStorage_Delete(p,a) ICOM_CALL1(Delete,p,a) -#define IPropertySetStorage_Enum(p,a) ICOM_CALL1(Enum,p,a) - - -/***************************************************************************** - * IPropertyStorage interface - */ -typedef struct tagPROPVARIANT PROPVARIANT,*LPPROPVARIANT; - -/* Flags for IPropertySetStorage::Create */ -#define PROPSETFLAG_DEFAULT ( 0 ) -#define PROPSETFLAG_NONSIMPLE ( 1 ) -#define PROPSETFLAG_ANSI ( 2 ) - -typedef struct tagCAUB -{ - ULONG cElems; - unsigned char *pElems; -} CAUB; - -typedef struct tagCAI -{ - ULONG cElems; - short *pElems; -} CAI; - -typedef struct tagCAUI -{ - ULONG cElems; - USHORT *pElems; -} CAUI; - -typedef struct tagCAL -{ - ULONG cElems; - long *pElems; -} CAL; - -typedef struct tagCAUL -{ - ULONG cElems; - ULONG *pElems; -} CAUL; - -typedef struct tagCAFLT -{ - ULONG cElems; - float *pElems; -} CAFLT; - -typedef struct tagCADBL -{ - ULONG cElems; - double *pElems; -} CADBL; - -typedef struct tagCACY -{ - ULONG cElems; - CY *pElems; -} CACY; - -typedef struct tagCADATE -{ - ULONG cElems; - DATE *pElems; -} CADATE; - -typedef struct tagCABSTR -{ - ULONG cElems; - BSTR *pElems; -} CABSTR; - -typedef struct tagCABOOL -{ - ULONG cElems; - VARIANT_BOOL *pElems; -} CABOOL; - -typedef struct tagCASCODE -{ - ULONG cElems; - SCODE *pElems; -} CASCODE; - -typedef struct tagCAPROPVARIANT -{ - ULONG cElems; - PROPVARIANT *pElems; -} CAPROPVARIANT; - -typedef struct tagCAH -{ - ULONG cElems; - LARGE_INTEGER *pElems; -} CAH; - -typedef struct tagCAUH -{ - ULONG cElems; - ULARGE_INTEGER *pElems; -} CAUH; - -typedef struct tagCALPSTR -{ - ULONG cElems; - LPSTR *pElems; -} CALPSTR; - -typedef struct tagCALPWSTR -{ - ULONG cElems; - LPWSTR *pElems; -} CALPWSTR; - -typedef struct tagCAFILETIME -{ - ULONG cElems; - FILETIME *pElems; -} CAFILETIME; - -typedef struct tagCACLIPDATA -{ - ULONG cElems; - CLIPDATA *pElems; -} CACLIPDATA; - -typedef struct tagCACLSID -{ - ULONG cElems; - CLSID *pElems; -} CACLSID; - -struct tagPROPVARIANT -{ - VARTYPE vt; - WORD wReserved1; - WORD wReserved2; - WORD wReserved3; - union - { - /* Empty union arm */ - UCHAR bVal; - short iVal; - USHORT uiVal; - VARIANT_BOOL boolVal; -#ifndef __cplusplus - /* FIXME: bool is reserved in C++, how can we deal with that ? */ - _VARIANT_BOOL bool; -#endif - long lVal; - ULONG ulVal; - float fltVal; - SCODE scode; - LARGE_INTEGER hVal; - ULARGE_INTEGER uhVal; - double dblVal; - CY cyVal; - DATE date; - FILETIME filetime; - CLSID *puuid; - BLOB blob; - CLIPDATA *pclipdata; - IStream *pStream; - IStorage *pStorage; - BSTR bstrVal; - LPSTR pszVal; - LPWSTR pwszVal; - CAUB caub; - CAI cai; - CAUI caui; - CABOOL cabool; - CAL cal; - CAUL caul; - CAFLT caflt; - CASCODE cascode; - CAH cah; - CAUH cauh; - CADBL cadbl; - CACY cacy; - CADATE cadate; - CAFILETIME cafiletime; - CACLSID cauuid; - CACLIPDATA caclipdata; - CABSTR cabstr; - CALPSTR calpstr; - CALPWSTR calpwstr; - CAPROPVARIANT capropvar; - } u; -}; - - -#define ICOM_INTERFACE IPropertyStorage -#define IPropertyStorage_METHODS \ - ICOM_METHOD3(HRESULT,ReadMultiple, ULONG,cpspec, const PROPSPEC*,rgpspec, PROPVARIANT*,rgpropvar) \ - ICOM_METHOD4(HRESULT,WriteMultiple, ULONG,cpspec, const PROPSPEC*,rgpspec, const PROPVARIANT*,rgpropvar, PROPID,propidNameFirst) \ - ICOM_METHOD2(HRESULT,DeleteMultiple, ULONG,cpspec, const PROPSPEC*,rgpspec) \ - ICOM_METHOD2(HRESULT,ReadPropertyNames, const PROPID*,rgpropid, LPOLESTR*,rglpwstrName) \ - ICOM_METHOD3(HRESULT,WritePropertyNames, ULONG,cpropid, const PROPID*,rgpropid, LPOLESTR*,rglpwstrName) \ - ICOM_METHOD2(HRESULT,DeletePropertyNames, ULONG,cpropid, const PROPID*,rgpropid) \ - ICOM_METHOD1(HRESULT,Commit, DWORD,grfCommitFlags) \ - ICOM_METHOD (HRESULT,Revert) \ - ICOM_METHOD1(HRESULT,Enum, IEnumSTATPROPSTG**,ppenum) \ - ICOM_METHOD3(HRESULT,SetTimes, const FILETIME*,pctime, const FILETIME*,patime, const FILETIME*,pmtime) \ - ICOM_METHOD1(HRESULT,SetClass, REFCLSID,clsid) \ - ICOM_METHOD1(HRESULT,Stat, STATPROPSETSTG*,pstatpsstg) -#define IPropertyStorage_IMETHODS \ - IUnknown_IMETHODS \ - IPropertyStorage_METHODS -ICOM_DEFINE(IPropertyStorage,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IPropertyStorage_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IPropertyStorage_AddRef(p) ICOM_CALL (AddRef,p) -#define IPropertyStorage_Release(p) ICOM_CALL (Release,p) -/*** IPropertyStorage methods ***/ -#define IPropertyStorage_ReadMultiple(p,a,b,c) ICOM_CALL3(ReadMultiple,p,a,b,c) -#define IPropertyStorage_WriteMultiple(p,a,b,c,d) ICOM_CALL4(WriteMultiple,p,a,b,c,d) -#define IPropertyStorage_DeleteMultiple(p,a,b) ICOM_CALL2(DeleteMultiple,p,a,b) -#define IPropertyStorage_ReadPropertyNames(p,a,b) ICOM_CALL2(ReadPropertyNames,p,a,b) -#define IPropertyStorage_WritePropertyNames(p,a,b,c) ICOM_CALL3(WritePropertyNames,p,a,b,c) -#define IPropertyStorage_DeletePropertyNames(p,a,b) ICOM_CALL2(DeletePropertyNames,p,a,b) -#define IPropertyStorage_Commit(p,a) ICOM_CALL1(Commit,p,a) -#define IPropertyStorage_Revert(p) ICOM_CALL (Revert,p) -#define IPropertyStorage_Enum(p,a) ICOM_CALL1(Enum,p,a) -#define IPropertyStorage_SetTimes(p,a,b,c) ICOM_CALL3(SetTimes,p,a,b,c) -#define IPropertyStorage_SetClass(p,a) ICOM_CALL1(SetClass,p,a) -#define IPropertyStorage_Stat(p,a) ICOM_CALL1(Stat,p,a) - -#ifdef __cplusplus -} /* extern "C" */ -#endif /* defined(__cplusplus) */ - -#endif /* __WINE_WINE_OBJ_PROPERTYSTORAGE_H */ diff --git a/include/wine/obj_storage.h b/include/wine/obj_storage.h deleted file mode 100644 index fea4c9b4832..00000000000 --- a/include/wine/obj_storage.h +++ /dev/null @@ -1,599 +0,0 @@ -/* - * Defines the COM interfaces and APIs related to structured data storage. - * - * Copyright (C) the Wine project - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __WINE_WINE_OBJ_STORAGE_H -#define __WINE_WINE_OBJ_STORAGE_H - -#ifdef __cplusplus -extern "C" { -#endif /* defined(__cplusplus) */ - -/***************************************************************************** - * Predeclare the structures - */ -typedef enum tagLOCKTYPE -{ -#undef LOCK_WRITE - LOCK_WRITE = 1, - LOCK_EXCLUSIVE = 2, - LOCK_ONLYONCE = 4 -} LOCKTYPE; - -typedef struct tagStorageLayout -{ - DWORD LayoutType; - OLECHAR16* pwcsElementName; - LARGE_INTEGER cOffset; - LARGE_INTEGER cBytes; -} StorageLayout; - -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 struct tagSTATSTG16 { - LPOLESTR16 pwcsName; - DWORD type; - ULARGE_INTEGER cbSize; - FILETIME mtime; - FILETIME ctime; - FILETIME atime; - DWORD grfMode; - DWORD grfLocksSupported; - CLSID clsid; - DWORD grfStateBits; - DWORD reserved; -} STATSTG16; - -typedef LPOLESTR16 *SNB16; -typedef LPOLESTR *SNB; - - -/***************************************************************************** - * Predeclare the interfaces - */ -DEFINE_OLEGUID(IID_IEnumSTATSTG, 0x0000000dL, 0, 0); -typedef struct IEnumSTATSTG IEnumSTATSTG,*LPENUMSTATSTG; - -DEFINE_GUID (IID_IFillLockBytes, 0x99caf010L, 0x415e, 0x11cf, 0x88, 0x14, 0x00, 0xaa, 0x00, 0xb5, 0x69, 0xf5); -typedef struct IFillLockBytes IFillLockBytes,*LPFILLLOCKBYTES; - -DEFINE_GUID (IID_ILayoutStorage, 0x0e6d4d90L, 0x6738, 0x11cf, 0x96, 0x08, 0x00, 0xaa, 0x00, 0x68, 0x0d, 0xb4); -typedef struct ILayoutStorage ILayoutStorage,*LPLAYOUTSTORAGE; - -DEFINE_OLEGUID(IID_ILockBytes, 0x0000000aL, 0, 0); -typedef struct ILockBytes ILockBytes,*LPLOCKBYTES; - -DEFINE_OLEGUID(IID_IPersist, 0x0000010cL, 0, 0); -typedef struct IPersist IPersist,*LPPERSIST; - -DEFINE_OLEGUID(IID_IPersistFile, 0x0000010bL, 0, 0); -typedef struct IPersistFile IPersistFile,*LPPERSISTFILE; - -DEFINE_OLEGUID(IID_IPersistStorage, 0x0000010aL, 0, 0); -typedef struct IPersistStorage IPersistStorage,*LPPERSISTSTORAGE; - -DEFINE_OLEGUID(IID_IPersistStream, 0x00000109L, 0, 0); -typedef struct IPersistStream IPersistStream,*LPPERSISTSTREAM; - -DEFINE_GUID (IID_IProgressNotify, 0xa9d758a0L, 0x4617, 0x11cf, 0x95, 0xfc, 0x00, 0xaa, 0x00, 0x68, 0x0d, 0xb4); -typedef struct IProgressNotify IProgressNotify,*LPPROGRESSNOTIFY; - -DEFINE_OLEGUID(IID_IRootStorage, 0x00000012L, 0, 0); -typedef struct IRootStorage IRootStorage,*LPROOTSTORAGE; - -DEFINE_GUID (IID_ISequentialStream, 0x0c733a30L, 0x2a1c, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d); -typedef struct ISequentialStream ISequentialStream,*LPSEQUENTIALSTREAM; - -DEFINE_OLEGUID(IID_IStorage, 0x0000000bL, 0, 0); -typedef struct IStorage16 IStorage16,*LPSTORAGE16; -typedef struct IStorage IStorage,*LPSTORAGE; - -DEFINE_OLEGUID(IID_IStream, 0x0000000cL, 0, 0); -typedef struct IStream16 IStream16,*LPSTREAM16; -typedef struct IStream IStream,*LPSTREAM; - - -/***************************************************************************** - * STGTY enumeration - * - * See IStorage - */ -#define STGTY_STORAGE 1 -#define STGTY_STREAM 2 -#define STGTY_LOCKBYTES 3 -#define STGTY_PROPERTY 4 - -/***************************************************************************** - * STREAM_SEEK enumeration - * - * See IStream - */ -#define STREAM_SEEK_SET 0 -#define STREAM_SEEK_CUR 1 -#define STREAM_SEEK_END 2 - -/***************************************************************************** - * IEnumSTATSTG interface - */ -#define ICOM_INTERFACE IEnumSTATSTG -#define IEnumSTATSTG_METHODS \ - ICOM_METHOD3(HRESULT,Next, ULONG,celt, STATSTG*,rgelt, ULONG*,pceltFethed) \ - ICOM_METHOD1(HRESULT,Skip, ULONG,celt) \ - ICOM_METHOD (HRESULT,Reset) \ - ICOM_METHOD1(HRESULT,Clone, IEnumSTATSTG**,ppenum) -#define IEnumSTATSTG_IMETHODS \ - IUnknown_IMETHODS \ - IEnumSTATSTG_METHODS -ICOM_DEFINE(IEnumSTATSTG,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IEnumSTATSTG_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IEnumSTATSTG_AddRef(p) ICOM_CALL (AddRef,p) -#define IEnumSTATSTG_Release(p) ICOM_CALL (Release,p) -/*** IEnumSTATSTG methods ***/ -#define IEnumSTATSTG_Next(p,a,b,c) ICOM_CALL3(Next,p,a,b,c) -#define IEnumSTATSTG_Skip(p,a) ICOM_CALL1(Skip,p,a) -#define IEnumSTATSTG_Reset(p) ICOM_CALL(Reset,p) -#define IEnumSTATSTG_Clone(p,a) ICOM_CALL1(Clone,p,a) - - -/***************************************************************************** - * IFillLockBytes interface - */ -#define ICOM_INTERFACE IFillLockBytes -#define IFillLockBytes_METHODS \ - ICOM_METHOD3(HRESULT,FillAppend, const void*,pv, ULONG,cb, ULONG*,pcbWritten) \ - ICOM_METHOD4(HRESULT,FillAt, ULARGE_INTEGER,ulOffset, const void*,pv, ULONG,cb, ULONG*,pcbWritten) \ - ICOM_METHOD1(HRESULT,SetFillSize, ULARGE_INTEGER,ulSize) \ - ICOM_METHOD1(HRESULT,Terminate, BOOL,bCanceled) -#define IFillLockBytes_IMETHODS \ - IUnknown_IMETHODS \ - IFillLockBytes_METHODS -ICOM_DEFINE(IFillLockBytes,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IFillLockBytes_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IFillLockBytes_AddRef(p) ICOM_CALL (AddRef,p) -#define IFillLockBytes_Release(p) ICOM_CALL (Release,p) -/*** IFillLockBytes methods ***/ -#define IFillLockBytes_FillAppend(p,a,b,c) ICOM_CALL3(FillAppend,p,a,b,c) -#define IFillLockBytes_FillAt(p,a,b,c,d) ICOM_CALL4(FillAt,p,a,b,c,d) -#define IFillLockBytes_SetFillSize(p,a) ICOM_CALL1(SetFillSize,p,a) -#define IFillLockBytes_Terminate(p,a) ICOM_CALL1(Terminate,p,a) - - -/***************************************************************************** - * ILayoutStorage interface - */ -#define ICOM_INTERFACE ILayoutStorage -#define ILayoutStorage_METHODS \ - ICOM_METHOD2(HRESULT,LayoutScript, DWORD,nEntries, DWORD,glfInterleavedFlag) \ - ICOM_METHOD (HRESULT,BeginMonitor) \ - ICOM_METHOD (HRESULT,EndMonitor) \ - ICOM_METHOD1(HRESULT,ReLayoutDocfile, OLECHAR16*,pwcsNewDfName) \ - ICOM_METHOD1(HRESULT,ReLayoutDocfileOnILockBytes, ILockBytes*,pILockBytes) -#define ILayoutStorage_IMETHODS \ - IUnknown_IMETHODS \ - ILayoutStorage_METHODS -ICOM_DEFINE(ILayoutStorage,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define ILayoutStorage_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define ILayoutStorage_AddRef(p) ICOM_CALL (AddRef,p) -#define ILayoutStorage_Release(p) ICOM_CALL (Release,p) -/*** ILayoutStorage methods ***/ -#define ILayoutStorage_LayoutScript(p,a,b) ICOM_CALL2(LayoutScript,p,a,b) -#define ILayoutStorage_BeginMonitor(p) ICOM_CALL (BeginMonitor,p) -#define ILayoutStorage_EndMonitor(p) ICOM_CALL (EndMonitor,p) -#define ILayoutStorage_ReLayoutDocfile(p,a) ICOM_CALL1(ReLayoutDocfile,p,a) -#define ILayoutStorage_ReLayoutDocfileOnILockBytes(p,a) ICOM_CALL1(ReLayoutDocfileOnILockBytes,p,a) - - -/***************************************************************************** - * ILockBytes interface - */ -#define ICOM_INTERFACE ILockBytes -#define ILockBytes_METHODS \ - ICOM_METHOD4(HRESULT,ReadAt, ULARGE_INTEGER,ulOffset, void*,pv, ULONG,cb, ULONG*,pcbRead) \ - ICOM_METHOD4(HRESULT,WriteAt, ULARGE_INTEGER,ulOffset, const void*,pv, ULONG,cb, ULONG*,pcbWritten) \ - ICOM_METHOD (HRESULT,Flush) \ - ICOM_METHOD1(HRESULT,SetSize, ULARGE_INTEGER,cb) \ - ICOM_METHOD3(HRESULT,LockRegion, ULARGE_INTEGER,libOffset, ULARGE_INTEGER,cb, DWORD,dwLockType) \ - ICOM_METHOD3(HRESULT,UnlockRegion, ULARGE_INTEGER,libOffset, ULARGE_INTEGER,cb, DWORD,dwLockType) \ - ICOM_METHOD2(HRESULT,Stat, STATSTG*,pstatstg, DWORD,grfStatFlag) -#define ILockBytes_IMETHODS \ - IUnknown_IMETHODS \ - ILockBytes_METHODS -ICOM_DEFINE(ILockBytes,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define ILockBytes_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define ILockBytes_AddRef(p) ICOM_CALL (AddRef,p) -#define ILockBytes_Release(p) ICOM_CALL (Release,p) -/*** ILockBytes methods ***/ -#define ILockBytes_ReadAt(p,a,b,c,d) ICOM_CALL4(ReadAt,p,a,b,c,d) -#define ILockBytes_WriteAt(p,a,b,c,d) ICOM_CALL4(WriteAt,p,a,b,c,d) -#define ILockBytes_Flush(p) ICOM_CALL (Flush,p) -#define ILockBytes_SetSize(p,a) ICOM_CALL1(SetSize,p,a) -#define ILockBytes_LockRegion(p,a,b,c) ICOM_CALL3(LockRegion,p,a,b,c) -#define ILockBytes_UnlockRegion(p,a,b,c) ICOM_CALL3(UnlockRegion,p,a,b,c) -#define ILockBytes_Stat(p,a,b) ICOM_CALL2(Stat,p,a,b) - - -/***************************************************************************** - * IPersist interface - */ -#define ICOM_INTERFACE IPersist -#define IPersist_METHODS \ - ICOM_METHOD1(HRESULT,GetClassID, CLSID*,pClassID) -#define IPersist_IMETHODS \ - IUnknown_IMETHODS \ - IPersist_METHODS -ICOM_DEFINE(IPersist,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IPersist_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IPersist_AddRef(p) ICOM_CALL (AddRef,p) -#define IPersist_Release(p) ICOM_CALL (Release,p) -/*** IPersist methods ***/ -#define IPersist_GetClassID(p,a) ICOM_CALL1(GetClassID,p,a) - - -/***************************************************************************** - * IPersistFile interface - */ -#define ICOM_INTERFACE IPersistFile -#define IPersistFile_METHODS \ - ICOM_METHOD (HRESULT,IsDirty) \ - ICOM_METHOD2 (HRESULT,Load, LPCOLESTR,pszFileName, DWORD,dwMode) \ - ICOM_METHOD2 (HRESULT,Save, LPCOLESTR,pszFileName, BOOL,fRemember) \ - ICOM_METHOD1 (HRESULT,SaveCompleted, LPCOLESTR,pszFileName) \ - ICOM_METHOD1(HRESULT,GetCurFile, LPOLESTR*,ppszFileName) -#define IPersistFile_IMETHODS \ - IPersist_IMETHODS \ - IPersistFile_METHODS -ICOM_DEFINE(IPersistFile,IPersist) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IPersistFile_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IPersistFile_AddRef(p) ICOM_CALL (AddRef,p) -#define IPersistFile_Release(p) ICOM_CALL (Release,p) -/*** IPersist methods ***/ -#define IPersistFile_GetClassID(p,a) ICOM_CALL1(GetClassID,p,a) -/*** IPersistFile methods ***/ -#define IPersistFile_IsDirty(p) ICOM_CALL(IsDirty,p) -#define IPersistFile_Load(p,a,b) ICOM_CALL2(Load,p,a,b) -#define IPersistFile_Save(p,a,b) ICOM_CALL2(Save,p,a,b) -#define IPersistFile_SaveCompleted(p,a) ICOM_CALL1(SaveCompleted,p,a) -#define IPersistFile_GetCurFile(p,a) ICOM_CALL1(GetCurFile,p,a) - - -/***************************************************************************** - * IPersistStorage interface - */ -#define ICOM_INTERFACE IPersistStorage -#define IPersistStorage_METHODS \ - ICOM_METHOD (HRESULT,IsDirty) \ - ICOM_METHOD1(HRESULT,InitNew, IStorage*,pStg) \ - ICOM_METHOD1(HRESULT,Load, IStorage*,pStg) \ - ICOM_METHOD2(HRESULT,Save, IStorage*,pStg, BOOL,fSameAsLoad) \ - ICOM_METHOD1(HRESULT,SaveCompleted, IStorage*,pStgNew) \ - ICOM_METHOD (HRESULT,HandsOffStorage) -#define IPersistStorage_IMETHODS \ - IPersist_IMETHODS \ - IPersistStorage_METHODS -ICOM_DEFINE(IPersistStorage,IPersist) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IPersistStorage_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IPersistStorage_AddRef(p) ICOM_CALL (AddRef,p) -#define IPersistStorage_Release(p) ICOM_CALL (Release,p) -/*** IPersist methods ***/ -#define IPersistStorage_GetClassID(p,a) ICOM_CALL1(GetClassID,p,a) -/*** IPersistStorage methods ***/ -#define IPersistStorage_IsDirty(p) ICOM_CALL (IsDirty,p) -#define IPersistStorage_InitNew(p,a) ICOM_CALL1(InitNew,p,a) -#define IPersistStorage_Load(p,a) ICOM_CALL1(Load,p,a) -#define IPersistStorage_Save(p,a,b) ICOM_CALL2(Save,p,a,b) -#define IPersistStorage_SaveCompleted(p,a) ICOM_CALL1(SaveCompleted,p,a) -#define IPersistStorage_HandsOffStorage(p) ICOM_CALL (HandsOffStorage,p) - - -/***************************************************************************** - * IPersistStream interface - */ -#define ICOM_INTERFACE IPersistStream -#define IPersistStream_METHODS \ - ICOM_METHOD (HRESULT,IsDirty) \ - ICOM_METHOD1(HRESULT,Load, IStream*,pStm) \ - ICOM_METHOD2(HRESULT,Save, IStream*,pStm, BOOL,fClearDirty) \ - ICOM_METHOD1(HRESULT,GetSizeMax, ULARGE_INTEGER*,pcbSize) -#define IPersistStream_IMETHODS \ - IPersist_IMETHODS \ - IPersistStream_METHODS -ICOM_DEFINE(IPersistStream,IPersist) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IPersistStream_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IPersistStream_AddRef(p) ICOM_CALL (AddRef,p) -#define IPersistStream_Release(p) ICOM_CALL (Release,p) -/*** IPersist methods ***/ -#define IPersistStream_GetClassID(p,a) ICOM_CALL1(GetClassID,p,a) -/*** IPersistStream methods ***/ -#define IPersistStream_IsDirty(p) ICOM_CALL (IsDirty,p) -#define IPersistStream_Load(p,a) ICOM_CALL1(Load,p,a) -#define IPersistStream_Save(p,a,b) ICOM_CALL2(Save,p,a,b) -#define IPersistStream_GetSizeMax(p,a) ICOM_CALL1(GetSizeMax,p,a) - - -/***************************************************************************** - * IProgressNotify interface - */ -#define ICOM_INTERFACE IProgressNotify -#define IProgressNotify_METHODS \ - ICOM_METHOD4(HRESULT,OnProgress, DWORD,dwProgressCurrent, DWORD,dwProgressMaximum, BOOL,fAccurate, BOOL,fOwner) -#define IProgressNotify_IMETHODS \ - IUnknown_IMETHODS \ - IProgressNotify_METHODS -ICOM_DEFINE(IProgressNotify,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IProgressNotify_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IProgressNotify_AddRef(p) ICOM_CALL (AddRef,p) -#define IProgressNotify_Release(p) ICOM_CALL (Release,p) -/*** IProgressNotify methods ***/ -#define IProgressNotify_OnProgress(p,a,b,c,d) ICOM_CALL4(OnProgress,p,a,b,c,d) - - -/***************************************************************************** - * IRootStorage interface - */ -#define ICOM_INTERFACE IRootStorage -#define IRootStorage_METHODS \ - ICOM_METHOD1(HRESULT,SwitchToFile, LPOLESTR,pszFile) -#define IRootStorage_IMETHODS \ - IUnknown_IMETHODS \ - IRootStorage_METHODS -ICOM_DEFINE(IRootStorage,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IRootStorage_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IRootStorage_AddRef(p) ICOM_CALL (AddRef,p) -#define IRootStorage_Release(p) ICOM_CALL (Release,p) -/*** IRootStorage methods ***/ -#define IRootStorage_SwitchToFile(p,a) ICOM_CALLSwitchToFile(,p,a) - - -/***************************************************************************** - * ISequentialStream interface - */ -#define ICOM_INTERFACE ISequentialStream -#define ISequentialStream_METHODS \ - ICOM_METHOD3(HRESULT,Read, void*,pv, ULONG,cb, ULONG*,pcbRead) \ - ICOM_METHOD3(HRESULT,Write, const void*,pv, ULONG,cb, ULONG*,pcbWritten) -#define ISequentialStream_IMETHODS \ - IUnknown_IMETHODS \ - ISequentialStream_METHODS -ICOM_DEFINE(ISequentialStream,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define ISequentialStream_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define ISequentialStream_AddRef(p) ICOM_CALL (AddRef,p) -#define ISequentialStream_Release(p) ICOM_CALL (Release,p) -/*** ISequentialStream methods ***/ -#define ISequentialStream_Read(p,a,b,c) ICOM_CALL3(Read,p,a,b,c) -#define ISequentialStream_Write(p,a,b,c) ICOM_CALL3(Write,p,a,b,c) - - -/***************************************************************************** - * IStorage interface - */ -#define ICOM_INTERFACE IStorage16 -#define IStorage16_METHODS \ - ICOM_METHOD5(HRESULT,CreateStream, LPCOLESTR16,pwcsName, DWORD,grfMode, DWORD,reserved1, DWORD,reserved2, IStream16**,ppstm) \ - ICOM_METHOD5(HRESULT,OpenStream, LPCOLESTR16,pwcsName, void*,reserved1, DWORD,grfMode, DWORD,reserved2, IStream16**,ppstm) \ - ICOM_METHOD5(HRESULT,CreateStorage, LPCOLESTR16,pwcsName, DWORD,grfMode, DWORD,dwStgFmt, DWORD,reserved2, IStorage16**,ppstg) \ - ICOM_METHOD6(HRESULT,OpenStorage, LPCOLESTR16,pwcsName, IStorage16*,pstgPriority, DWORD,grfMode, SNB16,snb16Exclude, DWORD,reserved, IStorage16**,ppstg) \ - ICOM_METHOD4(HRESULT,CopyTo, DWORD,ciidExclude, const IID*,rgiidExclude, SNB16,snb16Exclude, IStorage16*,pstgDest) \ - ICOM_METHOD4(HRESULT,MoveElementTo, LPCOLESTR16,pwcsName, IStorage16*,pstgDest, LPCOLESTR16,pwcsNewName, DWORD,grfFlags) \ - ICOM_METHOD1(HRESULT,Commit, DWORD,grfCommitFlags) \ - ICOM_METHOD (HRESULT,Revert) \ - ICOM_METHOD4(HRESULT,EnumElements, DWORD,reserved1, void*,reserved2, DWORD,reserved3, IEnumSTATSTG**,ppenum) \ - ICOM_METHOD1(HRESULT,DestroyElement, LPCOLESTR16,pwcsName) \ - ICOM_METHOD2(HRESULT,RenameElement, LPCOLESTR16,pwcsOldName, LPOLESTR16,pwcsNewName) \ - ICOM_METHOD4(HRESULT,SetElementTimes,LPCOLESTR16,pwcsName, const FILETIME*,pctime, const FILETIME*,patime, const FILETIME*,pmtime) \ - ICOM_METHOD1(HRESULT,SetClass, REFCLSID,clsid) \ - ICOM_METHOD2(HRESULT,SetStateBits, DWORD,grfStateBits, DWORD,grfMask) \ - ICOM_METHOD2(HRESULT,Stat, STATSTG*,pstatstg, DWORD,grfStatFlag) -#define IStorage16_IMETHODS \ - IUnknown_IMETHODS \ - IStorage16_METHODS -ICOM_DEFINE(IStorage16,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IStorage16_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IStorage16_AddRef(p) ICOM_CALL (AddRef,p) -#define IStorage16_Release(p) ICOM_CALL (Release,p) -/*** IStorage16 methods ***/ -#define IStorage16_CreateStream(p,a,b,c,d,e) ICOM_CALL5(CreateStream,p,a,b,c,d,e) -#define IStorage16_OpenStream(p,a,b,c,d,e) ICOM_CALL5(OpenStream,p,a,b,c,d,e) -#define IStorage16_CreateStorage(p,a,b,c,d,e) ICOM_CALL5(CreateStorage,p,a,b,c,d,e) -#define IStorage16_OpenStorage(p,a,b,c,d,e,f) ICOM_CALL6(OpenStorage,p,a,b,c,d,e,f) -#define IStorage16_CopyTo(p,a,b,c,d) ICOM_CALL4(CopyTo,p,a,b,c,d) -#define IStorage16_MoveElementTo(p,a,b,c,d) ICOM_CALL4(MoveElementTo,p,a,b,c,d) -#define IStorage16_Commit(p,a) ICOM_CALL1(Commit,p,a) -#define IStorage16_Revert(p) ICOM_CALL (Revert,p) -#define IStorage16_EnumElements(p,a,b,c,d) ICOM_CALL4(EnumElements,p,a,b,c,d) -#define IStorage16_DestroyElement(p,a) ICOM_CALL1(DestroyElement,p,a) -#define IStorage16_RenameElement(p,a,b) ICOM_CALL2(RenameElement,p,a,b) -#define IStorage16_SetElementTimes(p,a,b,c,d) ICOM_CALL4(SetElementTimes,p,a,b,c,d) -#define IStorage16_SetClass(p,a) ICOM_CALL1(SetClass,p,a) -#define IStorage16_SetStateBits(p,a,b) ICOM_CALL2(SetStateBits,p,a,b) -#define IStorage16_Stat(p,a,b) ICOM_CALL2(Stat,p,a,b) - - -#define ICOM_INTERFACE IStorage -#define IStorage_METHODS \ - ICOM_METHOD5(HRESULT,CreateStream, LPCOLESTR,pwcsName, DWORD,grfMode, DWORD,reserved1, DWORD,reserved2, IStream**,ppstm) \ - ICOM_METHOD5(HRESULT,OpenStream, LPCOLESTR,pwcsName, void*,reserved1, DWORD,grfMode, DWORD,reserved2, IStream**,ppstm) \ - ICOM_METHOD5(HRESULT,CreateStorage, LPCOLESTR,pwcsName, DWORD,grfMode, DWORD,dwStgFmt, DWORD,reserved2, IStorage**,ppstg) \ - ICOM_METHOD6(HRESULT,OpenStorage, LPCOLESTR,pwcsName, IStorage*,pstgPriority, DWORD,grfMode, SNB,snb16Exclude, DWORD,reserved, IStorage**,ppstg) \ - ICOM_METHOD4(HRESULT,CopyTo, DWORD,ciidExclude, const IID*,rgiidExclude, SNB,snb16Exclude, IStorage*,pstgDest) \ - ICOM_METHOD4(HRESULT,MoveElementTo, LPCOLESTR,pwcsName, IStorage*,pstgDest, LPCOLESTR,pwcsNewName, DWORD,grfFlags) \ - ICOM_METHOD1(HRESULT,Commit, DWORD,grfCommitFlags) \ - ICOM_METHOD (HRESULT,Revert) \ - ICOM_METHOD4(HRESULT,EnumElements, DWORD,reserved1, void*,reserved2, DWORD,reserved3, IEnumSTATSTG**,ppenum) \ - ICOM_METHOD1(HRESULT,DestroyElement, LPCOLESTR,pwcsName) \ - ICOM_METHOD2(HRESULT,RenameElement, LPCOLESTR,pwcsOldName, LPCOLESTR,pwcsNewName) \ - ICOM_METHOD4(HRESULT,SetElementTimes,LPCOLESTR,pwcsName, const FILETIME*,pctime, const FILETIME*,patime, const FILETIME*,pmtime) \ - ICOM_METHOD1(HRESULT,SetClass, REFCLSID,clsid) \ - ICOM_METHOD2(HRESULT,SetStateBits, DWORD,grfStateBits, DWORD,grfMask) \ - ICOM_METHOD2(HRESULT,Stat, STATSTG*,pstatstg, DWORD,grfStatFlag) -#define IStorage_IMETHODS \ - IUnknown_IMETHODS \ - IStorage_METHODS -ICOM_DEFINE(IStorage,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IStorage_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IStorage_AddRef(p) ICOM_CALL (AddRef,p) -#define IStorage_Release(p) ICOM_CALL (Release,p) -/*** IStorage methods ***/ -#define IStorage_CreateStream(p,a,b,c,d,e) ICOM_CALL5(CreateStream,p,a,b,c,d,e) -#define IStorage_OpenStream(p,a,b,c,d,e) ICOM_CALL5(OpenStream,p,a,b,c,d,e) -#define IStorage_CreateStorage(p,a,b,c,d,e) ICOM_CALL5(CreateStorage,p,a,b,c,d,e) -#define IStorage_OpenStorage(p,a,b,c,d,e,f) ICOM_CALL6(OpenStorage,p,a,b,c,d,e,f) -#define IStorage_CopyTo(p,a,b,c,d) ICOM_CALL4(CopyTo,p,a,b,c,d) -#define IStorage_MoveElementTo(p,a,b,c,d) ICOM_CALL4(MoveElementTo,p,a,b,c,d) -#define IStorage_Commit(p,a) ICOM_CALL1(Commit,p,a) -#define IStorage_Revert(p) ICOM_CALL (Revert,p) -#define IStorage_EnumElements(p,a,b,c,d) ICOM_CALL4(EnumElements,p,a,b,c,d) -#define IStorage_DestroyElement(p,a) ICOM_CALL1(DestroyElement,p,a) -#define IStorage_RenameElement(p,a,b) ICOM_CALL2(RenameElement,p,a,b) -#define IStorage_SetElementTimes(p,a,b,c,d) ICOM_CALL4(SetElementTimes,p,a,b,c,d) -#define IStorage_SetClass(p,a) ICOM_CALL1(SetClass,p,a) -#define IStorage_SetStateBits(p,a,b) ICOM_CALL2(SetStateBits,p,a,b) -#define IStorage_Stat(p,a,b) ICOM_CALL2(Stat,p,a,b) - - -/***************************************************************************** - * IStream interface - */ -#define ICOM_INTERFACE IStream16 -#define IStream16_METHODS \ - ICOM_METHOD3(HRESULT,Seek, LARGE_INTEGER,dlibMove, DWORD,dwOrigin, ULARGE_INTEGER*,plibNewPosition) \ - ICOM_METHOD1(HRESULT,SetSize, ULARGE_INTEGER,libNewSize) \ - ICOM_METHOD4(HRESULT,CopyTo, IStream16*,pstm, ULARGE_INTEGER,cb, ULARGE_INTEGER*,pcbRead, ULARGE_INTEGER*,pcbWritten) \ - ICOM_METHOD1(HRESULT,Commit, DWORD,grfCommitFlags) \ - ICOM_METHOD (HRESULT,Revert) \ - ICOM_METHOD3(HRESULT,LockRegion, ULARGE_INTEGER,libOffset, ULARGE_INTEGER,cb, DWORD,dwLockType) \ - ICOM_METHOD3(HRESULT,UnlockRegion,ULARGE_INTEGER,libOffset, ULARGE_INTEGER,cb, DWORD,dwLockType) \ - ICOM_METHOD2(HRESULT,Stat, STATSTG*,pstatstg, DWORD,grfStatFlag) \ - ICOM_METHOD1(HRESULT,Clone, IStream16**,ppstm) -#define IStream16_IMETHODS \ - ISequentialStream_IMETHODS \ - IStream16_METHODS -ICOM_DEFINE(IStream16,ISequentialStream) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IStream16_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IStream16_AddRef(p) ICOM_CALL (AddRef,p) -#define IStream16_Release(p) ICOM_CALL (Release,p) -/*** ISequentialStream methods ***/ -#define IStream16_Read(p,a,b,c) ICOM_CALL3(Read,p,a,b,c) -#define IStream16_Write(p,a,b,c) ICOM_CALL3(Write,p,a,b,c) -/*** IStream16 methods ***/ -#define IStream16_Seek(p) ICOM_CALL3(Seek,p) -#define IStream16_SetSize(p,a,b) ICOM_CALL1(SetSize,p,a,b) -#define IStream16_CopyTo(pa,b,c,d) ICOM_CALL4(CopyTo,pa,b,c,d) -#define IStream16_Commit(p,a) ICOM_CALL1(Commit,p,a) -#define IStream16_Revert(p) ICOM_CALL (Revert,p) -#define IStream16_LockRegion(pa,b,c) ICOM_CALL3(LockRegion,pa,b,c) -#define IStream16_UnlockRegion(p,a,b,c) ICOM_CALL3(UnlockRegion,p,a,b,c) -#define IStream16_Stat(p,a,b) ICOM_CALL2(Stat,p,a,b) -#define IStream16_Clone(p,a) ICOM_CALL1(Clone,p,a) - - -#define ICOM_INTERFACE IStream -#define IStream_METHODS \ - ICOM_METHOD3(HRESULT,Seek, LARGE_INTEGER,dlibMove, DWORD,dwOrigin, ULARGE_INTEGER*,plibNewPosition) \ - ICOM_METHOD1(HRESULT,SetSize, ULARGE_INTEGER,libNewSize) \ - ICOM_METHOD4(HRESULT,CopyTo, IStream*,pstm, ULARGE_INTEGER,cb, ULARGE_INTEGER*,pcbRead, ULARGE_INTEGER*,pcbWritten) \ - ICOM_METHOD1(HRESULT,Commit, DWORD,grfCommitFlags) \ - ICOM_METHOD (HRESULT,Revert) \ - ICOM_METHOD3(HRESULT,LockRegion, ULARGE_INTEGER,libOffset, ULARGE_INTEGER,cb, DWORD,dwLockType) \ - ICOM_METHOD3(HRESULT,UnlockRegion,ULARGE_INTEGER,libOffset, ULARGE_INTEGER,cb, DWORD,dwLockType) \ - ICOM_METHOD2(HRESULT,Stat, STATSTG*,pstatstg, DWORD,grfStatFlag) \ - ICOM_METHOD1(HRESULT,Clone, IStream**,ppstm) -#define IStream_IMETHODS \ - ISequentialStream_IMETHODS \ - IStream_METHODS -ICOM_DEFINE(IStream,ISequentialStream) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IStream_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IStream_AddRef(p) ICOM_CALL (AddRef,p) -#define IStream_Release(p) ICOM_CALL (Release,p) -/*** ISequentialStream methods ***/ -#define IStream_Read(p,a,b,c) ICOM_CALL3(Read,p,a,b,c) -#define IStream_Write(p,a,b,c) ICOM_CALL3(Write,p,a,b,c) -/*** IStream methods ***/ -#define IStream_Seek(p,a,b,c) ICOM_CALL3(Seek,p,a,b,c) -#define IStream_SetSize(p,a) ICOM_CALL1(SetSize,p,a) -#define IStream_CopyTo(p,a,b,c,d) ICOM_CALL4(CopyTo,p,a,b,c,d) -#define IStream_Commit(p,a) ICOM_CALL1(Commit,p,a) -#define IStream_Revert(p) ICOM_CALL (Revert,p) -#define IStream_LockRegion(p,a,b,c) ICOM_CALL3(LockRegion,p,a,b,c) -#define IStream_UnlockRegion(p,a,b,c) ICOM_CALL3(UnlockRegion,p,a,b,c) -#define IStream_Stat(p,a,b) ICOM_CALL2(Stat,p,a,b) -#define IStream_Clone(p,a) ICOM_CALL1(Clone,p,a) - - -#ifdef __cplusplus -} /* extern "C" */ -#endif /* defined(__cplusplus) */ - -#endif /* __WINE_WINE_OBJ_STORAGE_H */