Wrote a new objidl.idl to replace a number of include/wine/obj_*.h
files.
diff --git a/include/objidl.h b/include/objidl.h
index 062bea0..657250a 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 */
