diff --git a/include/Makefile.in b/include/Makefile.in index d058ada5687..3eb0b1554e3 100644 --- a/include/Makefile.in +++ b/include/Makefile.in @@ -8,6 +8,7 @@ IDL_SRCS = \ comcat.idl \ oaidl.idl \ objidl.idl \ + ocidl.idl \ oleidl.idl \ servprov.idl \ strmif.idl \ @@ -123,7 +124,6 @@ WINDOWS_INCLUDES = \ ntsecapi.h \ ntstatus.h \ objbase.h \ - ocidl.h \ ole2.h \ ole2ver.h \ oleauto.h \ @@ -242,17 +242,11 @@ WINE_INCLUDES = \ exception.h \ library.h \ obj_commdlgbrowser.h \ - obj_connection.h \ obj_contextmenu.h \ - obj_control.h \ obj_dockingwindowframe.h \ obj_dragdrophelper.h \ obj_enumidlist.h \ obj_extracticon.h \ - obj_olefont.h \ - obj_oleundo.h \ - obj_picture.h \ - obj_property.h \ obj_shellbrowser.h \ obj_shellextinit.h \ obj_shellfolder.h \ diff --git a/include/oaidl.h b/include/oaidl.h index 8881eab3285..c2cffe4302e 100644 --- a/include/oaidl.h +++ b/include/oaidl.h @@ -5343,6 +5343,203 @@ void __RPC_STUB ICreateTypeLib2_SetHelpStringDll_Stub( #endif /* __ICreateTypeLib2_INTERFACE_DEFINED__ */ +#ifndef __IErrorLog_FWD_DEFINED__ +#define __IErrorLog_FWD_DEFINED__ +typedef struct IErrorLog IErrorLog; +#endif + +typedef IErrorLog *LPERRORLOG; + +/***************************************************************************** + * IErrorLog interface + */ +#ifndef __IErrorLog_INTERFACE_DEFINED__ +#define __IErrorLog_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IErrorLog, 0x3127ca40, 0x446e, 0x11ce, 0x81,0x35, 0x00,0xaa,0x00,0x4b,0xb8,0x51); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IErrorLog : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE AddError( + LPCOLESTR pszPropName, + EXCEPINFO* pExcepInfo) = 0; + +}; +#else +typedef struct IErrorLogVtbl IErrorLogVtbl; +struct IErrorLog { + const IErrorLogVtbl* lpVtbl; +}; +struct IErrorLogVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IErrorLog* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IErrorLog* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IErrorLog* This); + + /*** IErrorLog methods ***/ + HRESULT (STDMETHODCALLTYPE *AddError)( + IErrorLog* This, + LPCOLESTR pszPropName, + EXCEPINFO* pExcepInfo); + +}; + +/*** IUnknown methods ***/ +#define IErrorLog_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IErrorLog_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IErrorLog_Release(p) (p)->lpVtbl->Release(p) +/*** IErrorLog methods ***/ +#define IErrorLog_AddError(p,a,b) (p)->lpVtbl->AddError(p,a,b) + +#endif + +#define IErrorLog_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IErrorLog methods ***/ \ + STDMETHOD_(HRESULT,AddError)(THIS_ LPCOLESTR pszPropName, EXCEPINFO* pExcepInfo) PURE; + +HRESULT CALLBACK IErrorLog_AddError_Proxy( + IErrorLog* This, + LPCOLESTR pszPropName, + EXCEPINFO* pExcepInfo); +void __RPC_STUB IErrorLog_AddError_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IErrorLog_INTERFACE_DEFINED__ */ + +#ifndef __IPropertyBag_FWD_DEFINED__ +#define __IPropertyBag_FWD_DEFINED__ +typedef struct IPropertyBag IPropertyBag; +#endif + +typedef IPropertyBag *LPPROPERTYBAG; + +/***************************************************************************** + * IPropertyBag interface + */ +#ifndef __IPropertyBag_INTERFACE_DEFINED__ +#define __IPropertyBag_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IPropertyBag, 0x55272a00, 0x42cb, 0x11ce, 0x81,0x35, 0x00,0xaa,0x00,0x4b,0xb8,0x51); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPropertyBag : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Read( + LPCOLESTR pszPropName, + VARIANT* pVar, + IErrorLog* pErrorLog) = 0; + + virtual HRESULT STDMETHODCALLTYPE Write( + LPCOLESTR pszPropName, + VARIANT* pVar) = 0; + +}; +#else +typedef struct IPropertyBagVtbl IPropertyBagVtbl; +struct IPropertyBag { + const IPropertyBagVtbl* lpVtbl; +}; +struct IPropertyBagVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPropertyBag* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPropertyBag* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPropertyBag* This); + + /*** IPropertyBag methods ***/ + HRESULT (STDMETHODCALLTYPE *Read)( + IPropertyBag* This, + LPCOLESTR pszPropName, + VARIANT* pVar, + IErrorLog* pErrorLog); + + HRESULT (STDMETHODCALLTYPE *Write)( + IPropertyBag* This, + LPCOLESTR pszPropName, + VARIANT* pVar); + +}; + +/*** IUnknown methods ***/ +#define IPropertyBag_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPropertyBag_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPropertyBag_Release(p) (p)->lpVtbl->Release(p) +/*** IPropertyBag methods ***/ +#define IPropertyBag_Read(p,a,b,c) (p)->lpVtbl->Read(p,a,b,c) +#define IPropertyBag_Write(p,a,b) (p)->lpVtbl->Write(p,a,b) + +#endif + +#define IPropertyBag_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IPropertyBag methods ***/ \ + STDMETHOD_(HRESULT,Read)(THIS_ LPCOLESTR pszPropName, VARIANT* pVar, IErrorLog* pErrorLog) PURE; \ + STDMETHOD_(HRESULT,Write)(THIS_ LPCOLESTR pszPropName, VARIANT* pVar) PURE; + +HRESULT CALLBACK IPropertyBag_RemoteRead_Proxy( + IPropertyBag* This, + LPCOLESTR pszPropName, + VARIANT* pVar, + IErrorLog* pErrorLog, + DWORD varType, + IUnknown* pUnkObj); +void __RPC_STUB IPropertyBag_RemoteRead_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyBag_Read_Proxy( + IPropertyBag* This, + LPCOLESTR pszPropName, + VARIANT* pVar, + IErrorLog* pErrorLog); +HRESULT __RPC_STUB IPropertyBag_Read_Stub( + IPropertyBag* This, + LPCOLESTR pszPropName, + VARIANT* pVar, + IErrorLog* pErrorLog, + DWORD varType, + IUnknown* pUnkObj); +HRESULT CALLBACK IPropertyBag_Write_Proxy( + IPropertyBag* This, + LPCOLESTR pszPropName, + VARIANT* pVar); +void __RPC_STUB IPropertyBag_Write_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPropertyBag_INTERFACE_DEFINED__ */ + #ifdef __cplusplus } #endif diff --git a/include/oaidl.idl b/include/oaidl.idl index 89c5c6ca0e1..e0b4c72a99c 100644 --- a/include/oaidl.idl +++ b/include/oaidl.idl @@ -1576,3 +1576,53 @@ interface ICreateTypeLib2 : ICreateTypeLib HRESULT SetHelpStringDll( [in] LPOLESTR szFileName); } + + +/***************************************************************************** + * IErrorLog interface + */ +[ + object, + uuid(3127ca40-446e-11ce-8135-00aa004bb851), + pointer_default(unique) +] +interface IErrorLog : IUnknown +{ + typedef IErrorLog *LPERRORLOG; + + HRESULT AddError( + [in] LPCOLESTR pszPropName, + [in] EXCEPINFO *pExcepInfo); +} + + +/***************************************************************************** + * IPropertyBag interface + */ +[ + object, + uuid(55272a00-42cb-11ce-8135-00aa004bb851), + pointer_default(unique) +] +interface IPropertyBag : IUnknown +{ + typedef IPropertyBag *LPPROPERTYBAG; + + [local] + HRESULT Read( + [in] LPCOLESTR pszPropName, + [in, out] VARIANT *pVar, + [in] IErrorLog *pErrorLog); + + [call_as(Read)] + HRESULT RemoteRead( + [in] LPCOLESTR pszPropName, + [out] VARIANT *pVar, + [in] IErrorLog *pErrorLog, + [in] DWORD varType, + [in] IUnknown *pUnkObj); + + HRESULT Write( + [in] LPCOLESTR pszPropName, + [in] VARIANT *pVar); +} diff --git a/include/ocidl.h b/include/ocidl.h index b65e242fccd..87659307619 100644 --- a/include/ocidl.h +++ b/include/ocidl.h @@ -1,49 +1,6194 @@ -/* - * Copyright (C) 1999 Francis Beaudet - * - * 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 - */ - +/*** Autogenerated by WIDL 0.1 from ocidl.idl - Do not edit ***/ #include #include -#ifndef COM_NO_WINDOWS_H -#include -#include + +#ifndef __WIDL_OCIDL_H +#define __WIDL_OCIDL_H +#ifdef __cplusplus +extern "C" { #endif - -#ifndef __WINE_OCIDL_H -#define __WINE_OCIDL_H - -#if defined(__WINESRC__) && !defined(INITGUID) && !defined(__WINE_INCLUDE_OCIDL) -#error DO NOT INCLUDE DIRECTLY -#endif - -#define __WINE_INCLUDE_OLEIDL #include -#undef __WINE_INCLUDE_OLEIDL - -#define __WINE_INCLUDE_OAIDL #include -#undef __WINE_INCLUDE_OAIDL +#include +#include +typedef enum tagREADYSTATE { + READYSTATE_UNINITIALIZED = 0, + READYSTATE_LOADING = 1, + READYSTATE_LOADED = 2, + READYSTATE_INTERACTIVE = 3, + READYSTATE_COMPLETE = 4 +} READYSTATE; -#include -#include +typedef struct tagVARIANT_BLOB { + DWORD clSize; + DWORD rpcReserved; + ULONGLONG ahData[1]; +} wireVARIANT_BLOB; -#include -#include -#include -#include +typedef struct tagUserVARIANT { + wireVARIANT_BLOB pVarBlob; +} UserVARIANT; -#endif /* __WINE_OCIDL_H */ +#ifndef __IFont_FWD_DEFINED__ +#define __IFont_FWD_DEFINED__ +typedef struct IFont IFont; +#endif + +typedef IFont *LPFONT; + +typedef TEXTMETRICW TEXTMETRICOLE, *LPTEXTMETRICOLE; + +/***************************************************************************** + * IFont interface + */ +#ifndef __IFont_INTERFACE_DEFINED__ +#define __IFont_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IFont, 0xbef6e002, 0xa874, 0x101a, 0x8b,0xba, 0x00,0xaa,0x00,0x30,0x0c,0xab); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IFont : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE get_Name( + BSTR* pname) = 0; + + virtual HRESULT STDMETHODCALLTYPE put_Name( + BSTR name) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_Size( + CY* psize) = 0; + + virtual HRESULT STDMETHODCALLTYPE put_Size( + CY size) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_Bold( + BOOL* pbold) = 0; + + virtual HRESULT STDMETHODCALLTYPE put_Bold( + BOOL bold) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_Italic( + BOOL* pitalic) = 0; + + virtual HRESULT STDMETHODCALLTYPE put_Italic( + BOOL italic) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_Underline( + BOOL* punderline) = 0; + + virtual HRESULT STDMETHODCALLTYPE put_Underline( + BOOL underline) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_Strikethrough( + BOOL* pstrikethrough) = 0; + + virtual HRESULT STDMETHODCALLTYPE put_Strikethrough( + BOOL strikethrough) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_Weight( + SHORT* pweight) = 0; + + virtual HRESULT STDMETHODCALLTYPE put_Weight( + SHORT weight) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_Charset( + SHORT* pcharset) = 0; + + virtual HRESULT STDMETHODCALLTYPE put_Charset( + SHORT charset) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_hFont( + HFONT* phfont) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + IFont** ppfont) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsEqual( + IFont* pFontOther) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetRatio( + LONG cyLogical, + LONG cyHimetric) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueryTextMetrics( + TEXTMETRICOLE* ptm) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddRefHfont( + HFONT hfont) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReleaseHfont( + HFONT hfont) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetHdc( + HDC hdc) = 0; + +}; +#else +typedef struct IFontVtbl IFontVtbl; +struct IFont { + const IFontVtbl* lpVtbl; +}; +struct IFontVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IFont* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IFont* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IFont* This); + + /*** IFont methods ***/ + HRESULT (STDMETHODCALLTYPE *get_Name)( + IFont* This, + BSTR* pname); + + HRESULT (STDMETHODCALLTYPE *put_Name)( + IFont* This, + BSTR name); + + HRESULT (STDMETHODCALLTYPE *get_Size)( + IFont* This, + CY* psize); + + HRESULT (STDMETHODCALLTYPE *put_Size)( + IFont* This, + CY size); + + HRESULT (STDMETHODCALLTYPE *get_Bold)( + IFont* This, + BOOL* pbold); + + HRESULT (STDMETHODCALLTYPE *put_Bold)( + IFont* This, + BOOL bold); + + HRESULT (STDMETHODCALLTYPE *get_Italic)( + IFont* This, + BOOL* pitalic); + + HRESULT (STDMETHODCALLTYPE *put_Italic)( + IFont* This, + BOOL italic); + + HRESULT (STDMETHODCALLTYPE *get_Underline)( + IFont* This, + BOOL* punderline); + + HRESULT (STDMETHODCALLTYPE *put_Underline)( + IFont* This, + BOOL underline); + + HRESULT (STDMETHODCALLTYPE *get_Strikethrough)( + IFont* This, + BOOL* pstrikethrough); + + HRESULT (STDMETHODCALLTYPE *put_Strikethrough)( + IFont* This, + BOOL strikethrough); + + HRESULT (STDMETHODCALLTYPE *get_Weight)( + IFont* This, + SHORT* pweight); + + HRESULT (STDMETHODCALLTYPE *put_Weight)( + IFont* This, + SHORT weight); + + HRESULT (STDMETHODCALLTYPE *get_Charset)( + IFont* This, + SHORT* pcharset); + + HRESULT (STDMETHODCALLTYPE *put_Charset)( + IFont* This, + SHORT charset); + + HRESULT (STDMETHODCALLTYPE *get_hFont)( + IFont* This, + HFONT* phfont); + + HRESULT (STDMETHODCALLTYPE *Clone)( + IFont* This, + IFont** ppfont); + + HRESULT (STDMETHODCALLTYPE *IsEqual)( + IFont* This, + IFont* pFontOther); + + HRESULT (STDMETHODCALLTYPE *SetRatio)( + IFont* This, + LONG cyLogical, + LONG cyHimetric); + + HRESULT (STDMETHODCALLTYPE *QueryTextMetrics)( + IFont* This, + TEXTMETRICOLE* ptm); + + HRESULT (STDMETHODCALLTYPE *AddRefHfont)( + IFont* This, + HFONT hfont); + + HRESULT (STDMETHODCALLTYPE *ReleaseHfont)( + IFont* This, + HFONT hfont); + + HRESULT (STDMETHODCALLTYPE *SetHdc)( + IFont* This, + HDC hdc); + +}; + +/*** IUnknown methods ***/ +#define IFont_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IFont_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IFont_Release(p) (p)->lpVtbl->Release(p) +/*** IFont methods ***/ +#define IFont_get_Name(p,a) (p)->lpVtbl->get_Name(p,a) +#define IFont_put_Name(p,a) (p)->lpVtbl->put_Name(p,a) +#define IFont_get_Size(p,a) (p)->lpVtbl->get_Size(p,a) +#define IFont_put_Size(p,a) (p)->lpVtbl->put_Size(p,a) +#define IFont_get_Bold(p,a) (p)->lpVtbl->get_Bold(p,a) +#define IFont_put_Bold(p,a) (p)->lpVtbl->put_Bold(p,a) +#define IFont_get_Italic(p,a) (p)->lpVtbl->get_Italic(p,a) +#define IFont_put_Italic(p,a) (p)->lpVtbl->put_Italic(p,a) +#define IFont_get_Underline(p,a) (p)->lpVtbl->get_Underline(p,a) +#define IFont_put_Underline(p,a) (p)->lpVtbl->put_Underline(p,a) +#define IFont_get_Strikethrough(p,a) (p)->lpVtbl->get_Strikethrough(p,a) +#define IFont_put_Strikethrough(p,a) (p)->lpVtbl->put_Strikethrough(p,a) +#define IFont_get_Weight(p,a) (p)->lpVtbl->get_Weight(p,a) +#define IFont_put_Weight(p,a) (p)->lpVtbl->put_Weight(p,a) +#define IFont_get_Charset(p,a) (p)->lpVtbl->get_Charset(p,a) +#define IFont_put_Charset(p,a) (p)->lpVtbl->put_Charset(p,a) +#define IFont_get_hFont(p,a) (p)->lpVtbl->get_hFont(p,a) +#define IFont_Clone(p,a) (p)->lpVtbl->Clone(p,a) +#define IFont_IsEqual(p,a) (p)->lpVtbl->IsEqual(p,a) +#define IFont_SetRatio(p,a,b) (p)->lpVtbl->SetRatio(p,a,b) +#define IFont_QueryTextMetrics(p,a) (p)->lpVtbl->QueryTextMetrics(p,a) +#define IFont_AddRefHfont(p,a) (p)->lpVtbl->AddRefHfont(p,a) +#define IFont_ReleaseHfont(p,a) (p)->lpVtbl->ReleaseHfont(p,a) +#define IFont_SetHdc(p,a) (p)->lpVtbl->SetHdc(p,a) + +#endif + +#define IFont_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IFont methods ***/ \ + STDMETHOD_(HRESULT,get_Name)(THIS_ BSTR* pname) PURE; \ + STDMETHOD_(HRESULT,put_Name)(THIS_ BSTR name) PURE; \ + STDMETHOD_(HRESULT,get_Size)(THIS_ CY* psize) PURE; \ + STDMETHOD_(HRESULT,put_Size)(THIS_ CY size) PURE; \ + STDMETHOD_(HRESULT,get_Bold)(THIS_ BOOL* pbold) PURE; \ + STDMETHOD_(HRESULT,put_Bold)(THIS_ BOOL bold) PURE; \ + STDMETHOD_(HRESULT,get_Italic)(THIS_ BOOL* pitalic) PURE; \ + STDMETHOD_(HRESULT,put_Italic)(THIS_ BOOL italic) PURE; \ + STDMETHOD_(HRESULT,get_Underline)(THIS_ BOOL* punderline) PURE; \ + STDMETHOD_(HRESULT,put_Underline)(THIS_ BOOL underline) PURE; \ + STDMETHOD_(HRESULT,get_Strikethrough)(THIS_ BOOL* pstrikethrough) PURE; \ + STDMETHOD_(HRESULT,put_Strikethrough)(THIS_ BOOL strikethrough) PURE; \ + STDMETHOD_(HRESULT,get_Weight)(THIS_ SHORT* pweight) PURE; \ + STDMETHOD_(HRESULT,put_Weight)(THIS_ SHORT weight) PURE; \ + STDMETHOD_(HRESULT,get_Charset)(THIS_ SHORT* pcharset) PURE; \ + STDMETHOD_(HRESULT,put_Charset)(THIS_ SHORT charset) PURE; \ + STDMETHOD_(HRESULT,get_hFont)(THIS_ HFONT* phfont) PURE; \ + STDMETHOD_(HRESULT,Clone)(THIS_ IFont** ppfont) PURE; \ + STDMETHOD_(HRESULT,IsEqual)(THIS_ IFont* pFontOther) PURE; \ + STDMETHOD_(HRESULT,SetRatio)(THIS_ LONG cyLogical, LONG cyHimetric) PURE; \ + STDMETHOD_(HRESULT,QueryTextMetrics)(THIS_ TEXTMETRICOLE* ptm) PURE; \ + STDMETHOD_(HRESULT,AddRefHfont)(THIS_ HFONT hfont) PURE; \ + STDMETHOD_(HRESULT,ReleaseHfont)(THIS_ HFONT hfont) PURE; \ + STDMETHOD_(HRESULT,SetHdc)(THIS_ HDC hdc) PURE; + +HRESULT CALLBACK IFont_get_Name_Proxy( + IFont* This, + BSTR* pname); +void __RPC_STUB IFont_get_Name_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_put_Name_Proxy( + IFont* This, + BSTR name); +void __RPC_STUB IFont_put_Name_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_get_Size_Proxy( + IFont* This, + CY* psize); +void __RPC_STUB IFont_get_Size_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_put_Size_Proxy( + IFont* This, + CY size); +void __RPC_STUB IFont_put_Size_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_get_Bold_Proxy( + IFont* This, + BOOL* pbold); +void __RPC_STUB IFont_get_Bold_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_put_Bold_Proxy( + IFont* This, + BOOL bold); +void __RPC_STUB IFont_put_Bold_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_get_Italic_Proxy( + IFont* This, + BOOL* pitalic); +void __RPC_STUB IFont_get_Italic_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_put_Italic_Proxy( + IFont* This, + BOOL italic); +void __RPC_STUB IFont_put_Italic_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_get_Underline_Proxy( + IFont* This, + BOOL* punderline); +void __RPC_STUB IFont_get_Underline_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_put_Underline_Proxy( + IFont* This, + BOOL underline); +void __RPC_STUB IFont_put_Underline_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_get_Strikethrough_Proxy( + IFont* This, + BOOL* pstrikethrough); +void __RPC_STUB IFont_get_Strikethrough_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_put_Strikethrough_Proxy( + IFont* This, + BOOL strikethrough); +void __RPC_STUB IFont_put_Strikethrough_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_get_Weight_Proxy( + IFont* This, + SHORT* pweight); +void __RPC_STUB IFont_get_Weight_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_put_Weight_Proxy( + IFont* This, + SHORT weight); +void __RPC_STUB IFont_put_Weight_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_get_Charset_Proxy( + IFont* This, + SHORT* pcharset); +void __RPC_STUB IFont_get_Charset_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_put_Charset_Proxy( + IFont* This, + SHORT charset); +void __RPC_STUB IFont_put_Charset_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_get_hFont_Proxy( + IFont* This, + HFONT* phfont); +void __RPC_STUB IFont_get_hFont_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_Clone_Proxy( + IFont* This, + IFont** ppfont); +void __RPC_STUB IFont_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_IsEqual_Proxy( + IFont* This, + IFont* pFontOther); +void __RPC_STUB IFont_IsEqual_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_SetRatio_Proxy( + IFont* This, + LONG cyLogical, + LONG cyHimetric); +void __RPC_STUB IFont_SetRatio_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_QueryTextMetrics_Proxy( + IFont* This, + TEXTMETRICOLE* ptm); +void __RPC_STUB IFont_QueryTextMetrics_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_AddRefHfont_Proxy( + IFont* This, + HFONT hfont); +void __RPC_STUB IFont_AddRefHfont_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_ReleaseHfont_Proxy( + IFont* This, + HFONT hfont); +void __RPC_STUB IFont_ReleaseHfont_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFont_SetHdc_Proxy( + IFont* This, + HDC hdc); +void __RPC_STUB IFont_SetHdc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IFont_INTERFACE_DEFINED__ */ + +#ifndef __IFontDisp_FWD_DEFINED__ +#define __IFontDisp_FWD_DEFINED__ +typedef struct IFontDisp IFontDisp; +#endif + +typedef IFontDisp *LPFONTDISP; + +/***************************************************************************** + * IFontDisp interface + */ +#ifndef __IFontDisp_INTERFACE_DEFINED__ +#define __IFontDisp_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IFontDisp, 0xbef6e003, 0xa874, 0x101a, 0x8b,0xba, 0x00,0xaa,0x00,0x30,0x0c,0xab); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IFontDisp : public IDispatch +{ +}; +#else +typedef struct IFontDispVtbl IFontDispVtbl; +struct IFontDisp { + const IFontDispVtbl* lpVtbl; +}; +struct IFontDispVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IFontDisp* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IFontDisp* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IFontDisp* This); + + /*** IDispatch methods ***/ + HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( + IFontDisp* This, + UINT* pctinfo); + + HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( + IFontDisp* This, + UINT iTInfo, + LCID lcid, + ITypeInfo** ppTInfo); + + HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( + IFontDisp* This, + REFIID riid, + LPOLESTR* rgszNames, + UINT cNames, + LCID lcid, + DISPID* rgDispId); + + HRESULT (STDMETHODCALLTYPE *Invoke)( + IFontDisp* This, + DISPID dispIdMember, + REFIID riid, + LCID lcid, + WORD wFlags, + DISPPARAMS* pDispParams, + VARIANT* pVarResult, + EXCEPINFO* pExcepInfo, + UINT* puArgErr); + +}; + +/*** IUnknown methods ***/ +#define IFontDisp_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IFontDisp_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IFontDisp_Release(p) (p)->lpVtbl->Release(p) +/*** IDispatch methods ***/ +#define IFontDisp_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a) +#define IFontDisp_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c) +#define IFontDisp_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e) +#define IFontDisp_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h) + +#endif + +#define IFontDisp_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IDispatch methods ***/ \ + STDMETHOD_(HRESULT,GetTypeInfoCount)(THIS_ UINT* pctinfo) PURE; \ + STDMETHOD_(HRESULT,GetTypeInfo)(THIS_ UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo) PURE; \ + STDMETHOD_(HRESULT,GetIDsOfNames)(THIS_ REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId) PURE; \ + STDMETHOD_(HRESULT,Invoke)(THIS_ DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr) PURE; + + +#endif /* __IFontDisp_INTERFACE_DEFINED__ */ + +#ifndef __IPicture_FWD_DEFINED__ +#define __IPicture_FWD_DEFINED__ +typedef struct IPicture IPicture; +#endif + +typedef IPicture *LPPICTURE; + +typedef enum tagPicture { + PICTURE_SCALABLE = 0x1, + PICTURE_TRANSPARENT = 0x2 +} PICTUREATTRIBUTES; + +typedef UINT OLE_HANDLE; + +typedef LONG OLE_XPOS_HIMETRIC; + +typedef LONG OLE_YPOS_HIMETRIC; + +typedef LONG OLE_XSIZE_HIMETRIC; + +typedef LONG OLE_YSIZE_HIMETRIC; + +/***************************************************************************** + * IPicture interface + */ +#ifndef __IPicture_INTERFACE_DEFINED__ +#define __IPicture_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IPicture, 0x7bf80980, 0xbf32, 0x101a, 0x8b,0xbb, 0x00,0xaa,0x00,0x30,0x0c,0xab); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPicture : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE get_Handle( + OLE_HANDLE* pHandle) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_hPal( + OLE_HANDLE* phPal) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_Type( + SHORT* pType) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_Width( + OLE_XSIZE_HIMETRIC* pWidth) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_Height( + OLE_YSIZE_HIMETRIC* pHeight) = 0; + + virtual HRESULT STDMETHODCALLTYPE Render( + HDC hdc, + LONG x, + LONG y, + LONG cx, + LONG cy, + OLE_XPOS_HIMETRIC xSrc, + OLE_YPOS_HIMETRIC ySrc, + OLE_XSIZE_HIMETRIC cxSrc, + OLE_YSIZE_HIMETRIC cySrc, + LPCRECT pRcWBounds) = 0; + + virtual HRESULT STDMETHODCALLTYPE set_hPal( + OLE_HANDLE hPal) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_CurDC( + HDC* phDC) = 0; + + virtual HRESULT STDMETHODCALLTYPE SelectPicture( + HDC hDCIn, + HDC* phDCOut, + OLE_HANDLE* phBmpOut) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_KeepOriginalFormat( + BOOL* pKeep) = 0; + + virtual HRESULT STDMETHODCALLTYPE put_KeepOriginalFormat( + BOOL keep) = 0; + + virtual HRESULT STDMETHODCALLTYPE PictureChanged( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE SaveAsFile( + LPSTREAM pStream, + BOOL fSaveMemCopy, + LONG* pCbSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_Attributes( + DWORD* pDwAttr) = 0; + +}; +#else +typedef struct IPictureVtbl IPictureVtbl; +struct IPicture { + const IPictureVtbl* lpVtbl; +}; +struct IPictureVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPicture* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPicture* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPicture* This); + + /*** IPicture methods ***/ + HRESULT (STDMETHODCALLTYPE *get_Handle)( + IPicture* This, + OLE_HANDLE* pHandle); + + HRESULT (STDMETHODCALLTYPE *get_hPal)( + IPicture* This, + OLE_HANDLE* phPal); + + HRESULT (STDMETHODCALLTYPE *get_Type)( + IPicture* This, + SHORT* pType); + + HRESULT (STDMETHODCALLTYPE *get_Width)( + IPicture* This, + OLE_XSIZE_HIMETRIC* pWidth); + + HRESULT (STDMETHODCALLTYPE *get_Height)( + IPicture* This, + OLE_YSIZE_HIMETRIC* pHeight); + + HRESULT (STDMETHODCALLTYPE *Render)( + IPicture* This, + HDC hdc, + LONG x, + LONG y, + LONG cx, + LONG cy, + OLE_XPOS_HIMETRIC xSrc, + OLE_YPOS_HIMETRIC ySrc, + OLE_XSIZE_HIMETRIC cxSrc, + OLE_YSIZE_HIMETRIC cySrc, + LPCRECT pRcWBounds); + + HRESULT (STDMETHODCALLTYPE *set_hPal)( + IPicture* This, + OLE_HANDLE hPal); + + HRESULT (STDMETHODCALLTYPE *get_CurDC)( + IPicture* This, + HDC* phDC); + + HRESULT (STDMETHODCALLTYPE *SelectPicture)( + IPicture* This, + HDC hDCIn, + HDC* phDCOut, + OLE_HANDLE* phBmpOut); + + HRESULT (STDMETHODCALLTYPE *get_KeepOriginalFormat)( + IPicture* This, + BOOL* pKeep); + + HRESULT (STDMETHODCALLTYPE *put_KeepOriginalFormat)( + IPicture* This, + BOOL keep); + + HRESULT (STDMETHODCALLTYPE *PictureChanged)( + IPicture* This); + + HRESULT (STDMETHODCALLTYPE *SaveAsFile)( + IPicture* This, + LPSTREAM pStream, + BOOL fSaveMemCopy, + LONG* pCbSize); + + HRESULT (STDMETHODCALLTYPE *get_Attributes)( + IPicture* This, + DWORD* pDwAttr); + +}; + +/*** IUnknown methods ***/ +#define IPicture_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPicture_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPicture_Release(p) (p)->lpVtbl->Release(p) +/*** IPicture methods ***/ +#define IPicture_get_Handle(p,a) (p)->lpVtbl->get_Handle(p,a) +#define IPicture_get_hPal(p,a) (p)->lpVtbl->get_hPal(p,a) +#define IPicture_get_Type(p,a) (p)->lpVtbl->get_Type(p,a) +#define IPicture_get_Width(p,a) (p)->lpVtbl->get_Width(p,a) +#define IPicture_get_Height(p,a) (p)->lpVtbl->get_Height(p,a) +#define IPicture_Render(p,a,b,c,d,e,f,g,h,i,j) (p)->lpVtbl->Render(p,a,b,c,d,e,f,g,h,i,j) +#define IPicture_set_hPal(p,a) (p)->lpVtbl->set_hPal(p,a) +#define IPicture_get_CurDC(p,a) (p)->lpVtbl->get_CurDC(p,a) +#define IPicture_SelectPicture(p,a,b,c) (p)->lpVtbl->SelectPicture(p,a,b,c) +#define IPicture_get_KeepOriginalFormat(p,a) (p)->lpVtbl->get_KeepOriginalFormat(p,a) +#define IPicture_put_KeepOriginalFormat(p,a) (p)->lpVtbl->put_KeepOriginalFormat(p,a) +#define IPicture_PictureChanged(p) (p)->lpVtbl->PictureChanged(p) +#define IPicture_SaveAsFile(p,a,b,c) (p)->lpVtbl->SaveAsFile(p,a,b,c) +#define IPicture_get_Attributes(p,a) (p)->lpVtbl->get_Attributes(p,a) + +#endif + +#define IPicture_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IPicture methods ***/ \ + STDMETHOD_(HRESULT,get_Handle)(THIS_ OLE_HANDLE* pHandle) PURE; \ + STDMETHOD_(HRESULT,get_hPal)(THIS_ OLE_HANDLE* phPal) PURE; \ + STDMETHOD_(HRESULT,get_Type)(THIS_ SHORT* pType) PURE; \ + STDMETHOD_(HRESULT,get_Width)(THIS_ OLE_XSIZE_HIMETRIC* pWidth) PURE; \ + STDMETHOD_(HRESULT,get_Height)(THIS_ OLE_YSIZE_HIMETRIC* pHeight) PURE; \ + STDMETHOD_(HRESULT,Render)(THIS_ HDC hdc, LONG x, LONG y, LONG cx, LONG cy, OLE_XPOS_HIMETRIC xSrc, OLE_YPOS_HIMETRIC ySrc, OLE_XSIZE_HIMETRIC cxSrc, OLE_YSIZE_HIMETRIC cySrc, LPCRECT pRcWBounds) PURE; \ + STDMETHOD_(HRESULT,set_hPal)(THIS_ OLE_HANDLE hPal) PURE; \ + STDMETHOD_(HRESULT,get_CurDC)(THIS_ HDC* phDC) PURE; \ + STDMETHOD_(HRESULT,SelectPicture)(THIS_ HDC hDCIn, HDC* phDCOut, OLE_HANDLE* phBmpOut) PURE; \ + STDMETHOD_(HRESULT,get_KeepOriginalFormat)(THIS_ BOOL* pKeep) PURE; \ + STDMETHOD_(HRESULT,put_KeepOriginalFormat)(THIS_ BOOL keep) PURE; \ + STDMETHOD_(HRESULT,PictureChanged)(THIS) PURE; \ + STDMETHOD_(HRESULT,SaveAsFile)(THIS_ LPSTREAM pStream, BOOL fSaveMemCopy, LONG* pCbSize) PURE; \ + STDMETHOD_(HRESULT,get_Attributes)(THIS_ DWORD* pDwAttr) PURE; + +HRESULT CALLBACK IPicture_get_Handle_Proxy( + IPicture* This, + OLE_HANDLE* pHandle); +void __RPC_STUB IPicture_get_Handle_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPicture_get_hPal_Proxy( + IPicture* This, + OLE_HANDLE* phPal); +void __RPC_STUB IPicture_get_hPal_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPicture_get_Type_Proxy( + IPicture* This, + SHORT* pType); +void __RPC_STUB IPicture_get_Type_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPicture_get_Width_Proxy( + IPicture* This, + OLE_XSIZE_HIMETRIC* pWidth); +void __RPC_STUB IPicture_get_Width_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPicture_get_Height_Proxy( + IPicture* This, + OLE_YSIZE_HIMETRIC* pHeight); +void __RPC_STUB IPicture_get_Height_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPicture_Render_Proxy( + IPicture* This, + HDC hdc, + LONG x, + LONG y, + LONG cx, + LONG cy, + OLE_XPOS_HIMETRIC xSrc, + OLE_YPOS_HIMETRIC ySrc, + OLE_XSIZE_HIMETRIC cxSrc, + OLE_YSIZE_HIMETRIC cySrc, + LPCRECT pRcWBounds); +void __RPC_STUB IPicture_Render_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPicture_set_hPal_Proxy( + IPicture* This, + OLE_HANDLE hPal); +void __RPC_STUB IPicture_set_hPal_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPicture_get_CurDC_Proxy( + IPicture* This, + HDC* phDC); +void __RPC_STUB IPicture_get_CurDC_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPicture_SelectPicture_Proxy( + IPicture* This, + HDC hDCIn, + HDC* phDCOut, + OLE_HANDLE* phBmpOut); +void __RPC_STUB IPicture_SelectPicture_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPicture_get_KeepOriginalFormat_Proxy( + IPicture* This, + BOOL* pKeep); +void __RPC_STUB IPicture_get_KeepOriginalFormat_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPicture_put_KeepOriginalFormat_Proxy( + IPicture* This, + BOOL keep); +void __RPC_STUB IPicture_put_KeepOriginalFormat_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPicture_PictureChanged_Proxy( + IPicture* This); +void __RPC_STUB IPicture_PictureChanged_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPicture_SaveAsFile_Proxy( + IPicture* This, + LPSTREAM pStream, + BOOL fSaveMemCopy, + LONG* pCbSize); +void __RPC_STUB IPicture_SaveAsFile_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPicture_get_Attributes_Proxy( + IPicture* This, + DWORD* pDwAttr); +void __RPC_STUB IPicture_get_Attributes_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPicture_INTERFACE_DEFINED__ */ + +#ifndef __IPictureDisp_FWD_DEFINED__ +#define __IPictureDisp_FWD_DEFINED__ +typedef struct IPictureDisp IPictureDisp; +#endif + +typedef IPictureDisp *LPPICTUREDISP; + +/***************************************************************************** + * IPictureDisp interface + */ +#ifndef __IPictureDisp_INTERFACE_DEFINED__ +#define __IPictureDisp_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IPictureDisp, 0x7bf80981, 0xbf32, 0x101a, 0x8b,0xbb, 0x00,0xaa,0x00,0x30,0x0c,0xab); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPictureDisp : public IDispatch +{ +}; +#else +typedef struct IPictureDispVtbl IPictureDispVtbl; +struct IPictureDisp { + const IPictureDispVtbl* lpVtbl; +}; +struct IPictureDispVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPictureDisp* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPictureDisp* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPictureDisp* This); + + /*** IDispatch methods ***/ + HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)( + IPictureDisp* This, + UINT* pctinfo); + + HRESULT (STDMETHODCALLTYPE *GetTypeInfo)( + IPictureDisp* This, + UINT iTInfo, + LCID lcid, + ITypeInfo** ppTInfo); + + HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)( + IPictureDisp* This, + REFIID riid, + LPOLESTR* rgszNames, + UINT cNames, + LCID lcid, + DISPID* rgDispId); + + HRESULT (STDMETHODCALLTYPE *Invoke)( + IPictureDisp* This, + DISPID dispIdMember, + REFIID riid, + LCID lcid, + WORD wFlags, + DISPPARAMS* pDispParams, + VARIANT* pVarResult, + EXCEPINFO* pExcepInfo, + UINT* puArgErr); + +}; + +/*** IUnknown methods ***/ +#define IPictureDisp_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPictureDisp_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPictureDisp_Release(p) (p)->lpVtbl->Release(p) +/*** IDispatch methods ***/ +#define IPictureDisp_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a) +#define IPictureDisp_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c) +#define IPictureDisp_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e) +#define IPictureDisp_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h) + +#endif + +#define IPictureDisp_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IDispatch methods ***/ \ + STDMETHOD_(HRESULT,GetTypeInfoCount)(THIS_ UINT* pctinfo) PURE; \ + STDMETHOD_(HRESULT,GetTypeInfo)(THIS_ UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo) PURE; \ + STDMETHOD_(HRESULT,GetIDsOfNames)(THIS_ REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId) PURE; \ + STDMETHOD_(HRESULT,Invoke)(THIS_ DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr) PURE; + + +#endif /* __IPictureDisp_INTERFACE_DEFINED__ */ + +#ifndef __IOleControl_FWD_DEFINED__ +#define __IOleControl_FWD_DEFINED__ +typedef struct IOleControl IOleControl; +#endif + +typedef IOleControl *LPOLECONTROL; + +typedef struct tagCONTROLINFO { + ULONG cb; + HACCEL hAccel; + USHORT cAccel; + DWORD dwFlags; +} CONTROLINFO, *LPCONTROLINFO; + +typedef enum tagCTRLINFO { + CTRLINFO_EATS_RETURN = 1, + CTRLINFO_EATS_ESCAPE = 2 +} CTRLINFO; + +/***************************************************************************** + * IOleControl interface + */ +#ifndef __IOleControl_INTERFACE_DEFINED__ +#define __IOleControl_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IOleControl, 0xb196b288, 0xbab4, 0x101a, 0xb6,0x9c, 0x00,0xaa,0x00,0x34,0x1d,0x07); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IOleControl : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetControlInfo( + CONTROLINFO* pCI) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnMnemonic( + MSG* pMsg) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnAmbientPropertyChange( + DISPID dispID) = 0; + + virtual HRESULT STDMETHODCALLTYPE FreezeEvents( + BOOL bFreeze) = 0; + +}; +#else +typedef struct IOleControlVtbl IOleControlVtbl; +struct IOleControl { + const IOleControlVtbl* lpVtbl; +}; +struct IOleControlVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IOleControl* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IOleControl* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IOleControl* This); + + /*** IOleControl methods ***/ + HRESULT (STDMETHODCALLTYPE *GetControlInfo)( + IOleControl* This, + CONTROLINFO* pCI); + + HRESULT (STDMETHODCALLTYPE *OnMnemonic)( + IOleControl* This, + MSG* pMsg); + + HRESULT (STDMETHODCALLTYPE *OnAmbientPropertyChange)( + IOleControl* This, + DISPID dispID); + + HRESULT (STDMETHODCALLTYPE *FreezeEvents)( + IOleControl* This, + BOOL bFreeze); + +}; + +/*** IUnknown methods ***/ +#define IOleControl_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IOleControl_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IOleControl_Release(p) (p)->lpVtbl->Release(p) +/*** IOleControl methods ***/ +#define IOleControl_GetControlInfo(p,a) (p)->lpVtbl->GetControlInfo(p,a) +#define IOleControl_OnMnemonic(p,a) (p)->lpVtbl->OnMnemonic(p,a) +#define IOleControl_OnAmbientPropertyChange(p,a) (p)->lpVtbl->OnAmbientPropertyChange(p,a) +#define IOleControl_FreezeEvents(p,a) (p)->lpVtbl->FreezeEvents(p,a) + +#endif + +#define IOleControl_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IOleControl methods ***/ \ + STDMETHOD_(HRESULT,GetControlInfo)(THIS_ CONTROLINFO* pCI) PURE; \ + STDMETHOD_(HRESULT,OnMnemonic)(THIS_ MSG* pMsg) PURE; \ + STDMETHOD_(HRESULT,OnAmbientPropertyChange)(THIS_ DISPID dispID) PURE; \ + STDMETHOD_(HRESULT,FreezeEvents)(THIS_ BOOL bFreeze) PURE; + +HRESULT CALLBACK IOleControl_GetControlInfo_Proxy( + IOleControl* This, + CONTROLINFO* pCI); +void __RPC_STUB IOleControl_GetControlInfo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleControl_OnMnemonic_Proxy( + IOleControl* This, + MSG* pMsg); +void __RPC_STUB IOleControl_OnMnemonic_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleControl_OnAmbientPropertyChange_Proxy( + IOleControl* This, + DISPID dispID); +void __RPC_STUB IOleControl_OnAmbientPropertyChange_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleControl_FreezeEvents_Proxy( + IOleControl* This, + BOOL bFreeze); +void __RPC_STUB IOleControl_FreezeEvents_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IOleControl_INTERFACE_DEFINED__ */ + +#ifndef __IOleControlSite_FWD_DEFINED__ +#define __IOleControlSite_FWD_DEFINED__ +typedef struct IOleControlSite IOleControlSite; +#endif + +typedef IOleControlSite *LPOLECONTROLSITE; + +typedef struct tagPOINTF { + FLOAT x; + FLOAT y; +} POINTF, *LPPOINTF; + +typedef enum tagXFORMCOORDS { + XFORMCOORDS_POSITION = 0x1, + XFORMCOORDS_SIZE = 0x2, + XFORMCOORDS_HIMETRICTOCONTAINER = 0x4, + XFORMCOORDS_CONTAINERTOHIMETRIC = 0x8, + XFORMCOORDS_EVENTCOMPAT = 0x10 +} XFORMCOORDS; + +/***************************************************************************** + * IOleControlSite interface + */ +#ifndef __IOleControlSite_INTERFACE_DEFINED__ +#define __IOleControlSite_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IOleControlSite, 0xb196b289, 0xbab4, 0x101a, 0xb6,0x9c, 0x00,0xaa,0x00,0x34,0x1d,0x07); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IOleControlSite : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE OnControlInfoChanged( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE LockInPlaceActive( + BOOL fLock) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetExtendedControl( + IDispatch** ppDisp) = 0; + + virtual HRESULT STDMETHODCALLTYPE TransformCoords( + POINTL* pPtlHimetric, + POINTF* pPtfContainer, + DWORD dwFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE TranslateAccelerator( + MSG* pMsg, + DWORD grfModifiers) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnFocus( + BOOL fGotFocus) = 0; + + virtual HRESULT STDMETHODCALLTYPE ShowPropertyFrame( + ) = 0; + +}; +#else +typedef struct IOleControlSiteVtbl IOleControlSiteVtbl; +struct IOleControlSite { + const IOleControlSiteVtbl* lpVtbl; +}; +struct IOleControlSiteVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IOleControlSite* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IOleControlSite* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IOleControlSite* This); + + /*** IOleControlSite methods ***/ + HRESULT (STDMETHODCALLTYPE *OnControlInfoChanged)( + IOleControlSite* This); + + HRESULT (STDMETHODCALLTYPE *LockInPlaceActive)( + IOleControlSite* This, + BOOL fLock); + + HRESULT (STDMETHODCALLTYPE *GetExtendedControl)( + IOleControlSite* This, + IDispatch** ppDisp); + + HRESULT (STDMETHODCALLTYPE *TransformCoords)( + IOleControlSite* This, + POINTL* pPtlHimetric, + POINTF* pPtfContainer, + DWORD dwFlags); + + HRESULT (STDMETHODCALLTYPE *TranslateAccelerator)( + IOleControlSite* This, + MSG* pMsg, + DWORD grfModifiers); + + HRESULT (STDMETHODCALLTYPE *OnFocus)( + IOleControlSite* This, + BOOL fGotFocus); + + HRESULT (STDMETHODCALLTYPE *ShowPropertyFrame)( + IOleControlSite* This); + +}; + +/*** IUnknown methods ***/ +#define IOleControlSite_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IOleControlSite_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IOleControlSite_Release(p) (p)->lpVtbl->Release(p) +/*** IOleControlSite methods ***/ +#define IOleControlSite_OnControlInfoChanged(p) (p)->lpVtbl->OnControlInfoChanged(p) +#define IOleControlSite_LockInPlaceActive(p,a) (p)->lpVtbl->LockInPlaceActive(p,a) +#define IOleControlSite_GetExtendedControl(p,a) (p)->lpVtbl->GetExtendedControl(p,a) +#define IOleControlSite_TransformCoords(p,a,b,c) (p)->lpVtbl->TransformCoords(p,a,b,c) +#define IOleControlSite_TranslateAccelerator(p,a,b) (p)->lpVtbl->TranslateAccelerator(p,a,b) +#define IOleControlSite_OnFocus(p,a) (p)->lpVtbl->OnFocus(p,a) +#define IOleControlSite_ShowPropertyFrame(p) (p)->lpVtbl->ShowPropertyFrame(p) + +#endif + +#define IOleControlSite_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IOleControlSite methods ***/ \ + STDMETHOD_(HRESULT,OnControlInfoChanged)(THIS) PURE; \ + STDMETHOD_(HRESULT,LockInPlaceActive)(THIS_ BOOL fLock) PURE; \ + STDMETHOD_(HRESULT,GetExtendedControl)(THIS_ IDispatch** ppDisp) PURE; \ + STDMETHOD_(HRESULT,TransformCoords)(THIS_ POINTL* pPtlHimetric, POINTF* pPtfContainer, DWORD dwFlags) PURE; \ + STDMETHOD_(HRESULT,TranslateAccelerator)(THIS_ MSG* pMsg, DWORD grfModifiers) PURE; \ + STDMETHOD_(HRESULT,OnFocus)(THIS_ BOOL fGotFocus) PURE; \ + STDMETHOD_(HRESULT,ShowPropertyFrame)(THIS) PURE; + +HRESULT CALLBACK IOleControlSite_OnControlInfoChanged_Proxy( + IOleControlSite* This); +void __RPC_STUB IOleControlSite_OnControlInfoChanged_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleControlSite_LockInPlaceActive_Proxy( + IOleControlSite* This, + BOOL fLock); +void __RPC_STUB IOleControlSite_LockInPlaceActive_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleControlSite_GetExtendedControl_Proxy( + IOleControlSite* This, + IDispatch** ppDisp); +void __RPC_STUB IOleControlSite_GetExtendedControl_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleControlSite_TransformCoords_Proxy( + IOleControlSite* This, + POINTL* pPtlHimetric, + POINTF* pPtfContainer, + DWORD dwFlags); +void __RPC_STUB IOleControlSite_TransformCoords_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleControlSite_TranslateAccelerator_Proxy( + IOleControlSite* This, + MSG* pMsg, + DWORD grfModifiers); +void __RPC_STUB IOleControlSite_TranslateAccelerator_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleControlSite_OnFocus_Proxy( + IOleControlSite* This, + BOOL fGotFocus); +void __RPC_STUB IOleControlSite_OnFocus_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleControlSite_ShowPropertyFrame_Proxy( + IOleControlSite* This); +void __RPC_STUB IOleControlSite_ShowPropertyFrame_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IOleControlSite_INTERFACE_DEFINED__ */ + +#ifndef __IOleInPlaceSiteEx_FWD_DEFINED__ +#define __IOleInPlaceSiteEx_FWD_DEFINED__ +typedef struct IOleInPlaceSiteEx IOleInPlaceSiteEx; +#endif + +typedef IOleInPlaceSiteEx *LPOLEINPLACESITEEX; + +typedef enum tagACTIVATEFLAGS { + ACTIVATE_WINDOWLESS = 1 +} ACTIVATE_FLAGS; + +/***************************************************************************** + * IOleInPlaceSiteEx interface + */ +#ifndef __IOleInPlaceSiteEx_INTERFACE_DEFINED__ +#define __IOleInPlaceSiteEx_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IOleInPlaceSiteEx, 0x9c2cad80, 0x3424, 0x11cf, 0xb6,0x70, 0x00,0xaa,0x00,0x4c,0xd6,0xd8); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IOleInPlaceSiteEx : public IOleInPlaceSite +{ + virtual HRESULT STDMETHODCALLTYPE OnInPlaceActivateEx( + BOOL* pfNoRedraw, + DWORD dwFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnInPlaceDeactivateEx( + BOOL fNoRedraw) = 0; + + virtual HRESULT STDMETHODCALLTYPE RequestUIActivate( + ) = 0; + +}; +#else +typedef struct IOleInPlaceSiteExVtbl IOleInPlaceSiteExVtbl; +struct IOleInPlaceSiteEx { + const IOleInPlaceSiteExVtbl* lpVtbl; +}; +struct IOleInPlaceSiteExVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IOleInPlaceSiteEx* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IOleInPlaceSiteEx* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IOleInPlaceSiteEx* This); + + /*** IOleWindow methods ***/ + HRESULT (STDMETHODCALLTYPE *GetWindow)( + IOleInPlaceSiteEx* This, + HWND* phwnd); + + HRESULT (STDMETHODCALLTYPE *ContextSensitiveHelp)( + IOleInPlaceSiteEx* This, + BOOL fEnterMode); + + /*** IOleInPlaceSite methods ***/ + HRESULT (STDMETHODCALLTYPE *CanInPlaceActivate)( + IOleInPlaceSiteEx* This); + + HRESULT (STDMETHODCALLTYPE *OnInPlaceActivate)( + IOleInPlaceSiteEx* This); + + HRESULT (STDMETHODCALLTYPE *OnUIActivate)( + IOleInPlaceSiteEx* This); + + HRESULT (STDMETHODCALLTYPE *GetWindowContext)( + IOleInPlaceSiteEx* This, + IOleInPlaceFrame** ppFrame, + IOleInPlaceUIWindow** ppDoc, + LPRECT lprcPosRect, + LPRECT lprcClipRect, + LPOLEINPLACEFRAMEINFO lpFrameInfo); + + HRESULT (STDMETHODCALLTYPE *Scroll)( + IOleInPlaceSiteEx* This, + SIZE scrollExtant); + + HRESULT (STDMETHODCALLTYPE *OnUIDeactivate)( + IOleInPlaceSiteEx* This, + BOOL fUndoable); + + HRESULT (STDMETHODCALLTYPE *OnInPlaceDeactivate)( + IOleInPlaceSiteEx* This); + + HRESULT (STDMETHODCALLTYPE *DiscardUndoState)( + IOleInPlaceSiteEx* This); + + HRESULT (STDMETHODCALLTYPE *DeactivateAndUndo)( + IOleInPlaceSiteEx* This); + + HRESULT (STDMETHODCALLTYPE *OnPosRectChange)( + IOleInPlaceSiteEx* This, + LPCRECT lprcPosRect); + + /*** IOleInPlaceSiteEx methods ***/ + HRESULT (STDMETHODCALLTYPE *OnInPlaceActivateEx)( + IOleInPlaceSiteEx* This, + BOOL* pfNoRedraw, + DWORD dwFlags); + + HRESULT (STDMETHODCALLTYPE *OnInPlaceDeactivateEx)( + IOleInPlaceSiteEx* This, + BOOL fNoRedraw); + + HRESULT (STDMETHODCALLTYPE *RequestUIActivate)( + IOleInPlaceSiteEx* This); + +}; + +/*** IUnknown methods ***/ +#define IOleInPlaceSiteEx_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IOleInPlaceSiteEx_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IOleInPlaceSiteEx_Release(p) (p)->lpVtbl->Release(p) +/*** IOleWindow methods ***/ +#define IOleInPlaceSiteEx_GetWindow(p,a) (p)->lpVtbl->GetWindow(p,a) +#define IOleInPlaceSiteEx_ContextSensitiveHelp(p,a) (p)->lpVtbl->ContextSensitiveHelp(p,a) +/*** IOleInPlaceSite methods ***/ +#define IOleInPlaceSiteEx_CanInPlaceActivate(p) (p)->lpVtbl->CanInPlaceActivate(p) +#define IOleInPlaceSiteEx_OnInPlaceActivate(p) (p)->lpVtbl->OnInPlaceActivate(p) +#define IOleInPlaceSiteEx_OnUIActivate(p) (p)->lpVtbl->OnUIActivate(p) +#define IOleInPlaceSiteEx_GetWindowContext(p,a,b,c,d,e) (p)->lpVtbl->GetWindowContext(p,a,b,c,d,e) +#define IOleInPlaceSiteEx_Scroll(p,a) (p)->lpVtbl->Scroll(p,a) +#define IOleInPlaceSiteEx_OnUIDeactivate(p,a) (p)->lpVtbl->OnUIDeactivate(p,a) +#define IOleInPlaceSiteEx_OnInPlaceDeactivate(p) (p)->lpVtbl->OnInPlaceDeactivate(p) +#define IOleInPlaceSiteEx_DiscardUndoState(p) (p)->lpVtbl->DiscardUndoState(p) +#define IOleInPlaceSiteEx_DeactivateAndUndo(p) (p)->lpVtbl->DeactivateAndUndo(p) +#define IOleInPlaceSiteEx_OnPosRectChange(p,a) (p)->lpVtbl->OnPosRectChange(p,a) +/*** IOleInPlaceSiteEx methods ***/ +#define IOleInPlaceSiteEx_OnInPlaceActivateEx(p,a,b) (p)->lpVtbl->OnInPlaceActivateEx(p,a,b) +#define IOleInPlaceSiteEx_OnInPlaceDeactivateEx(p,a) (p)->lpVtbl->OnInPlaceDeactivateEx(p,a) +#define IOleInPlaceSiteEx_RequestUIActivate(p) (p)->lpVtbl->RequestUIActivate(p) + +#endif + +#define IOleInPlaceSiteEx_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IOleWindow methods ***/ \ + STDMETHOD_(HRESULT,GetWindow)(THIS_ HWND* phwnd) PURE; \ + STDMETHOD_(HRESULT,ContextSensitiveHelp)(THIS_ BOOL fEnterMode) PURE; \ + /*** IOleInPlaceSite methods ***/ \ + STDMETHOD_(HRESULT,CanInPlaceActivate)(THIS) PURE; \ + STDMETHOD_(HRESULT,OnInPlaceActivate)(THIS) PURE; \ + STDMETHOD_(HRESULT,OnUIActivate)(THIS) PURE; \ + STDMETHOD_(HRESULT,GetWindowContext)(THIS_ IOleInPlaceFrame** ppFrame, IOleInPlaceUIWindow** ppDoc, LPRECT lprcPosRect, LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo) PURE; \ + STDMETHOD_(HRESULT,Scroll)(THIS_ SIZE scrollExtant) PURE; \ + STDMETHOD_(HRESULT,OnUIDeactivate)(THIS_ BOOL fUndoable) PURE; \ + STDMETHOD_(HRESULT,OnInPlaceDeactivate)(THIS) PURE; \ + STDMETHOD_(HRESULT,DiscardUndoState)(THIS) PURE; \ + STDMETHOD_(HRESULT,DeactivateAndUndo)(THIS) PURE; \ + STDMETHOD_(HRESULT,OnPosRectChange)(THIS_ LPCRECT lprcPosRect) PURE; \ + /*** IOleInPlaceSiteEx methods ***/ \ + STDMETHOD_(HRESULT,OnInPlaceActivateEx)(THIS_ BOOL* pfNoRedraw, DWORD dwFlags) PURE; \ + STDMETHOD_(HRESULT,OnInPlaceDeactivateEx)(THIS_ BOOL fNoRedraw) PURE; \ + STDMETHOD_(HRESULT,RequestUIActivate)(THIS) PURE; + +HRESULT CALLBACK IOleInPlaceSiteEx_OnInPlaceActivateEx_Proxy( + IOleInPlaceSiteEx* This, + BOOL* pfNoRedraw, + DWORD dwFlags); +void __RPC_STUB IOleInPlaceSiteEx_OnInPlaceActivateEx_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleInPlaceSiteEx_OnInPlaceDeactivateEx_Proxy( + IOleInPlaceSiteEx* This, + BOOL fNoRedraw); +void __RPC_STUB IOleInPlaceSiteEx_OnInPlaceDeactivateEx_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleInPlaceSiteEx_RequestUIActivate_Proxy( + IOleInPlaceSiteEx* This); +void __RPC_STUB IOleInPlaceSiteEx_RequestUIActivate_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IOleInPlaceSiteEx_INTERFACE_DEFINED__ */ + +#ifndef __IOleInPlaceSiteWindowless_FWD_DEFINED__ +#define __IOleInPlaceSiteWindowless_FWD_DEFINED__ +typedef struct IOleInPlaceSiteWindowless IOleInPlaceSiteWindowless; +#endif + +typedef IOleInPlaceSiteWindowless *LPOLEINPLACESITEWINDOWLESS; + +typedef enum tagOLEDCFLAGS { + OLEDC_NODRAW = 0x1, + OLEDC_PAINTBKGND = 0x2, + OLEDC_OFFSCREEN = 0x4 +} OLEDCFLAGS; + +/***************************************************************************** + * IOleInPlaceSiteWindowless interface + */ +#ifndef __IOleInPlaceSiteWindowless_INTERFACE_DEFINED__ +#define __IOleInPlaceSiteWindowless_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IOleInPlaceSiteWindowless, 0x922eada0, 0x3424, 0x11cf, 0xb6,0x70, 0x00,0xaa,0x00,0x4c,0xd6,0xd8); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IOleInPlaceSiteWindowless : public IOleInPlaceSiteEx +{ + virtual HRESULT STDMETHODCALLTYPE CanWindowlessActivate( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCapture( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCapture( + BOOL fCapture) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFocus( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFocus( + BOOL fFocus) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDC( + LPCRECT pRect, + DWORD grfFlags, + HDC* phDC) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReleaseDC( + HDC hDC) = 0; + + virtual HRESULT STDMETHODCALLTYPE InvalidateRect( + LPCRECT pRect, + BOOL fErase) = 0; + + virtual HRESULT STDMETHODCALLTYPE InvalidateRgn( + HRGN hRGN, + BOOL fErase) = 0; + + virtual HRESULT STDMETHODCALLTYPE ScrollRect( + INT dx, + INT dy, + LPCRECT pRectScroll, + LPCRECT pRectClip) = 0; + + virtual HRESULT STDMETHODCALLTYPE AdjustRect( + LPRECT prc) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnDefWindowMessage( + UINT msg, + WPARAM wParam, + LPARAM lParam, + LRESULT* plResult) = 0; + +}; +#else +typedef struct IOleInPlaceSiteWindowlessVtbl IOleInPlaceSiteWindowlessVtbl; +struct IOleInPlaceSiteWindowless { + const IOleInPlaceSiteWindowlessVtbl* lpVtbl; +}; +struct IOleInPlaceSiteWindowlessVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IOleInPlaceSiteWindowless* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IOleInPlaceSiteWindowless* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IOleInPlaceSiteWindowless* This); + + /*** IOleWindow methods ***/ + HRESULT (STDMETHODCALLTYPE *GetWindow)( + IOleInPlaceSiteWindowless* This, + HWND* phwnd); + + HRESULT (STDMETHODCALLTYPE *ContextSensitiveHelp)( + IOleInPlaceSiteWindowless* This, + BOOL fEnterMode); + + /*** IOleInPlaceSite methods ***/ + HRESULT (STDMETHODCALLTYPE *CanInPlaceActivate)( + IOleInPlaceSiteWindowless* This); + + HRESULT (STDMETHODCALLTYPE *OnInPlaceActivate)( + IOleInPlaceSiteWindowless* This); + + HRESULT (STDMETHODCALLTYPE *OnUIActivate)( + IOleInPlaceSiteWindowless* This); + + HRESULT (STDMETHODCALLTYPE *GetWindowContext)( + IOleInPlaceSiteWindowless* This, + IOleInPlaceFrame** ppFrame, + IOleInPlaceUIWindow** ppDoc, + LPRECT lprcPosRect, + LPRECT lprcClipRect, + LPOLEINPLACEFRAMEINFO lpFrameInfo); + + HRESULT (STDMETHODCALLTYPE *Scroll)( + IOleInPlaceSiteWindowless* This, + SIZE scrollExtant); + + HRESULT (STDMETHODCALLTYPE *OnUIDeactivate)( + IOleInPlaceSiteWindowless* This, + BOOL fUndoable); + + HRESULT (STDMETHODCALLTYPE *OnInPlaceDeactivate)( + IOleInPlaceSiteWindowless* This); + + HRESULT (STDMETHODCALLTYPE *DiscardUndoState)( + IOleInPlaceSiteWindowless* This); + + HRESULT (STDMETHODCALLTYPE *DeactivateAndUndo)( + IOleInPlaceSiteWindowless* This); + + HRESULT (STDMETHODCALLTYPE *OnPosRectChange)( + IOleInPlaceSiteWindowless* This, + LPCRECT lprcPosRect); + + /*** IOleInPlaceSiteEx methods ***/ + HRESULT (STDMETHODCALLTYPE *OnInPlaceActivateEx)( + IOleInPlaceSiteWindowless* This, + BOOL* pfNoRedraw, + DWORD dwFlags); + + HRESULT (STDMETHODCALLTYPE *OnInPlaceDeactivateEx)( + IOleInPlaceSiteWindowless* This, + BOOL fNoRedraw); + + HRESULT (STDMETHODCALLTYPE *RequestUIActivate)( + IOleInPlaceSiteWindowless* This); + + /*** IOleInPlaceSiteWindowless methods ***/ + HRESULT (STDMETHODCALLTYPE *CanWindowlessActivate)( + IOleInPlaceSiteWindowless* This); + + HRESULT (STDMETHODCALLTYPE *GetCapture)( + IOleInPlaceSiteWindowless* This); + + HRESULT (STDMETHODCALLTYPE *SetCapture)( + IOleInPlaceSiteWindowless* This, + BOOL fCapture); + + HRESULT (STDMETHODCALLTYPE *GetFocus)( + IOleInPlaceSiteWindowless* This); + + HRESULT (STDMETHODCALLTYPE *SetFocus)( + IOleInPlaceSiteWindowless* This, + BOOL fFocus); + + HRESULT (STDMETHODCALLTYPE *GetDC)( + IOleInPlaceSiteWindowless* This, + LPCRECT pRect, + DWORD grfFlags, + HDC* phDC); + + HRESULT (STDMETHODCALLTYPE *ReleaseDC)( + IOleInPlaceSiteWindowless* This, + HDC hDC); + + HRESULT (STDMETHODCALLTYPE *InvalidateRect)( + IOleInPlaceSiteWindowless* This, + LPCRECT pRect, + BOOL fErase); + + HRESULT (STDMETHODCALLTYPE *InvalidateRgn)( + IOleInPlaceSiteWindowless* This, + HRGN hRGN, + BOOL fErase); + + HRESULT (STDMETHODCALLTYPE *ScrollRect)( + IOleInPlaceSiteWindowless* This, + INT dx, + INT dy, + LPCRECT pRectScroll, + LPCRECT pRectClip); + + HRESULT (STDMETHODCALLTYPE *AdjustRect)( + IOleInPlaceSiteWindowless* This, + LPRECT prc); + + HRESULT (STDMETHODCALLTYPE *OnDefWindowMessage)( + IOleInPlaceSiteWindowless* This, + UINT msg, + WPARAM wParam, + LPARAM lParam, + LRESULT* plResult); + +}; + +/*** IUnknown methods ***/ +#define IOleInPlaceSiteWindowless_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IOleInPlaceSiteWindowless_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IOleInPlaceSiteWindowless_Release(p) (p)->lpVtbl->Release(p) +/*** IOleWindow methods ***/ +#define IOleInPlaceSiteWindowless_GetWindow(p,a) (p)->lpVtbl->GetWindow(p,a) +#define IOleInPlaceSiteWindowless_ContextSensitiveHelp(p,a) (p)->lpVtbl->ContextSensitiveHelp(p,a) +/*** IOleInPlaceSite methods ***/ +#define IOleInPlaceSiteWindowless_CanInPlaceActivate(p) (p)->lpVtbl->CanInPlaceActivate(p) +#define IOleInPlaceSiteWindowless_OnInPlaceActivate(p) (p)->lpVtbl->OnInPlaceActivate(p) +#define IOleInPlaceSiteWindowless_OnUIActivate(p) (p)->lpVtbl->OnUIActivate(p) +#define IOleInPlaceSiteWindowless_GetWindowContext(p,a,b,c,d,e) (p)->lpVtbl->GetWindowContext(p,a,b,c,d,e) +#define IOleInPlaceSiteWindowless_Scroll(p,a) (p)->lpVtbl->Scroll(p,a) +#define IOleInPlaceSiteWindowless_OnUIDeactivate(p,a) (p)->lpVtbl->OnUIDeactivate(p,a) +#define IOleInPlaceSiteWindowless_OnInPlaceDeactivate(p) (p)->lpVtbl->OnInPlaceDeactivate(p) +#define IOleInPlaceSiteWindowless_DiscardUndoState(p) (p)->lpVtbl->DiscardUndoState(p) +#define IOleInPlaceSiteWindowless_DeactivateAndUndo(p) (p)->lpVtbl->DeactivateAndUndo(p) +#define IOleInPlaceSiteWindowless_OnPosRectChange(p,a) (p)->lpVtbl->OnPosRectChange(p,a) +/*** IOleInPlaceSiteEx methods ***/ +#define IOleInPlaceSiteWindowless_OnInPlaceActivateEx(p,a,b) (p)->lpVtbl->OnInPlaceActivateEx(p,a,b) +#define IOleInPlaceSiteWindowless_OnInPlaceDeactivateEx(p,a) (p)->lpVtbl->OnInPlaceDeactivateEx(p,a) +#define IOleInPlaceSiteWindowless_RequestUIActivate(p) (p)->lpVtbl->RequestUIActivate(p) +/*** IOleInPlaceSiteWindowless methods ***/ +#define IOleInPlaceSiteWindowless_CanWindowlessActivate(p) (p)->lpVtbl->CanWindowlessActivate(p) +#define IOleInPlaceSiteWindowless_GetCapture(p) (p)->lpVtbl->GetCapture(p) +#define IOleInPlaceSiteWindowless_SetCapture(p,a) (p)->lpVtbl->SetCapture(p,a) +#define IOleInPlaceSiteWindowless_GetFocus(p) (p)->lpVtbl->GetFocus(p) +#define IOleInPlaceSiteWindowless_SetFocus(p,a) (p)->lpVtbl->SetFocus(p,a) +#define IOleInPlaceSiteWindowless_GetDC(p,a,b,c) (p)->lpVtbl->GetDC(p,a,b,c) +#define IOleInPlaceSiteWindowless_ReleaseDC(p,a) (p)->lpVtbl->ReleaseDC(p,a) +#define IOleInPlaceSiteWindowless_InvalidateRect(p,a,b) (p)->lpVtbl->InvalidateRect(p,a,b) +#define IOleInPlaceSiteWindowless_InvalidateRgn(p,a,b) (p)->lpVtbl->InvalidateRgn(p,a,b) +#define IOleInPlaceSiteWindowless_ScrollRect(p,a,b,c,d) (p)->lpVtbl->ScrollRect(p,a,b,c,d) +#define IOleInPlaceSiteWindowless_AdjustRect(p,a) (p)->lpVtbl->AdjustRect(p,a) +#define IOleInPlaceSiteWindowless_OnDefWindowMessage(p,a,b,c,d) (p)->lpVtbl->OnDefWindowMessage(p,a,b,c,d) + +#endif + +#define IOleInPlaceSiteWindowless_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IOleWindow methods ***/ \ + STDMETHOD_(HRESULT,GetWindow)(THIS_ HWND* phwnd) PURE; \ + STDMETHOD_(HRESULT,ContextSensitiveHelp)(THIS_ BOOL fEnterMode) PURE; \ + /*** IOleInPlaceSite methods ***/ \ + STDMETHOD_(HRESULT,CanInPlaceActivate)(THIS) PURE; \ + STDMETHOD_(HRESULT,OnInPlaceActivate)(THIS) PURE; \ + STDMETHOD_(HRESULT,OnUIActivate)(THIS) PURE; \ + STDMETHOD_(HRESULT,GetWindowContext)(THIS_ IOleInPlaceFrame** ppFrame, IOleInPlaceUIWindow** ppDoc, LPRECT lprcPosRect, LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo) PURE; \ + STDMETHOD_(HRESULT,Scroll)(THIS_ SIZE scrollExtant) PURE; \ + STDMETHOD_(HRESULT,OnUIDeactivate)(THIS_ BOOL fUndoable) PURE; \ + STDMETHOD_(HRESULT,OnInPlaceDeactivate)(THIS) PURE; \ + STDMETHOD_(HRESULT,DiscardUndoState)(THIS) PURE; \ + STDMETHOD_(HRESULT,DeactivateAndUndo)(THIS) PURE; \ + STDMETHOD_(HRESULT,OnPosRectChange)(THIS_ LPCRECT lprcPosRect) PURE; \ + /*** IOleInPlaceSiteEx methods ***/ \ + STDMETHOD_(HRESULT,OnInPlaceActivateEx)(THIS_ BOOL* pfNoRedraw, DWORD dwFlags) PURE; \ + STDMETHOD_(HRESULT,OnInPlaceDeactivateEx)(THIS_ BOOL fNoRedraw) PURE; \ + STDMETHOD_(HRESULT,RequestUIActivate)(THIS) PURE; \ + /*** IOleInPlaceSiteWindowless methods ***/ \ + STDMETHOD_(HRESULT,CanWindowlessActivate)(THIS) PURE; \ + STDMETHOD_(HRESULT,GetCapture)(THIS) PURE; \ + STDMETHOD_(HRESULT,SetCapture)(THIS_ BOOL fCapture) PURE; \ + STDMETHOD_(HRESULT,GetFocus)(THIS) PURE; \ + STDMETHOD_(HRESULT,SetFocus)(THIS_ BOOL fFocus) PURE; \ + STDMETHOD_(HRESULT,GetDC)(THIS_ LPCRECT pRect, DWORD grfFlags, HDC* phDC) PURE; \ + STDMETHOD_(HRESULT,ReleaseDC)(THIS_ HDC hDC) PURE; \ + STDMETHOD_(HRESULT,InvalidateRect)(THIS_ LPCRECT pRect, BOOL fErase) PURE; \ + STDMETHOD_(HRESULT,InvalidateRgn)(THIS_ HRGN hRGN, BOOL fErase) PURE; \ + STDMETHOD_(HRESULT,ScrollRect)(THIS_ INT dx, INT dy, LPCRECT pRectScroll, LPCRECT pRectClip) PURE; \ + STDMETHOD_(HRESULT,AdjustRect)(THIS_ LPRECT prc) PURE; \ + STDMETHOD_(HRESULT,OnDefWindowMessage)(THIS_ UINT msg, WPARAM wParam, LPARAM lParam, LRESULT* plResult) PURE; + +HRESULT CALLBACK IOleInPlaceSiteWindowless_CanWindowlessActivate_Proxy( + IOleInPlaceSiteWindowless* This); +void __RPC_STUB IOleInPlaceSiteWindowless_CanWindowlessActivate_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleInPlaceSiteWindowless_GetCapture_Proxy( + IOleInPlaceSiteWindowless* This); +void __RPC_STUB IOleInPlaceSiteWindowless_GetCapture_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleInPlaceSiteWindowless_SetCapture_Proxy( + IOleInPlaceSiteWindowless* This, + BOOL fCapture); +void __RPC_STUB IOleInPlaceSiteWindowless_SetCapture_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleInPlaceSiteWindowless_GetFocus_Proxy( + IOleInPlaceSiteWindowless* This); +void __RPC_STUB IOleInPlaceSiteWindowless_GetFocus_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleInPlaceSiteWindowless_SetFocus_Proxy( + IOleInPlaceSiteWindowless* This, + BOOL fFocus); +void __RPC_STUB IOleInPlaceSiteWindowless_SetFocus_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleInPlaceSiteWindowless_GetDC_Proxy( + IOleInPlaceSiteWindowless* This, + LPCRECT pRect, + DWORD grfFlags, + HDC* phDC); +void __RPC_STUB IOleInPlaceSiteWindowless_GetDC_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleInPlaceSiteWindowless_ReleaseDC_Proxy( + IOleInPlaceSiteWindowless* This, + HDC hDC); +void __RPC_STUB IOleInPlaceSiteWindowless_ReleaseDC_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleInPlaceSiteWindowless_InvalidateRect_Proxy( + IOleInPlaceSiteWindowless* This, + LPCRECT pRect, + BOOL fErase); +void __RPC_STUB IOleInPlaceSiteWindowless_InvalidateRect_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleInPlaceSiteWindowless_InvalidateRgn_Proxy( + IOleInPlaceSiteWindowless* This, + HRGN hRGN, + BOOL fErase); +void __RPC_STUB IOleInPlaceSiteWindowless_InvalidateRgn_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleInPlaceSiteWindowless_ScrollRect_Proxy( + IOleInPlaceSiteWindowless* This, + INT dx, + INT dy, + LPCRECT pRectScroll, + LPCRECT pRectClip); +void __RPC_STUB IOleInPlaceSiteWindowless_ScrollRect_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleInPlaceSiteWindowless_AdjustRect_Proxy( + IOleInPlaceSiteWindowless* This, + LPRECT prc); +void __RPC_STUB IOleInPlaceSiteWindowless_AdjustRect_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleInPlaceSiteWindowless_OnDefWindowMessage_Proxy( + IOleInPlaceSiteWindowless* This, + UINT msg, + WPARAM wParam, + LPARAM lParam, + LRESULT* plResult); +void __RPC_STUB IOleInPlaceSiteWindowless_OnDefWindowMessage_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IOleInPlaceSiteWindowless_INTERFACE_DEFINED__ */ + +#ifndef __IOleInPlaceObjectWindowless_FWD_DEFINED__ +#define __IOleInPlaceObjectWindowless_FWD_DEFINED__ +typedef struct IOleInPlaceObjectWindowless IOleInPlaceObjectWindowless; +#endif + +typedef IOleInPlaceObjectWindowless *LPOLEINPLACEOBJECTWINDOWLESS; + +/***************************************************************************** + * IOleInPlaceObjectWindowless interface + */ +#ifndef __IOleInPlaceObjectWindowless_INTERFACE_DEFINED__ +#define __IOleInPlaceObjectWindowless_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IOleInPlaceObjectWindowless, 0x1c2056cc, 0x5ef4, 0x101b, 0x8b,0xc8, 0x00,0xaa,0x00,0x3e,0x3b,0x29); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IOleInPlaceObjectWindowless : public IOleInPlaceObject +{ + virtual HRESULT STDMETHODCALLTYPE OnWindowMessage( + UINT msg, + WPARAM wParam, + LPARAM lParam, + LRESULT* plResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDropTarget( + IDropTarget** ppDropTarget) = 0; + +}; +#else +typedef struct IOleInPlaceObjectWindowlessVtbl IOleInPlaceObjectWindowlessVtbl; +struct IOleInPlaceObjectWindowless { + const IOleInPlaceObjectWindowlessVtbl* lpVtbl; +}; +struct IOleInPlaceObjectWindowlessVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IOleInPlaceObjectWindowless* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IOleInPlaceObjectWindowless* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IOleInPlaceObjectWindowless* This); + + /*** IOleWindow methods ***/ + HRESULT (STDMETHODCALLTYPE *GetWindow)( + IOleInPlaceObjectWindowless* This, + HWND* phwnd); + + HRESULT (STDMETHODCALLTYPE *ContextSensitiveHelp)( + IOleInPlaceObjectWindowless* This, + BOOL fEnterMode); + + /*** IOleInPlaceObject methods ***/ + HRESULT (STDMETHODCALLTYPE *InPlaceDeactivate)( + IOleInPlaceObjectWindowless* This); + + HRESULT (STDMETHODCALLTYPE *UIDeactivate)( + IOleInPlaceObjectWindowless* This); + + HRESULT (STDMETHODCALLTYPE *SetObjectRects)( + IOleInPlaceObjectWindowless* This, + LPCRECT lprcPosRect, + LPCRECT lprcClipRect); + + HRESULT (STDMETHODCALLTYPE *ReactivateAndUndo)( + IOleInPlaceObjectWindowless* This); + + /*** IOleInPlaceObjectWindowless methods ***/ + HRESULT (STDMETHODCALLTYPE *OnWindowMessage)( + IOleInPlaceObjectWindowless* This, + UINT msg, + WPARAM wParam, + LPARAM lParam, + LRESULT* plResult); + + HRESULT (STDMETHODCALLTYPE *GetDropTarget)( + IOleInPlaceObjectWindowless* This, + IDropTarget** ppDropTarget); + +}; + +/*** IUnknown methods ***/ +#define IOleInPlaceObjectWindowless_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IOleInPlaceObjectWindowless_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IOleInPlaceObjectWindowless_Release(p) (p)->lpVtbl->Release(p) +/*** IOleWindow methods ***/ +#define IOleInPlaceObjectWindowless_GetWindow(p,a) (p)->lpVtbl->GetWindow(p,a) +#define IOleInPlaceObjectWindowless_ContextSensitiveHelp(p,a) (p)->lpVtbl->ContextSensitiveHelp(p,a) +/*** IOleInPlaceObject methods ***/ +#define IOleInPlaceObjectWindowless_InPlaceDeactivate(p) (p)->lpVtbl->InPlaceDeactivate(p) +#define IOleInPlaceObjectWindowless_UIDeactivate(p) (p)->lpVtbl->UIDeactivate(p) +#define IOleInPlaceObjectWindowless_SetObjectRects(p,a,b) (p)->lpVtbl->SetObjectRects(p,a,b) +#define IOleInPlaceObjectWindowless_ReactivateAndUndo(p) (p)->lpVtbl->ReactivateAndUndo(p) +/*** IOleInPlaceObjectWindowless methods ***/ +#define IOleInPlaceObjectWindowless_OnWindowMessage(p,a,b,c,d) (p)->lpVtbl->OnWindowMessage(p,a,b,c,d) +#define IOleInPlaceObjectWindowless_GetDropTarget(p,a) (p)->lpVtbl->GetDropTarget(p,a) + +#endif + +#define IOleInPlaceObjectWindowless_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IOleWindow methods ***/ \ + STDMETHOD_(HRESULT,GetWindow)(THIS_ HWND* phwnd) PURE; \ + STDMETHOD_(HRESULT,ContextSensitiveHelp)(THIS_ BOOL fEnterMode) PURE; \ + /*** IOleInPlaceObject methods ***/ \ + STDMETHOD_(HRESULT,InPlaceDeactivate)(THIS) PURE; \ + STDMETHOD_(HRESULT,UIDeactivate)(THIS) PURE; \ + STDMETHOD_(HRESULT,SetObjectRects)(THIS_ LPCRECT lprcPosRect, LPCRECT lprcClipRect) PURE; \ + STDMETHOD_(HRESULT,ReactivateAndUndo)(THIS) PURE; \ + /*** IOleInPlaceObjectWindowless methods ***/ \ + STDMETHOD_(HRESULT,OnWindowMessage)(THIS_ UINT msg, WPARAM wParam, LPARAM lParam, LRESULT* plResult) PURE; \ + STDMETHOD_(HRESULT,GetDropTarget)(THIS_ IDropTarget** ppDropTarget) PURE; + +HRESULT CALLBACK IOleInPlaceObjectWindowless_OnWindowMessage_Proxy( + IOleInPlaceObjectWindowless* This, + UINT msg, + WPARAM wParam, + LPARAM lParam, + LRESULT* plResult); +void __RPC_STUB IOleInPlaceObjectWindowless_OnWindowMessage_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleInPlaceObjectWindowless_GetDropTarget_Proxy( + IOleInPlaceObjectWindowless* This, + IDropTarget** ppDropTarget); +void __RPC_STUB IOleInPlaceObjectWindowless_GetDropTarget_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IOleInPlaceObjectWindowless_INTERFACE_DEFINED__ */ + +#ifndef __IClassFactory2_FWD_DEFINED__ +#define __IClassFactory2_FWD_DEFINED__ +typedef struct IClassFactory2 IClassFactory2; +#endif + +typedef IClassFactory2 *LPCLASSFACTORY2; + +typedef struct tagLICINFO { + LONG cbLicInfo; + BOOL fRuntimeKeyAvail; + BOOL fLicVerified; +} LICINFO, *LPLICINFO; + +/***************************************************************************** + * IClassFactory2 interface + */ +#ifndef __IClassFactory2_INTERFACE_DEFINED__ +#define __IClassFactory2_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IClassFactory2, 0xb196b28f, 0xbab4, 0x101a, 0xb6,0x9c, 0x00,0xaa,0x00,0x34,0x1d,0x07); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IClassFactory2 : public IClassFactory +{ + virtual HRESULT STDMETHODCALLTYPE GetLicInfo( + LICINFO* pLicInfo) = 0; + + virtual HRESULT STDMETHODCALLTYPE RequestLicKey( + DWORD dwReserved, + BSTR* pBstrKey) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateInstanceLic( + IUnknown* pUnkOuter, + IUnknown* pUnkReserved, + REFIID riid, + BSTR bstrKey, + PVOID* ppvObj) = 0; + +}; +#else +typedef struct IClassFactory2Vtbl IClassFactory2Vtbl; +struct IClassFactory2 { + const IClassFactory2Vtbl* lpVtbl; +}; +struct IClassFactory2Vtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IClassFactory2* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IClassFactory2* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IClassFactory2* This); + + /*** IClassFactory methods ***/ + HRESULT (STDMETHODCALLTYPE *CreateInstance)( + IClassFactory2* This, + IUnknown* pUnkOuter, + REFIID riid, + void** ppvObject); + + HRESULT (STDMETHODCALLTYPE *LockServer)( + IClassFactory2* This, + BOOL fLock); + + /*** IClassFactory2 methods ***/ + HRESULT (STDMETHODCALLTYPE *GetLicInfo)( + IClassFactory2* This, + LICINFO* pLicInfo); + + HRESULT (STDMETHODCALLTYPE *RequestLicKey)( + IClassFactory2* This, + DWORD dwReserved, + BSTR* pBstrKey); + + HRESULT (STDMETHODCALLTYPE *CreateInstanceLic)( + IClassFactory2* This, + IUnknown* pUnkOuter, + IUnknown* pUnkReserved, + REFIID riid, + BSTR bstrKey, + PVOID* ppvObj); + +}; + +/*** IUnknown methods ***/ +#define IClassFactory2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IClassFactory2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IClassFactory2_Release(p) (p)->lpVtbl->Release(p) +/*** IClassFactory methods ***/ +#define IClassFactory2_CreateInstance(p,a,b,c) (p)->lpVtbl->CreateInstance(p,a,b,c) +#define IClassFactory2_LockServer(p,a) (p)->lpVtbl->LockServer(p,a) +/*** IClassFactory2 methods ***/ +#define IClassFactory2_GetLicInfo(p,a) (p)->lpVtbl->GetLicInfo(p,a) +#define IClassFactory2_RequestLicKey(p,a,b) (p)->lpVtbl->RequestLicKey(p,a,b) +#define IClassFactory2_CreateInstanceLic(p,a,b,c,d,e) (p)->lpVtbl->CreateInstanceLic(p,a,b,c,d,e) + +#endif + +#define IClassFactory2_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IClassFactory methods ***/ \ + STDMETHOD_(HRESULT,CreateInstance)(THIS_ IUnknown* pUnkOuter, REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(HRESULT,LockServer)(THIS_ BOOL fLock) PURE; \ + /*** IClassFactory2 methods ***/ \ + STDMETHOD_(HRESULT,GetLicInfo)(THIS_ LICINFO* pLicInfo) PURE; \ + STDMETHOD_(HRESULT,RequestLicKey)(THIS_ DWORD dwReserved, BSTR* pBstrKey) PURE; \ + STDMETHOD_(HRESULT,CreateInstanceLic)(THIS_ IUnknown* pUnkOuter, IUnknown* pUnkReserved, REFIID riid, BSTR bstrKey, PVOID* ppvObj) PURE; + +HRESULT CALLBACK IClassFactory2_GetLicInfo_Proxy( + IClassFactory2* This, + LICINFO* pLicInfo); +void __RPC_STUB IClassFactory2_GetLicInfo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IClassFactory2_RequestLicKey_Proxy( + IClassFactory2* This, + DWORD dwReserved, + BSTR* pBstrKey); +void __RPC_STUB IClassFactory2_RequestLicKey_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IClassFactory2_RemoteCreateInstanceLic_Proxy( + IClassFactory2* This, + REFIID riid, + BSTR bstrKey, + IUnknown** ppvObj); +void __RPC_STUB IClassFactory2_RemoteCreateInstanceLic_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IClassFactory2_CreateInstanceLic_Proxy( + IClassFactory2* This, + IUnknown* pUnkOuter, + IUnknown* pUnkReserved, + REFIID riid, + BSTR bstrKey, + PVOID* ppvObj); +HRESULT __RPC_STUB IClassFactory2_CreateInstanceLic_Stub( + IClassFactory2* This, + REFIID riid, + BSTR bstrKey, + IUnknown** ppvObj); + +#endif /* __IClassFactory2_INTERFACE_DEFINED__ */ + +#ifndef __IViewObjectEx_FWD_DEFINED__ +#define __IViewObjectEx_FWD_DEFINED__ +typedef struct IViewObjectEx IViewObjectEx; +#endif + +typedef IViewObjectEx *LPVIEWOBJECTEX; + +typedef enum tagVIEWSTATUS { + VIEWSTATUS_OPAQUE = 1, + VIEWSTATUS_SOLIDBKGND = 2, + VIEWSTATUS_DVASPECTOPAQUE = 4, + VIEWSTATUS_DVASPECTTRANSPARENT = 8, + VIEWSTATUS_SURFACE = 16, + VIEWSTATUS_3DSURFACE = 32 +} VIEWSTATUS; + +typedef enum tagHITRESULT { + HITRESULT_OUTSIDE = 0, + HITRESULT_TRANSPARENT = 1, + HITRESULT_CLOSE = 2, + HITRESULT_HIT = 3 +} HITRESULT; + +typedef enum tagDVASPECT2 { + DVASPECT_OPAQUE = 16, + DVASPECT_TRANSPARENT = 32 +} DVASPECT2; + +typedef struct tagExtentInfo { + ULONG cb; + DWORD dwExtentMode; + SIZEL sizelProposed; +} DVEXTENTINFO; + +typedef enum tagAspectInfoFlag { + DVASPECTINFOFLAG_CANOPTIMIZE = 1 +} DVASPECTINFOFLAG; + +typedef struct tagAspectInfo { + ULONG cb; + DWORD dwFlags; +} DVASPECTINFO; + +/***************************************************************************** + * IViewObjectEx interface + */ +#ifndef __IViewObjectEx_INTERFACE_DEFINED__ +#define __IViewObjectEx_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IViewObjectEx, 0x3af24292, 0x0c96, 0x11ce, 0xa0,0xcf, 0x00,0xaa,0x00,0x60,0x0a,0xb8); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IViewObjectEx : public IViewObject2 +{ + virtual HRESULT STDMETHODCALLTYPE GetRect( + DWORD dwAspect, + LPRECTL pRect) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetViewStatus( + DWORD* pdwStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueryHitPoint( + DWORD dwAspect, + LPCRECT pRectBounds, + POINT ptlLoc, + LONG lCloseHint, + DWORD* pHitResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueryHitRect( + DWORD dwAspect, + LPCRECT pRectBounds, + LPCRECT pRectLoc, + LONG lCloseHint, + DWORD* pHitResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetNaturalExtent( + DWORD dwAspect, + LONG lindex, + DVTARGETDEVICE* ptd, + HDC hicTargetDev, + DVEXTENTINFO* pExtentInfo, + LPSIZEL pSizel) = 0; + +}; +#else +typedef struct IViewObjectExVtbl IViewObjectExVtbl; +struct IViewObjectEx { + const IViewObjectExVtbl* lpVtbl; +}; +struct IViewObjectExVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IViewObjectEx* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IViewObjectEx* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IViewObjectEx* This); + + /*** IViewObject methods ***/ + HRESULT (STDMETHODCALLTYPE *Draw)( + IViewObjectEx* This, + DWORD dwDrawAspect, + LONG lindex, + void* pvAspect, + DVTARGETDEVICE* ptd, + HDC hdcTargetDev, + HDC hdcDraw, + LPCRECTL lprcBounds, + LPCRECTL lprcWBounds, + BOOL (STDMETHODCALLTYPE *pfnContinue)(ULONG_PTR dwContinue), + ULONG_PTR dwContinue); + + HRESULT (STDMETHODCALLTYPE *GetColorSet)( + IViewObjectEx* This, + DWORD dwDrawAspect, + LONG lindex, + void* pvAspect, + DVTARGETDEVICE* ptd, + HDC hicTargetDev, + LOGPALETTE** ppColorSet); + + HRESULT (STDMETHODCALLTYPE *Freeze)( + IViewObjectEx* This, + DWORD dwDrawAspect, + LONG lindex, + void* pvAspect, + DWORD* pdwFreeze); + + HRESULT (STDMETHODCALLTYPE *Unfreeze)( + IViewObjectEx* This, + DWORD dwFreeze); + + HRESULT (STDMETHODCALLTYPE *SetAdvise)( + IViewObjectEx* This, + DWORD aspects, + DWORD advf, + IAdviseSink* pAdvSink); + + HRESULT (STDMETHODCALLTYPE *GetAdvise)( + IViewObjectEx* This, + DWORD* pAspects, + DWORD* pAdvf, + IAdviseSink** ppAdvSink); + + /*** IViewObject2 methods ***/ + HRESULT (STDMETHODCALLTYPE *GetExtent)( + IViewObjectEx* This, + DWORD dwDrawAspect, + LONG lindex, + DVTARGETDEVICE* ptd, + LPSIZEL lpsizel); + + /*** IViewObjectEx methods ***/ + HRESULT (STDMETHODCALLTYPE *GetRect)( + IViewObjectEx* This, + DWORD dwAspect, + LPRECTL pRect); + + HRESULT (STDMETHODCALLTYPE *GetViewStatus)( + IViewObjectEx* This, + DWORD* pdwStatus); + + HRESULT (STDMETHODCALLTYPE *QueryHitPoint)( + IViewObjectEx* This, + DWORD dwAspect, + LPCRECT pRectBounds, + POINT ptlLoc, + LONG lCloseHint, + DWORD* pHitResult); + + HRESULT (STDMETHODCALLTYPE *QueryHitRect)( + IViewObjectEx* This, + DWORD dwAspect, + LPCRECT pRectBounds, + LPCRECT pRectLoc, + LONG lCloseHint, + DWORD* pHitResult); + + HRESULT (STDMETHODCALLTYPE *GetNaturalExtent)( + IViewObjectEx* This, + DWORD dwAspect, + LONG lindex, + DVTARGETDEVICE* ptd, + HDC hicTargetDev, + DVEXTENTINFO* pExtentInfo, + LPSIZEL pSizel); + +}; + +/*** IUnknown methods ***/ +#define IViewObjectEx_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IViewObjectEx_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IViewObjectEx_Release(p) (p)->lpVtbl->Release(p) +/*** IViewObject methods ***/ +#define IViewObjectEx_Draw(p,a,b,c,d,e,f,g,h,i,j) (p)->lpVtbl->Draw(p,a,b,c,d,e,f,g,h,i,j) +#define IViewObjectEx_GetColorSet(p,a,b,c,d,e,f) (p)->lpVtbl->GetColorSet(p,a,b,c,d,e,f) +#define IViewObjectEx_Freeze(p,a,b,c,d) (p)->lpVtbl->Freeze(p,a,b,c,d) +#define IViewObjectEx_Unfreeze(p,a) (p)->lpVtbl->Unfreeze(p,a) +#define IViewObjectEx_SetAdvise(p,a,b,c) (p)->lpVtbl->SetAdvise(p,a,b,c) +#define IViewObjectEx_GetAdvise(p,a,b,c) (p)->lpVtbl->GetAdvise(p,a,b,c) +/*** IViewObject2 methods ***/ +#define IViewObjectEx_GetExtent(p,a,b,c,d) (p)->lpVtbl->GetExtent(p,a,b,c,d) +/*** IViewObjectEx methods ***/ +#define IViewObjectEx_GetRect(p,a,b) (p)->lpVtbl->GetRect(p,a,b) +#define IViewObjectEx_GetViewStatus(p,a) (p)->lpVtbl->GetViewStatus(p,a) +#define IViewObjectEx_QueryHitPoint(p,a,b,c,d,e) (p)->lpVtbl->QueryHitPoint(p,a,b,c,d,e) +#define IViewObjectEx_QueryHitRect(p,a,b,c,d,e) (p)->lpVtbl->QueryHitRect(p,a,b,c,d,e) +#define IViewObjectEx_GetNaturalExtent(p,a,b,c,d,e,f) (p)->lpVtbl->GetNaturalExtent(p,a,b,c,d,e,f) + +#endif + +#define IViewObjectEx_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IViewObject methods ***/ \ + STDMETHOD_(HRESULT,Draw)(THIS_ DWORD dwDrawAspect, LONG lindex, void* pvAspect, DVTARGETDEVICE* ptd, HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBounds, BOOL (STDMETHODCALLTYPE *pfnContinue)(ULONG_PTR dwContinue), ULONG_PTR dwContinue) PURE; \ + STDMETHOD_(HRESULT,GetColorSet)(THIS_ DWORD dwDrawAspect, LONG lindex, void* pvAspect, DVTARGETDEVICE* ptd, HDC hicTargetDev, LOGPALETTE** ppColorSet) PURE; \ + STDMETHOD_(HRESULT,Freeze)(THIS_ DWORD dwDrawAspect, LONG lindex, void* pvAspect, DWORD* pdwFreeze) PURE; \ + STDMETHOD_(HRESULT,Unfreeze)(THIS_ DWORD dwFreeze) PURE; \ + STDMETHOD_(HRESULT,SetAdvise)(THIS_ DWORD aspects, DWORD advf, IAdviseSink* pAdvSink) PURE; \ + STDMETHOD_(HRESULT,GetAdvise)(THIS_ DWORD* pAspects, DWORD* pAdvf, IAdviseSink** ppAdvSink) PURE; \ + /*** IViewObject2 methods ***/ \ + STDMETHOD_(HRESULT,GetExtent)(THIS_ DWORD dwDrawAspect, LONG lindex, DVTARGETDEVICE* ptd, LPSIZEL lpsizel) PURE; \ + /*** IViewObjectEx methods ***/ \ + STDMETHOD_(HRESULT,GetRect)(THIS_ DWORD dwAspect, LPRECTL pRect) PURE; \ + STDMETHOD_(HRESULT,GetViewStatus)(THIS_ DWORD* pdwStatus) PURE; \ + STDMETHOD_(HRESULT,QueryHitPoint)(THIS_ DWORD dwAspect, LPCRECT pRectBounds, POINT ptlLoc, LONG lCloseHint, DWORD* pHitResult) PURE; \ + STDMETHOD_(HRESULT,QueryHitRect)(THIS_ DWORD dwAspect, LPCRECT pRectBounds, LPCRECT pRectLoc, LONG lCloseHint, DWORD* pHitResult) PURE; \ + STDMETHOD_(HRESULT,GetNaturalExtent)(THIS_ DWORD dwAspect, LONG lindex, DVTARGETDEVICE* ptd, HDC hicTargetDev, DVEXTENTINFO* pExtentInfo, LPSIZEL pSizel) PURE; + +HRESULT CALLBACK IViewObjectEx_GetRect_Proxy( + IViewObjectEx* This, + DWORD dwAspect, + LPRECTL pRect); +void __RPC_STUB IViewObjectEx_GetRect_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IViewObjectEx_GetViewStatus_Proxy( + IViewObjectEx* This, + DWORD* pdwStatus); +void __RPC_STUB IViewObjectEx_GetViewStatus_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IViewObjectEx_QueryHitPoint_Proxy( + IViewObjectEx* This, + DWORD dwAspect, + LPCRECT pRectBounds, + POINT ptlLoc, + LONG lCloseHint, + DWORD* pHitResult); +void __RPC_STUB IViewObjectEx_QueryHitPoint_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IViewObjectEx_QueryHitRect_Proxy( + IViewObjectEx* This, + DWORD dwAspect, + LPCRECT pRectBounds, + LPCRECT pRectLoc, + LONG lCloseHint, + DWORD* pHitResult); +void __RPC_STUB IViewObjectEx_QueryHitRect_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IViewObjectEx_GetNaturalExtent_Proxy( + IViewObjectEx* This, + DWORD dwAspect, + LONG lindex, + DVTARGETDEVICE* ptd, + HDC hicTargetDev, + DVEXTENTINFO* pExtentInfo, + LPSIZEL pSizel); +void __RPC_STUB IViewObjectEx_GetNaturalExtent_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IViewObjectEx_INTERFACE_DEFINED__ */ + +#ifndef __IProvideClassInfo_FWD_DEFINED__ +#define __IProvideClassInfo_FWD_DEFINED__ +typedef struct IProvideClassInfo IProvideClassInfo; +#endif + +typedef IProvideClassInfo *LPPROVIDECLASSINFO; + +#ifdef __WINESRC__ +#undef GetClassInfo +#endif +/***************************************************************************** + * IProvideClassInfo interface + */ +#ifndef __IProvideClassInfo_INTERFACE_DEFINED__ +#define __IProvideClassInfo_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IProvideClassInfo, 0xb196b283, 0xbab4, 0x101a, 0xb6,0x9c, 0x00,0xaa,0x00,0x34,0x1d,0x07); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IProvideClassInfo : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetClassInfo( + ITypeInfo** ppTI) = 0; + +}; +#else +typedef struct IProvideClassInfoVtbl IProvideClassInfoVtbl; +struct IProvideClassInfo { + const IProvideClassInfoVtbl* lpVtbl; +}; +struct IProvideClassInfoVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IProvideClassInfo* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IProvideClassInfo* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IProvideClassInfo* This); + + /*** IProvideClassInfo methods ***/ + HRESULT (STDMETHODCALLTYPE *GetClassInfo)( + IProvideClassInfo* This, + ITypeInfo** ppTI); + +}; + +/*** IUnknown methods ***/ +#define IProvideClassInfo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IProvideClassInfo_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IProvideClassInfo_Release(p) (p)->lpVtbl->Release(p) +/*** IProvideClassInfo methods ***/ +#define IProvideClassInfo_GetClassInfo(p,a) (p)->lpVtbl->GetClassInfo(p,a) + +#endif + +#define IProvideClassInfo_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IProvideClassInfo methods ***/ \ + STDMETHOD_(HRESULT,GetClassInfo)(THIS_ ITypeInfo** ppTI) PURE; + +HRESULT CALLBACK IProvideClassInfo_GetClassInfo_Proxy( + IProvideClassInfo* This, + ITypeInfo** ppTI); +void __RPC_STUB IProvideClassInfo_GetClassInfo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IProvideClassInfo_INTERFACE_DEFINED__ */ + +#ifndef __IProvideClassInfo2_FWD_DEFINED__ +#define __IProvideClassInfo2_FWD_DEFINED__ +typedef struct IProvideClassInfo2 IProvideClassInfo2; +#endif + +typedef IProvideClassInfo2 *LPPROVIDECLASSINFO2; + +typedef enum tagGUIDKIND { + GUIDKIND_DEFAULT_SOURCE_DISP_IID = 1 +} GUIDKIND; + +/***************************************************************************** + * IProvideClassInfo2 interface + */ +#ifndef __IProvideClassInfo2_INTERFACE_DEFINED__ +#define __IProvideClassInfo2_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IProvideClassInfo2, 0xa6bc3ac0, 0xdbaa, 0x11ce, 0x9d,0xe3, 0x00,0xaa,0x00,0x4b,0xb8,0x51); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IProvideClassInfo2 : public IProvideClassInfo +{ + virtual HRESULT STDMETHODCALLTYPE GetGUID( + DWORD dwGuidKind, + GUID* pGUID) = 0; + +}; +#else +typedef struct IProvideClassInfo2Vtbl IProvideClassInfo2Vtbl; +struct IProvideClassInfo2 { + const IProvideClassInfo2Vtbl* lpVtbl; +}; +struct IProvideClassInfo2Vtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IProvideClassInfo2* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IProvideClassInfo2* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IProvideClassInfo2* This); + + /*** IProvideClassInfo methods ***/ + HRESULT (STDMETHODCALLTYPE *GetClassInfo)( + IProvideClassInfo2* This, + ITypeInfo** ppTI); + + /*** IProvideClassInfo2 methods ***/ + HRESULT (STDMETHODCALLTYPE *GetGUID)( + IProvideClassInfo2* This, + DWORD dwGuidKind, + GUID* pGUID); + +}; + +/*** IUnknown methods ***/ +#define IProvideClassInfo2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IProvideClassInfo2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IProvideClassInfo2_Release(p) (p)->lpVtbl->Release(p) +/*** IProvideClassInfo methods ***/ +#define IProvideClassInfo2_GetClassInfo(p,a) (p)->lpVtbl->GetClassInfo(p,a) +/*** IProvideClassInfo2 methods ***/ +#define IProvideClassInfo2_GetGUID(p,a,b) (p)->lpVtbl->GetGUID(p,a,b) + +#endif + +#define IProvideClassInfo2_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IProvideClassInfo methods ***/ \ + STDMETHOD_(HRESULT,GetClassInfo)(THIS_ ITypeInfo** ppTI) PURE; \ + /*** IProvideClassInfo2 methods ***/ \ + STDMETHOD_(HRESULT,GetGUID)(THIS_ DWORD dwGuidKind, GUID* pGUID) PURE; + +HRESULT CALLBACK IProvideClassInfo2_GetGUID_Proxy( + IProvideClassInfo2* This, + DWORD dwGuidKind, + GUID* pGUID); +void __RPC_STUB IProvideClassInfo2_GetGUID_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IProvideClassInfo2_INTERFACE_DEFINED__ */ + +#ifndef __IConnectionPointContainer_FWD_DEFINED__ +#define __IConnectionPointContainer_FWD_DEFINED__ +typedef struct IConnectionPointContainer IConnectionPointContainer; +#endif + +#ifndef __IEnumConnections_FWD_DEFINED__ +#define __IEnumConnections_FWD_DEFINED__ +typedef struct IEnumConnections IEnumConnections; +#endif + +#ifndef __IConnectionPoint_FWD_DEFINED__ +#define __IConnectionPoint_FWD_DEFINED__ +typedef struct IConnectionPoint IConnectionPoint; +#endif + +typedef IConnectionPoint *PCONNECTIONPOINT, *LPCONNECTIONPOINT; + +/***************************************************************************** + * IConnectionPoint interface + */ +#ifndef __IConnectionPoint_INTERFACE_DEFINED__ +#define __IConnectionPoint_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IConnectionPoint, 0xb196b286, 0xbab4, 0x101a, 0xb6,0x9c, 0x00,0xaa,0x00,0x34,0x1d,0x07); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IConnectionPoint : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetConnectionInterface( + IID* pIID) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetConnectionPointContainer( + IConnectionPointContainer** ppCPC) = 0; + + virtual HRESULT STDMETHODCALLTYPE Advise( + IUnknown* pUnkSink, + DWORD* pdwCookie) = 0; + + virtual HRESULT STDMETHODCALLTYPE Unadvise( + DWORD dwCookie) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumConnections( + IEnumConnections** ppEnum) = 0; + +}; +#else +typedef struct IConnectionPointVtbl IConnectionPointVtbl; +struct IConnectionPoint { + const IConnectionPointVtbl* lpVtbl; +}; +struct IConnectionPointVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IConnectionPoint* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IConnectionPoint* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IConnectionPoint* This); + + /*** IConnectionPoint methods ***/ + HRESULT (STDMETHODCALLTYPE *GetConnectionInterface)( + IConnectionPoint* This, + IID* pIID); + + HRESULT (STDMETHODCALLTYPE *GetConnectionPointContainer)( + IConnectionPoint* This, + IConnectionPointContainer** ppCPC); + + HRESULT (STDMETHODCALLTYPE *Advise)( + IConnectionPoint* This, + IUnknown* pUnkSink, + DWORD* pdwCookie); + + HRESULT (STDMETHODCALLTYPE *Unadvise)( + IConnectionPoint* This, + DWORD dwCookie); + + HRESULT (STDMETHODCALLTYPE *EnumConnections)( + IConnectionPoint* This, + IEnumConnections** ppEnum); + +}; + +/*** IUnknown methods ***/ +#define IConnectionPoint_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IConnectionPoint_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IConnectionPoint_Release(p) (p)->lpVtbl->Release(p) +/*** IConnectionPoint methods ***/ +#define IConnectionPoint_GetConnectionInterface(p,a) (p)->lpVtbl->GetConnectionInterface(p,a) +#define IConnectionPoint_GetConnectionPointContainer(p,a) (p)->lpVtbl->GetConnectionPointContainer(p,a) +#define IConnectionPoint_Advise(p,a,b) (p)->lpVtbl->Advise(p,a,b) +#define IConnectionPoint_Unadvise(p,a) (p)->lpVtbl->Unadvise(p,a) +#define IConnectionPoint_EnumConnections(p,a) (p)->lpVtbl->EnumConnections(p,a) + +#endif + +#define IConnectionPoint_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IConnectionPoint methods ***/ \ + STDMETHOD_(HRESULT,GetConnectionInterface)(THIS_ IID* pIID) PURE; \ + STDMETHOD_(HRESULT,GetConnectionPointContainer)(THIS_ IConnectionPointContainer** ppCPC) PURE; \ + STDMETHOD_(HRESULT,Advise)(THIS_ IUnknown* pUnkSink, DWORD* pdwCookie) PURE; \ + STDMETHOD_(HRESULT,Unadvise)(THIS_ DWORD dwCookie) PURE; \ + STDMETHOD_(HRESULT,EnumConnections)(THIS_ IEnumConnections** ppEnum) PURE; + +HRESULT CALLBACK IConnectionPoint_GetConnectionInterface_Proxy( + IConnectionPoint* This, + IID* pIID); +void __RPC_STUB IConnectionPoint_GetConnectionInterface_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IConnectionPoint_GetConnectionPointContainer_Proxy( + IConnectionPoint* This, + IConnectionPointContainer** ppCPC); +void __RPC_STUB IConnectionPoint_GetConnectionPointContainer_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IConnectionPoint_Advise_Proxy( + IConnectionPoint* This, + IUnknown* pUnkSink, + DWORD* pdwCookie); +void __RPC_STUB IConnectionPoint_Advise_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IConnectionPoint_Unadvise_Proxy( + IConnectionPoint* This, + DWORD dwCookie); +void __RPC_STUB IConnectionPoint_Unadvise_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IConnectionPoint_EnumConnections_Proxy( + IConnectionPoint* This, + IEnumConnections** ppEnum); +void __RPC_STUB IConnectionPoint_EnumConnections_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IConnectionPoint_INTERFACE_DEFINED__ */ + +#ifndef __IEnumConnectionPoints_FWD_DEFINED__ +#define __IEnumConnectionPoints_FWD_DEFINED__ +typedef struct IEnumConnectionPoints IEnumConnectionPoints; +#endif + +typedef IConnectionPointContainer *PCONNECTIONPOINTCONTAINER, *LPCONNECTIONPOINTCONTAINER; + +/***************************************************************************** + * IConnectionPointContainer interface + */ +#ifndef __IConnectionPointContainer_INTERFACE_DEFINED__ +#define __IConnectionPointContainer_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IConnectionPointContainer, 0xb196b284, 0xbab4, 0x101a, 0xb6,0x9c, 0x00,0xaa,0x00,0x34,0x1d,0x07); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IConnectionPointContainer : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE EnumConnectionPoints( + IEnumConnectionPoints** ppEnum) = 0; + + virtual HRESULT STDMETHODCALLTYPE FindConnectionPoint( + REFIID riid, + IConnectionPoint** ppCP) = 0; + +}; +#else +typedef struct IConnectionPointContainerVtbl IConnectionPointContainerVtbl; +struct IConnectionPointContainer { + const IConnectionPointContainerVtbl* lpVtbl; +}; +struct IConnectionPointContainerVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IConnectionPointContainer* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IConnectionPointContainer* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IConnectionPointContainer* This); + + /*** IConnectionPointContainer methods ***/ + HRESULT (STDMETHODCALLTYPE *EnumConnectionPoints)( + IConnectionPointContainer* This, + IEnumConnectionPoints** ppEnum); + + HRESULT (STDMETHODCALLTYPE *FindConnectionPoint)( + IConnectionPointContainer* This, + REFIID riid, + IConnectionPoint** ppCP); + +}; + +/*** IUnknown methods ***/ +#define IConnectionPointContainer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IConnectionPointContainer_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IConnectionPointContainer_Release(p) (p)->lpVtbl->Release(p) +/*** IConnectionPointContainer methods ***/ +#define IConnectionPointContainer_EnumConnectionPoints(p,a) (p)->lpVtbl->EnumConnectionPoints(p,a) +#define IConnectionPointContainer_FindConnectionPoint(p,a,b) (p)->lpVtbl->FindConnectionPoint(p,a,b) + +#endif + +#define IConnectionPointContainer_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IConnectionPointContainer methods ***/ \ + STDMETHOD_(HRESULT,EnumConnectionPoints)(THIS_ IEnumConnectionPoints** ppEnum) PURE; \ + STDMETHOD_(HRESULT,FindConnectionPoint)(THIS_ REFIID riid, IConnectionPoint** ppCP) PURE; + +HRESULT CALLBACK IConnectionPointContainer_EnumConnectionPoints_Proxy( + IConnectionPointContainer* This, + IEnumConnectionPoints** ppEnum); +void __RPC_STUB IConnectionPointContainer_EnumConnectionPoints_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IConnectionPointContainer_FindConnectionPoint_Proxy( + IConnectionPointContainer* This, + REFIID riid, + IConnectionPoint** ppCP); +void __RPC_STUB IConnectionPointContainer_FindConnectionPoint_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IConnectionPointContainer_INTERFACE_DEFINED__ */ + +typedef IEnumConnections *PENUMCONNECTIONS, *LPENUMCONNECTIONS; + +typedef struct tagCONNECTDATA { + IUnknown *pUnk; + DWORD dwCookie; +} CONNECTDATA, *PCONNECTDATA, *LPCONNECTDATA; + +/***************************************************************************** + * IEnumConnections interface + */ +#ifndef __IEnumConnections_INTERFACE_DEFINED__ +#define __IEnumConnections_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IEnumConnections, 0xb196b287, 0xbab4, 0x101a, 0xb6,0x9c, 0x00,0xaa,0x00,0x34,0x1d,0x07); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IEnumConnections : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Next( + ULONG cConnections, + LPCONNECTDATA rgcd, + ULONG* pcFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + ULONG cConnections) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + IEnumConnections** ppEnum) = 0; + +}; +#else +typedef struct IEnumConnectionsVtbl IEnumConnectionsVtbl; +struct IEnumConnections { + const IEnumConnectionsVtbl* lpVtbl; +}; +struct IEnumConnectionsVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IEnumConnections* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IEnumConnections* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IEnumConnections* This); + + /*** IEnumConnections methods ***/ + HRESULT (STDMETHODCALLTYPE *Next)( + IEnumConnections* This, + ULONG cConnections, + LPCONNECTDATA rgcd, + ULONG* pcFetched); + + HRESULT (STDMETHODCALLTYPE *Skip)( + IEnumConnections* This, + ULONG cConnections); + + HRESULT (STDMETHODCALLTYPE *Reset)( + IEnumConnections* This); + + HRESULT (STDMETHODCALLTYPE *Clone)( + IEnumConnections* This, + IEnumConnections** ppEnum); + +}; + +/*** IUnknown methods ***/ +#define IEnumConnections_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumConnections_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumConnections_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumConnections methods ***/ +#define IEnumConnections_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumConnections_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumConnections_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumConnections_Clone(p,a) (p)->lpVtbl->Clone(p,a) + +#endif + +#define IEnumConnections_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IEnumConnections methods ***/ \ + STDMETHOD_(HRESULT,Next)(THIS_ ULONG cConnections, LPCONNECTDATA rgcd, ULONG* pcFetched) PURE; \ + STDMETHOD_(HRESULT,Skip)(THIS_ ULONG cConnections) PURE; \ + STDMETHOD_(HRESULT,Reset)(THIS) PURE; \ + STDMETHOD_(HRESULT,Clone)(THIS_ IEnumConnections** ppEnum) PURE; + +HRESULT CALLBACK IEnumConnections_RemoteNext_Proxy( + IEnumConnections* This, + ULONG cConnections, + LPCONNECTDATA rgcd, + ULONG* pcFetched); +void __RPC_STUB IEnumConnections_RemoteNext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumConnections_Next_Proxy( + IEnumConnections* This, + ULONG cConnections, + LPCONNECTDATA rgcd, + ULONG* pcFetched); +HRESULT __RPC_STUB IEnumConnections_Next_Stub( + IEnumConnections* This, + ULONG cConnections, + LPCONNECTDATA rgcd, + ULONG* pcFetched); +HRESULT CALLBACK IEnumConnections_Skip_Proxy( + IEnumConnections* This, + ULONG cConnections); +void __RPC_STUB IEnumConnections_Skip_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumConnections_Reset_Proxy( + IEnumConnections* This); +void __RPC_STUB IEnumConnections_Reset_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumConnections_Clone_Proxy( + IEnumConnections* This, + IEnumConnections** ppEnum); +void __RPC_STUB IEnumConnections_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IEnumConnections_INTERFACE_DEFINED__ */ + +typedef IEnumConnectionPoints *PENUMCONNECTIONPOINTS, *LPENUMCONNECTIONPOINTS; + +/***************************************************************************** + * IEnumConnectionPoints interface + */ +#ifndef __IEnumConnectionPoints_INTERFACE_DEFINED__ +#define __IEnumConnectionPoints_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IEnumConnectionPoints, 0xb196b285, 0xbab4, 0x101a, 0xb6,0x9c, 0x00,0xaa,0x00,0x34,0x1d,0x07); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IEnumConnectionPoints : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Next( + ULONG cConnections, + LPCONNECTIONPOINT* ppCP, + ULONG* pcFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + ULONG cConnections) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + IEnumConnectionPoints** ppEnum) = 0; + +}; +#else +typedef struct IEnumConnectionPointsVtbl IEnumConnectionPointsVtbl; +struct IEnumConnectionPoints { + const IEnumConnectionPointsVtbl* lpVtbl; +}; +struct IEnumConnectionPointsVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IEnumConnectionPoints* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IEnumConnectionPoints* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IEnumConnectionPoints* This); + + /*** IEnumConnectionPoints methods ***/ + HRESULT (STDMETHODCALLTYPE *Next)( + IEnumConnectionPoints* This, + ULONG cConnections, + LPCONNECTIONPOINT* ppCP, + ULONG* pcFetched); + + HRESULT (STDMETHODCALLTYPE *Skip)( + IEnumConnectionPoints* This, + ULONG cConnections); + + HRESULT (STDMETHODCALLTYPE *Reset)( + IEnumConnectionPoints* This); + + HRESULT (STDMETHODCALLTYPE *Clone)( + IEnumConnectionPoints* This, + IEnumConnectionPoints** ppEnum); + +}; + +/*** IUnknown methods ***/ +#define IEnumConnectionPoints_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumConnectionPoints_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumConnectionPoints_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumConnectionPoints methods ***/ +#define IEnumConnectionPoints_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumConnectionPoints_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumConnectionPoints_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumConnectionPoints_Clone(p,a) (p)->lpVtbl->Clone(p,a) + +#endif + +#define IEnumConnectionPoints_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IEnumConnectionPoints methods ***/ \ + STDMETHOD_(HRESULT,Next)(THIS_ ULONG cConnections, LPCONNECTIONPOINT* ppCP, ULONG* pcFetched) PURE; \ + STDMETHOD_(HRESULT,Skip)(THIS_ ULONG cConnections) PURE; \ + STDMETHOD_(HRESULT,Reset)(THIS) PURE; \ + STDMETHOD_(HRESULT,Clone)(THIS_ IEnumConnectionPoints** ppEnum) PURE; + +HRESULT CALLBACK IEnumConnectionPoints_RemoteNext_Proxy( + IEnumConnectionPoints* This, + ULONG cConnections, + LPCONNECTIONPOINT* ppCP, + ULONG* pcFetched); +void __RPC_STUB IEnumConnectionPoints_RemoteNext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumConnectionPoints_Next_Proxy( + IEnumConnectionPoints* This, + ULONG cConnections, + LPCONNECTIONPOINT* ppCP, + ULONG* pcFetched); +HRESULT __RPC_STUB IEnumConnectionPoints_Next_Stub( + IEnumConnectionPoints* This, + ULONG cConnections, + LPCONNECTIONPOINT* ppCP, + ULONG* pcFetched); +HRESULT CALLBACK IEnumConnectionPoints_Skip_Proxy( + IEnumConnectionPoints* This, + ULONG cConnections); +void __RPC_STUB IEnumConnectionPoints_Skip_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumConnectionPoints_Reset_Proxy( + IEnumConnectionPoints* This); +void __RPC_STUB IEnumConnectionPoints_Reset_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumConnectionPoints_Clone_Proxy( + IEnumConnectionPoints* This, + IEnumConnectionPoints** ppEnum); +void __RPC_STUB IEnumConnectionPoints_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IEnumConnectionPoints_INTERFACE_DEFINED__ */ + +#ifndef __IPropertyPageSite_FWD_DEFINED__ +#define __IPropertyPageSite_FWD_DEFINED__ +typedef struct IPropertyPageSite IPropertyPageSite; +#endif + +#ifndef __IPropertyPage_FWD_DEFINED__ +#define __IPropertyPage_FWD_DEFINED__ +typedef struct IPropertyPage IPropertyPage; +#endif + +typedef IPropertyPage *LPPROPERTYPAGE; + +typedef struct tagPROPPAGEINFO { + ULONG cb; + LPOLESTR pszTitle; + SIZE size; + LPOLESTR pszDocString; + LPOLESTR pszHelpFile; + DWORD dwHelpContext; +} PROPPAGEINFO, *LPPROPPAGEINFO; + +/***************************************************************************** + * IPropertyPage interface + */ +#ifndef __IPropertyPage_INTERFACE_DEFINED__ +#define __IPropertyPage_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IPropertyPage, 0xb196b28d, 0xbab4, 0x101a, 0xb6,0x9c, 0x00,0xaa,0x00,0x34,0x1d,0x07); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPropertyPage : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE SetPageSite( + IPropertyPageSite* pPageSite) = 0; + + virtual HRESULT STDMETHODCALLTYPE Activate( + HWND hWndParent, + LPCRECT pRect, + BOOL bModal) = 0; + + virtual HRESULT STDMETHODCALLTYPE Deactivate( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPageInfo( + PROPPAGEINFO* pPageInfo) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetObjects( + ULONG cObjects, + IUnknown** ppUnk) = 0; + + virtual HRESULT STDMETHODCALLTYPE Show( + UINT nCmdShow) = 0; + + virtual HRESULT STDMETHODCALLTYPE Move( + LPCRECT pRect) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsPageDirty( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Apply( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Help( + LPCOLESTR pszHelpDir) = 0; + + virtual HRESULT STDMETHODCALLTYPE TranslateAccelerator( + MSG* pMsg) = 0; + +}; +#else +typedef struct IPropertyPageVtbl IPropertyPageVtbl; +struct IPropertyPage { + const IPropertyPageVtbl* lpVtbl; +}; +struct IPropertyPageVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPropertyPage* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPropertyPage* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPropertyPage* This); + + /*** IPropertyPage methods ***/ + HRESULT (STDMETHODCALLTYPE *SetPageSite)( + IPropertyPage* This, + IPropertyPageSite* pPageSite); + + HRESULT (STDMETHODCALLTYPE *Activate)( + IPropertyPage* This, + HWND hWndParent, + LPCRECT pRect, + BOOL bModal); + + HRESULT (STDMETHODCALLTYPE *Deactivate)( + IPropertyPage* This); + + HRESULT (STDMETHODCALLTYPE *GetPageInfo)( + IPropertyPage* This, + PROPPAGEINFO* pPageInfo); + + HRESULT (STDMETHODCALLTYPE *SetObjects)( + IPropertyPage* This, + ULONG cObjects, + IUnknown** ppUnk); + + HRESULT (STDMETHODCALLTYPE *Show)( + IPropertyPage* This, + UINT nCmdShow); + + HRESULT (STDMETHODCALLTYPE *Move)( + IPropertyPage* This, + LPCRECT pRect); + + HRESULT (STDMETHODCALLTYPE *IsPageDirty)( + IPropertyPage* This); + + HRESULT (STDMETHODCALLTYPE *Apply)( + IPropertyPage* This); + + HRESULT (STDMETHODCALLTYPE *Help)( + IPropertyPage* This, + LPCOLESTR pszHelpDir); + + HRESULT (STDMETHODCALLTYPE *TranslateAccelerator)( + IPropertyPage* This, + MSG* pMsg); + +}; + +/*** IUnknown methods ***/ +#define IPropertyPage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPropertyPage_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPropertyPage_Release(p) (p)->lpVtbl->Release(p) +/*** IPropertyPage methods ***/ +#define IPropertyPage_SetPageSite(p,a) (p)->lpVtbl->SetPageSite(p,a) +#define IPropertyPage_Activate(p,a,b,c) (p)->lpVtbl->Activate(p,a,b,c) +#define IPropertyPage_Deactivate(p) (p)->lpVtbl->Deactivate(p) +#define IPropertyPage_GetPageInfo(p,a) (p)->lpVtbl->GetPageInfo(p,a) +#define IPropertyPage_SetObjects(p,a,b) (p)->lpVtbl->SetObjects(p,a,b) +#define IPropertyPage_Show(p,a) (p)->lpVtbl->Show(p,a) +#define IPropertyPage_Move(p,a) (p)->lpVtbl->Move(p,a) +#define IPropertyPage_IsPageDirty(p) (p)->lpVtbl->IsPageDirty(p) +#define IPropertyPage_Apply(p) (p)->lpVtbl->Apply(p) +#define IPropertyPage_Help(p,a) (p)->lpVtbl->Help(p,a) +#define IPropertyPage_TranslateAccelerator(p,a) (p)->lpVtbl->TranslateAccelerator(p,a) + +#endif + +#define IPropertyPage_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IPropertyPage methods ***/ \ + STDMETHOD_(HRESULT,SetPageSite)(THIS_ IPropertyPageSite* pPageSite) PURE; \ + STDMETHOD_(HRESULT,Activate)(THIS_ HWND hWndParent, LPCRECT pRect, BOOL bModal) PURE; \ + STDMETHOD_(HRESULT,Deactivate)(THIS) PURE; \ + STDMETHOD_(HRESULT,GetPageInfo)(THIS_ PROPPAGEINFO* pPageInfo) PURE; \ + STDMETHOD_(HRESULT,SetObjects)(THIS_ ULONG cObjects, IUnknown** ppUnk) PURE; \ + STDMETHOD_(HRESULT,Show)(THIS_ UINT nCmdShow) PURE; \ + STDMETHOD_(HRESULT,Move)(THIS_ LPCRECT pRect) PURE; \ + STDMETHOD_(HRESULT,IsPageDirty)(THIS) PURE; \ + STDMETHOD_(HRESULT,Apply)(THIS) PURE; \ + STDMETHOD_(HRESULT,Help)(THIS_ LPCOLESTR pszHelpDir) PURE; \ + STDMETHOD_(HRESULT,TranslateAccelerator)(THIS_ MSG* pMsg) PURE; + +HRESULT CALLBACK IPropertyPage_SetPageSite_Proxy( + IPropertyPage* This, + IPropertyPageSite* pPageSite); +void __RPC_STUB IPropertyPage_SetPageSite_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyPage_Activate_Proxy( + IPropertyPage* This, + HWND hWndParent, + LPCRECT pRect, + BOOL bModal); +void __RPC_STUB IPropertyPage_Activate_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyPage_Deactivate_Proxy( + IPropertyPage* This); +void __RPC_STUB IPropertyPage_Deactivate_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyPage_GetPageInfo_Proxy( + IPropertyPage* This, + PROPPAGEINFO* pPageInfo); +void __RPC_STUB IPropertyPage_GetPageInfo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyPage_SetObjects_Proxy( + IPropertyPage* This, + ULONG cObjects, + IUnknown** ppUnk); +void __RPC_STUB IPropertyPage_SetObjects_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyPage_Show_Proxy( + IPropertyPage* This, + UINT nCmdShow); +void __RPC_STUB IPropertyPage_Show_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyPage_Move_Proxy( + IPropertyPage* This, + LPCRECT pRect); +void __RPC_STUB IPropertyPage_Move_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyPage_IsPageDirty_Proxy( + IPropertyPage* This); +void __RPC_STUB IPropertyPage_IsPageDirty_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyPage_Apply_Proxy( + IPropertyPage* This); +void __RPC_STUB IPropertyPage_Apply_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyPage_Help_Proxy( + IPropertyPage* This, + LPCOLESTR pszHelpDir); +void __RPC_STUB IPropertyPage_Help_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyPage_TranslateAccelerator_Proxy( + IPropertyPage* This, + MSG* pMsg); +void __RPC_STUB IPropertyPage_TranslateAccelerator_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPropertyPage_INTERFACE_DEFINED__ */ + +#ifndef __IPropertyPage2_FWD_DEFINED__ +#define __IPropertyPage2_FWD_DEFINED__ +typedef struct IPropertyPage2 IPropertyPage2; +#endif + +typedef IPropertyPage2 *LPPROPERTYPAGE2; + +/***************************************************************************** + * IPropertyPage2 interface + */ +#ifndef __IPropertyPage2_INTERFACE_DEFINED__ +#define __IPropertyPage2_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IPropertyPage2, 0x01e44665, 0x24ac, 0x101b, 0x84,0xed, 0x08,0x00,0x2b,0x2e,0xc7,0x13); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPropertyPage2 : public IPropertyPage +{ + virtual HRESULT STDMETHODCALLTYPE EditProperty( + DISPID dispID) = 0; + +}; +#else +typedef struct IPropertyPage2Vtbl IPropertyPage2Vtbl; +struct IPropertyPage2 { + const IPropertyPage2Vtbl* lpVtbl; +}; +struct IPropertyPage2Vtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPropertyPage2* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPropertyPage2* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPropertyPage2* This); + + /*** IPropertyPage methods ***/ + HRESULT (STDMETHODCALLTYPE *SetPageSite)( + IPropertyPage2* This, + IPropertyPageSite* pPageSite); + + HRESULT (STDMETHODCALLTYPE *Activate)( + IPropertyPage2* This, + HWND hWndParent, + LPCRECT pRect, + BOOL bModal); + + HRESULT (STDMETHODCALLTYPE *Deactivate)( + IPropertyPage2* This); + + HRESULT (STDMETHODCALLTYPE *GetPageInfo)( + IPropertyPage2* This, + PROPPAGEINFO* pPageInfo); + + HRESULT (STDMETHODCALLTYPE *SetObjects)( + IPropertyPage2* This, + ULONG cObjects, + IUnknown** ppUnk); + + HRESULT (STDMETHODCALLTYPE *Show)( + IPropertyPage2* This, + UINT nCmdShow); + + HRESULT (STDMETHODCALLTYPE *Move)( + IPropertyPage2* This, + LPCRECT pRect); + + HRESULT (STDMETHODCALLTYPE *IsPageDirty)( + IPropertyPage2* This); + + HRESULT (STDMETHODCALLTYPE *Apply)( + IPropertyPage2* This); + + HRESULT (STDMETHODCALLTYPE *Help)( + IPropertyPage2* This, + LPCOLESTR pszHelpDir); + + HRESULT (STDMETHODCALLTYPE *TranslateAccelerator)( + IPropertyPage2* This, + MSG* pMsg); + + /*** IPropertyPage2 methods ***/ + HRESULT (STDMETHODCALLTYPE *EditProperty)( + IPropertyPage2* This, + DISPID dispID); + +}; + +/*** IUnknown methods ***/ +#define IPropertyPage2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPropertyPage2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPropertyPage2_Release(p) (p)->lpVtbl->Release(p) +/*** IPropertyPage methods ***/ +#define IPropertyPage2_SetPageSite(p,a) (p)->lpVtbl->SetPageSite(p,a) +#define IPropertyPage2_Activate(p,a,b,c) (p)->lpVtbl->Activate(p,a,b,c) +#define IPropertyPage2_Deactivate(p) (p)->lpVtbl->Deactivate(p) +#define IPropertyPage2_GetPageInfo(p,a) (p)->lpVtbl->GetPageInfo(p,a) +#define IPropertyPage2_SetObjects(p,a,b) (p)->lpVtbl->SetObjects(p,a,b) +#define IPropertyPage2_Show(p,a) (p)->lpVtbl->Show(p,a) +#define IPropertyPage2_Move(p,a) (p)->lpVtbl->Move(p,a) +#define IPropertyPage2_IsPageDirty(p) (p)->lpVtbl->IsPageDirty(p) +#define IPropertyPage2_Apply(p) (p)->lpVtbl->Apply(p) +#define IPropertyPage2_Help(p,a) (p)->lpVtbl->Help(p,a) +#define IPropertyPage2_TranslateAccelerator(p,a) (p)->lpVtbl->TranslateAccelerator(p,a) +/*** IPropertyPage2 methods ***/ +#define IPropertyPage2_EditProperty(p,a) (p)->lpVtbl->EditProperty(p,a) + +#endif + +#define IPropertyPage2_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IPropertyPage methods ***/ \ + STDMETHOD_(HRESULT,SetPageSite)(THIS_ IPropertyPageSite* pPageSite) PURE; \ + STDMETHOD_(HRESULT,Activate)(THIS_ HWND hWndParent, LPCRECT pRect, BOOL bModal) PURE; \ + STDMETHOD_(HRESULT,Deactivate)(THIS) PURE; \ + STDMETHOD_(HRESULT,GetPageInfo)(THIS_ PROPPAGEINFO* pPageInfo) PURE; \ + STDMETHOD_(HRESULT,SetObjects)(THIS_ ULONG cObjects, IUnknown** ppUnk) PURE; \ + STDMETHOD_(HRESULT,Show)(THIS_ UINT nCmdShow) PURE; \ + STDMETHOD_(HRESULT,Move)(THIS_ LPCRECT pRect) PURE; \ + STDMETHOD_(HRESULT,IsPageDirty)(THIS) PURE; \ + STDMETHOD_(HRESULT,Apply)(THIS) PURE; \ + STDMETHOD_(HRESULT,Help)(THIS_ LPCOLESTR pszHelpDir) PURE; \ + STDMETHOD_(HRESULT,TranslateAccelerator)(THIS_ MSG* pMsg) PURE; \ + /*** IPropertyPage2 methods ***/ \ + STDMETHOD_(HRESULT,EditProperty)(THIS_ DISPID dispID) PURE; + +HRESULT CALLBACK IPropertyPage2_EditProperty_Proxy( + IPropertyPage2* This, + DISPID dispID); +void __RPC_STUB IPropertyPage2_EditProperty_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPropertyPage2_INTERFACE_DEFINED__ */ + +typedef IPropertyPageSite *LPPROPERTYPAGESITE; + +typedef enum tagPROPPAGESTATUS { + PROPPAGESTATUS_DIRTY = 0x1, + PROPPAGESTATUS_VALIDATE = 0x2, + PROPPAGESTATUS_CLEAN = 0x4 +} PROPPAGESTATUS; + +/***************************************************************************** + * IPropertyPageSite interface + */ +#ifndef __IPropertyPageSite_INTERFACE_DEFINED__ +#define __IPropertyPageSite_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IPropertyPageSite, 0xb196b28c, 0xbab4, 0x101a, 0xb6,0x9c, 0x00,0xaa,0x00,0x34,0x1d,0x07); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPropertyPageSite : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE OnStatusChange( + DWORD dwFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetLocaleID( + LCID* pLocaleID) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPageContainer( + IUnknown** ppUnk) = 0; + + virtual HRESULT STDMETHODCALLTYPE TranslateAccelerator( + MSG* pMsg) = 0; + +}; +#else +typedef struct IPropertyPageSiteVtbl IPropertyPageSiteVtbl; +struct IPropertyPageSite { + const IPropertyPageSiteVtbl* lpVtbl; +}; +struct IPropertyPageSiteVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPropertyPageSite* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPropertyPageSite* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPropertyPageSite* This); + + /*** IPropertyPageSite methods ***/ + HRESULT (STDMETHODCALLTYPE *OnStatusChange)( + IPropertyPageSite* This, + DWORD dwFlags); + + HRESULT (STDMETHODCALLTYPE *GetLocaleID)( + IPropertyPageSite* This, + LCID* pLocaleID); + + HRESULT (STDMETHODCALLTYPE *GetPageContainer)( + IPropertyPageSite* This, + IUnknown** ppUnk); + + HRESULT (STDMETHODCALLTYPE *TranslateAccelerator)( + IPropertyPageSite* This, + MSG* pMsg); + +}; + +/*** IUnknown methods ***/ +#define IPropertyPageSite_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPropertyPageSite_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPropertyPageSite_Release(p) (p)->lpVtbl->Release(p) +/*** IPropertyPageSite methods ***/ +#define IPropertyPageSite_OnStatusChange(p,a) (p)->lpVtbl->OnStatusChange(p,a) +#define IPropertyPageSite_GetLocaleID(p,a) (p)->lpVtbl->GetLocaleID(p,a) +#define IPropertyPageSite_GetPageContainer(p,a) (p)->lpVtbl->GetPageContainer(p,a) +#define IPropertyPageSite_TranslateAccelerator(p,a) (p)->lpVtbl->TranslateAccelerator(p,a) + +#endif + +#define IPropertyPageSite_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IPropertyPageSite methods ***/ \ + STDMETHOD_(HRESULT,OnStatusChange)(THIS_ DWORD dwFlags) PURE; \ + STDMETHOD_(HRESULT,GetLocaleID)(THIS_ LCID* pLocaleID) PURE; \ + STDMETHOD_(HRESULT,GetPageContainer)(THIS_ IUnknown** ppUnk) PURE; \ + STDMETHOD_(HRESULT,TranslateAccelerator)(THIS_ MSG* pMsg) PURE; + +HRESULT CALLBACK IPropertyPageSite_OnStatusChange_Proxy( + IPropertyPageSite* This, + DWORD dwFlags); +void __RPC_STUB IPropertyPageSite_OnStatusChange_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyPageSite_GetLocaleID_Proxy( + IPropertyPageSite* This, + LCID* pLocaleID); +void __RPC_STUB IPropertyPageSite_GetLocaleID_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyPageSite_GetPageContainer_Proxy( + IPropertyPageSite* This, + IUnknown** ppUnk); +void __RPC_STUB IPropertyPageSite_GetPageContainer_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyPageSite_TranslateAccelerator_Proxy( + IPropertyPageSite* This, + MSG* pMsg); +void __RPC_STUB IPropertyPageSite_TranslateAccelerator_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPropertyPageSite_INTERFACE_DEFINED__ */ + +#ifndef __IPropertyNotifySink_FWD_DEFINED__ +#define __IPropertyNotifySink_FWD_DEFINED__ +typedef struct IPropertyNotifySink IPropertyNotifySink; +#endif + +typedef IPropertyNotifySink *LPPROPERTYNOTIFYSINK; + +/***************************************************************************** + * IPropertyNotifySink interface + */ +#ifndef __IPropertyNotifySink_INTERFACE_DEFINED__ +#define __IPropertyNotifySink_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IPropertyNotifySink, 0x9bfbbc02, 0xeff1, 0x101a, 0x84,0xed, 0x00,0xaa,0x00,0x34,0x1d,0x07); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPropertyNotifySink : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE OnChanged( + DISPID dispID) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnRequestEdit( + DISPID dispID) = 0; + +}; +#else +typedef struct IPropertyNotifySinkVtbl IPropertyNotifySinkVtbl; +struct IPropertyNotifySink { + const IPropertyNotifySinkVtbl* lpVtbl; +}; +struct IPropertyNotifySinkVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPropertyNotifySink* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPropertyNotifySink* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPropertyNotifySink* This); + + /*** IPropertyNotifySink methods ***/ + HRESULT (STDMETHODCALLTYPE *OnChanged)( + IPropertyNotifySink* This, + DISPID dispID); + + HRESULT (STDMETHODCALLTYPE *OnRequestEdit)( + IPropertyNotifySink* This, + DISPID dispID); + +}; + +/*** IUnknown methods ***/ +#define IPropertyNotifySink_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPropertyNotifySink_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPropertyNotifySink_Release(p) (p)->lpVtbl->Release(p) +/*** IPropertyNotifySink methods ***/ +#define IPropertyNotifySink_OnChanged(p,a) (p)->lpVtbl->OnChanged(p,a) +#define IPropertyNotifySink_OnRequestEdit(p,a) (p)->lpVtbl->OnRequestEdit(p,a) + +#endif + +#define IPropertyNotifySink_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IPropertyNotifySink methods ***/ \ + STDMETHOD_(HRESULT,OnChanged)(THIS_ DISPID dispID) PURE; \ + STDMETHOD_(HRESULT,OnRequestEdit)(THIS_ DISPID dispID) PURE; + +HRESULT CALLBACK IPropertyNotifySink_OnChanged_Proxy( + IPropertyNotifySink* This, + DISPID dispID); +void __RPC_STUB IPropertyNotifySink_OnChanged_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyNotifySink_OnRequestEdit_Proxy( + IPropertyNotifySink* This, + DISPID dispID); +void __RPC_STUB IPropertyNotifySink_OnRequestEdit_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPropertyNotifySink_INTERFACE_DEFINED__ */ + +#ifndef __ISimpleFrameSite_FWD_DEFINED__ +#define __ISimpleFrameSite_FWD_DEFINED__ +typedef struct ISimpleFrameSite ISimpleFrameSite; +#endif + +typedef ISimpleFrameSite *LPSIMPLEFRAMESITE; + +/***************************************************************************** + * ISimpleFrameSite interface + */ +#ifndef __ISimpleFrameSite_INTERFACE_DEFINED__ +#define __ISimpleFrameSite_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_ISimpleFrameSite, 0x742b0e01, 0x14e6, 0x101b, 0x91,0x4e, 0x00,0xaa,0x00,0x30,0x0c,0xab); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ISimpleFrameSite : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE PreMessageFilter( + HWND hWnd, + UINT msg, + WPARAM wp, + LPARAM lp, + LRESULT* plResult, + DWORD* pdwCookie) = 0; + + virtual HRESULT STDMETHODCALLTYPE PostMessageFilter( + HWND hWnd, + UINT msg, + WPARAM wp, + LPARAM lp, + LRESULT* plResult, + DWORD dwCookie) = 0; + +}; +#else +typedef struct ISimpleFrameSiteVtbl ISimpleFrameSiteVtbl; +struct ISimpleFrameSite { + const ISimpleFrameSiteVtbl* lpVtbl; +}; +struct ISimpleFrameSiteVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ISimpleFrameSite* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ISimpleFrameSite* This); + + ULONG (STDMETHODCALLTYPE *Release)( + ISimpleFrameSite* This); + + /*** ISimpleFrameSite methods ***/ + HRESULT (STDMETHODCALLTYPE *PreMessageFilter)( + ISimpleFrameSite* This, + HWND hWnd, + UINT msg, + WPARAM wp, + LPARAM lp, + LRESULT* plResult, + DWORD* pdwCookie); + + HRESULT (STDMETHODCALLTYPE *PostMessageFilter)( + ISimpleFrameSite* This, + HWND hWnd, + UINT msg, + WPARAM wp, + LPARAM lp, + LRESULT* plResult, + DWORD dwCookie); + +}; + +/*** IUnknown methods ***/ +#define ISimpleFrameSite_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ISimpleFrameSite_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ISimpleFrameSite_Release(p) (p)->lpVtbl->Release(p) +/*** ISimpleFrameSite methods ***/ +#define ISimpleFrameSite_PreMessageFilter(p,a,b,c,d,e,f) (p)->lpVtbl->PreMessageFilter(p,a,b,c,d,e,f) +#define ISimpleFrameSite_PostMessageFilter(p,a,b,c,d,e,f) (p)->lpVtbl->PostMessageFilter(p,a,b,c,d,e,f) + +#endif + +#define ISimpleFrameSite_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** ISimpleFrameSite methods ***/ \ + STDMETHOD_(HRESULT,PreMessageFilter)(THIS_ HWND hWnd, UINT msg, WPARAM wp, LPARAM lp, LRESULT* plResult, DWORD* pdwCookie) PURE; \ + STDMETHOD_(HRESULT,PostMessageFilter)(THIS_ HWND hWnd, UINT msg, WPARAM wp, LPARAM lp, LRESULT* plResult, DWORD dwCookie) PURE; + +HRESULT CALLBACK ISimpleFrameSite_PreMessageFilter_Proxy( + ISimpleFrameSite* This, + HWND hWnd, + UINT msg, + WPARAM wp, + LPARAM lp, + LRESULT* plResult, + DWORD* pdwCookie); +void __RPC_STUB ISimpleFrameSite_PreMessageFilter_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ISimpleFrameSite_PostMessageFilter_Proxy( + ISimpleFrameSite* This, + HWND hWnd, + UINT msg, + WPARAM wp, + LPARAM lp, + LRESULT* plResult, + DWORD dwCookie); +void __RPC_STUB ISimpleFrameSite_PostMessageFilter_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __ISimpleFrameSite_INTERFACE_DEFINED__ */ + +#ifndef __IPersistStreamInit_FWD_DEFINED__ +#define __IPersistStreamInit_FWD_DEFINED__ +typedef struct IPersistStreamInit IPersistStreamInit; +#endif + +typedef IPersistStreamInit *LPPERSISTSTREAMINIT; + +/***************************************************************************** + * IPersistStreamInit interface + */ +#ifndef __IPersistStreamInit_INTERFACE_DEFINED__ +#define __IPersistStreamInit_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IPersistStreamInit, 0x7fd52380, 0x4e07, 0x101b, 0xae,0x2d, 0x08,0x00,0x2b,0x2e,0xc7,0x13); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPersistStreamInit : public IPersist +{ + virtual HRESULT STDMETHODCALLTYPE IsDirty( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Load( + LPSTREAM pStm) = 0; + + virtual HRESULT STDMETHODCALLTYPE Save( + LPSTREAM pStm, + BOOL fClearDirty) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSizeMax( + ULARGE_INTEGER* pcbSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE InitNew( + ) = 0; + +}; +#else +typedef struct IPersistStreamInitVtbl IPersistStreamInitVtbl; +struct IPersistStreamInit { + const IPersistStreamInitVtbl* lpVtbl; +}; +struct IPersistStreamInitVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPersistStreamInit* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPersistStreamInit* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPersistStreamInit* This); + + /*** IPersist methods ***/ + HRESULT (STDMETHODCALLTYPE *GetClassID)( + IPersistStreamInit* This, + CLSID* pClassID); + + /*** IPersistStreamInit methods ***/ + HRESULT (STDMETHODCALLTYPE *IsDirty)( + IPersistStreamInit* This); + + HRESULT (STDMETHODCALLTYPE *Load)( + IPersistStreamInit* This, + LPSTREAM pStm); + + HRESULT (STDMETHODCALLTYPE *Save)( + IPersistStreamInit* This, + LPSTREAM pStm, + BOOL fClearDirty); + + HRESULT (STDMETHODCALLTYPE *GetSizeMax)( + IPersistStreamInit* This, + ULARGE_INTEGER* pcbSize); + + HRESULT (STDMETHODCALLTYPE *InitNew)( + IPersistStreamInit* This); + +}; + +/*** IUnknown methods ***/ +#define IPersistStreamInit_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPersistStreamInit_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPersistStreamInit_Release(p) (p)->lpVtbl->Release(p) +/*** IPersist methods ***/ +#define IPersistStreamInit_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a) +/*** IPersistStreamInit methods ***/ +#define IPersistStreamInit_IsDirty(p) (p)->lpVtbl->IsDirty(p) +#define IPersistStreamInit_Load(p,a) (p)->lpVtbl->Load(p,a) +#define IPersistStreamInit_Save(p,a,b) (p)->lpVtbl->Save(p,a,b) +#define IPersistStreamInit_GetSizeMax(p,a) (p)->lpVtbl->GetSizeMax(p,a) +#define IPersistStreamInit_InitNew(p) (p)->lpVtbl->InitNew(p) + +#endif + +#define IPersistStreamInit_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IPersist methods ***/ \ + STDMETHOD_(HRESULT,GetClassID)(THIS_ CLSID* pClassID) PURE; \ + /*** IPersistStreamInit methods ***/ \ + STDMETHOD_(HRESULT,IsDirty)(THIS) PURE; \ + STDMETHOD_(HRESULT,Load)(THIS_ LPSTREAM pStm) PURE; \ + STDMETHOD_(HRESULT,Save)(THIS_ LPSTREAM pStm, BOOL fClearDirty) PURE; \ + STDMETHOD_(HRESULT,GetSizeMax)(THIS_ ULARGE_INTEGER* pcbSize) PURE; \ + STDMETHOD_(HRESULT,InitNew)(THIS) PURE; + +HRESULT CALLBACK IPersistStreamInit_IsDirty_Proxy( + IPersistStreamInit* This); +void __RPC_STUB IPersistStreamInit_IsDirty_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistStreamInit_Load_Proxy( + IPersistStreamInit* This, + LPSTREAM pStm); +void __RPC_STUB IPersistStreamInit_Load_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistStreamInit_Save_Proxy( + IPersistStreamInit* This, + LPSTREAM pStm, + BOOL fClearDirty); +void __RPC_STUB IPersistStreamInit_Save_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistStreamInit_GetSizeMax_Proxy( + IPersistStreamInit* This, + ULARGE_INTEGER* pcbSize); +void __RPC_STUB IPersistStreamInit_GetSizeMax_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistStreamInit_InitNew_Proxy( + IPersistStreamInit* This); +void __RPC_STUB IPersistStreamInit_InitNew_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPersistStreamInit_INTERFACE_DEFINED__ */ + +#ifndef __IPersistMemory_FWD_DEFINED__ +#define __IPersistMemory_FWD_DEFINED__ +typedef struct IPersistMemory IPersistMemory; +#endif + +typedef IPersistMemory *LPPERSISTMEMORY; + +/***************************************************************************** + * IPersistMemory interface + */ +#ifndef __IPersistMemory_INTERFACE_DEFINED__ +#define __IPersistMemory_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IPersistMemory, 0xbd1ae5e0, 0xa6ae, 0x11ce, 0xbd,0x37, 0x50,0x42,0x00,0xc1,0x00,0x00); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPersistMemory : public IPersist +{ + virtual HRESULT STDMETHODCALLTYPE IsDirty( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Load( + LPVOID pMem, + ULONG cbSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE Save( + LPVOID pMem, + BOOL fClearDirty, + ULONG cbSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSizeMax( + ULONG* pCbSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE InitNew( + ) = 0; + +}; +#else +typedef struct IPersistMemoryVtbl IPersistMemoryVtbl; +struct IPersistMemory { + const IPersistMemoryVtbl* lpVtbl; +}; +struct IPersistMemoryVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPersistMemory* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPersistMemory* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPersistMemory* This); + + /*** IPersist methods ***/ + HRESULT (STDMETHODCALLTYPE *GetClassID)( + IPersistMemory* This, + CLSID* pClassID); + + /*** IPersistMemory methods ***/ + HRESULT (STDMETHODCALLTYPE *IsDirty)( + IPersistMemory* This); + + HRESULT (STDMETHODCALLTYPE *Load)( + IPersistMemory* This, + LPVOID pMem, + ULONG cbSize); + + HRESULT (STDMETHODCALLTYPE *Save)( + IPersistMemory* This, + LPVOID pMem, + BOOL fClearDirty, + ULONG cbSize); + + HRESULT (STDMETHODCALLTYPE *GetSizeMax)( + IPersistMemory* This, + ULONG* pCbSize); + + HRESULT (STDMETHODCALLTYPE *InitNew)( + IPersistMemory* This); + +}; + +/*** IUnknown methods ***/ +#define IPersistMemory_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPersistMemory_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPersistMemory_Release(p) (p)->lpVtbl->Release(p) +/*** IPersist methods ***/ +#define IPersistMemory_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a) +/*** IPersistMemory methods ***/ +#define IPersistMemory_IsDirty(p) (p)->lpVtbl->IsDirty(p) +#define IPersistMemory_Load(p,a,b) (p)->lpVtbl->Load(p,a,b) +#define IPersistMemory_Save(p,a,b,c) (p)->lpVtbl->Save(p,a,b,c) +#define IPersistMemory_GetSizeMax(p,a) (p)->lpVtbl->GetSizeMax(p,a) +#define IPersistMemory_InitNew(p) (p)->lpVtbl->InitNew(p) + +#endif + +#define IPersistMemory_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IPersist methods ***/ \ + STDMETHOD_(HRESULT,GetClassID)(THIS_ CLSID* pClassID) PURE; \ + /*** IPersistMemory methods ***/ \ + STDMETHOD_(HRESULT,IsDirty)(THIS) PURE; \ + STDMETHOD_(HRESULT,Load)(THIS_ LPVOID pMem, ULONG cbSize) PURE; \ + STDMETHOD_(HRESULT,Save)(THIS_ LPVOID pMem, BOOL fClearDirty, ULONG cbSize) PURE; \ + STDMETHOD_(HRESULT,GetSizeMax)(THIS_ ULONG* pCbSize) PURE; \ + STDMETHOD_(HRESULT,InitNew)(THIS) PURE; + +HRESULT CALLBACK IPersistMemory_IsDirty_Proxy( + IPersistMemory* This); +void __RPC_STUB IPersistMemory_IsDirty_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistMemory_RemoteLoad_Proxy( + IPersistMemory* This, + BYTE* pMem, + ULONG cbSize); +void __RPC_STUB IPersistMemory_RemoteLoad_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistMemory_Load_Proxy( + IPersistMemory* This, + LPVOID pMem, + ULONG cbSize); +HRESULT __RPC_STUB IPersistMemory_Load_Stub( + IPersistMemory* This, + BYTE* pMem, + ULONG cbSize); +HRESULT CALLBACK IPersistMemory_RemoteSave_Proxy( + IPersistMemory* This, + BYTE* pMem, + BOOL fClearDirty, + ULONG cbSize); +void __RPC_STUB IPersistMemory_RemoteSave_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistMemory_Save_Proxy( + IPersistMemory* This, + LPVOID pMem, + BOOL fClearDirty, + ULONG cbSize); +HRESULT __RPC_STUB IPersistMemory_Save_Stub( + IPersistMemory* This, + BYTE* pMem, + BOOL fClearDirty, + ULONG cbSize); +HRESULT CALLBACK IPersistMemory_GetSizeMax_Proxy( + IPersistMemory* This, + ULONG* pCbSize); +void __RPC_STUB IPersistMemory_GetSizeMax_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistMemory_InitNew_Proxy( + IPersistMemory* This); +void __RPC_STUB IPersistMemory_InitNew_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPersistMemory_INTERFACE_DEFINED__ */ + +#ifndef __IPersistPropertyBag_FWD_DEFINED__ +#define __IPersistPropertyBag_FWD_DEFINED__ +typedef struct IPersistPropertyBag IPersistPropertyBag; +#endif + +typedef IPersistPropertyBag *LPPERSISTPROPERTYBAG; + +/***************************************************************************** + * IPersistPropertyBag interface + */ +#ifndef __IPersistPropertyBag_INTERFACE_DEFINED__ +#define __IPersistPropertyBag_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IPersistPropertyBag, 0x37d84f60, 0x42cb, 0x11ce, 0x81,0x35, 0x00,0xaa,0x00,0x4b,0xb8,0x51); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPersistPropertyBag : public IPersist +{ + virtual HRESULT STDMETHODCALLTYPE InitNew( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Load( + IPropertyBag* pPropBag, + IErrorLog* pErrorLog) = 0; + + virtual HRESULT STDMETHODCALLTYPE Save( + IPropertyBag* pPropBag, + BOOL fClearDirty, + BOOL fSaveAllProperties) = 0; + +}; +#else +typedef struct IPersistPropertyBagVtbl IPersistPropertyBagVtbl; +struct IPersistPropertyBag { + const IPersistPropertyBagVtbl* lpVtbl; +}; +struct IPersistPropertyBagVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPersistPropertyBag* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPersistPropertyBag* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPersistPropertyBag* This); + + /*** IPersist methods ***/ + HRESULT (STDMETHODCALLTYPE *GetClassID)( + IPersistPropertyBag* This, + CLSID* pClassID); + + /*** IPersistPropertyBag methods ***/ + HRESULT (STDMETHODCALLTYPE *InitNew)( + IPersistPropertyBag* This); + + HRESULT (STDMETHODCALLTYPE *Load)( + IPersistPropertyBag* This, + IPropertyBag* pPropBag, + IErrorLog* pErrorLog); + + HRESULT (STDMETHODCALLTYPE *Save)( + IPersistPropertyBag* This, + IPropertyBag* pPropBag, + BOOL fClearDirty, + BOOL fSaveAllProperties); + +}; + +/*** IUnknown methods ***/ +#define IPersistPropertyBag_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPersistPropertyBag_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPersistPropertyBag_Release(p) (p)->lpVtbl->Release(p) +/*** IPersist methods ***/ +#define IPersistPropertyBag_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a) +/*** IPersistPropertyBag methods ***/ +#define IPersistPropertyBag_InitNew(p) (p)->lpVtbl->InitNew(p) +#define IPersistPropertyBag_Load(p,a,b) (p)->lpVtbl->Load(p,a,b) +#define IPersistPropertyBag_Save(p,a,b,c) (p)->lpVtbl->Save(p,a,b,c) + +#endif + +#define IPersistPropertyBag_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IPersist methods ***/ \ + STDMETHOD_(HRESULT,GetClassID)(THIS_ CLSID* pClassID) PURE; \ + /*** IPersistPropertyBag methods ***/ \ + STDMETHOD_(HRESULT,InitNew)(THIS) PURE; \ + STDMETHOD_(HRESULT,Load)(THIS_ IPropertyBag* pPropBag, IErrorLog* pErrorLog) PURE; \ + STDMETHOD_(HRESULT,Save)(THIS_ IPropertyBag* pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties) PURE; + +HRESULT CALLBACK IPersistPropertyBag_InitNew_Proxy( + IPersistPropertyBag* This); +void __RPC_STUB IPersistPropertyBag_InitNew_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistPropertyBag_Load_Proxy( + IPersistPropertyBag* This, + IPropertyBag* pPropBag, + IErrorLog* pErrorLog); +void __RPC_STUB IPersistPropertyBag_Load_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistPropertyBag_Save_Proxy( + IPersistPropertyBag* This, + IPropertyBag* pPropBag, + BOOL fClearDirty, + BOOL fSaveAllProperties); +void __RPC_STUB IPersistPropertyBag_Save_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPersistPropertyBag_INTERFACE_DEFINED__ */ + +#ifndef __IPropertyBag2_FWD_DEFINED__ +#define __IPropertyBag2_FWD_DEFINED__ +typedef struct IPropertyBag2 IPropertyBag2; +#endif + +typedef IPropertyBag2 *LPPROPERTYBAG2; + +typedef enum tagPROPBAG2_TYPE { + PROPBAG2_TYPE_UNDEFINED = 0, + PROPBAG2_TYPE_DATA = 1, + PROPBAG2_TYPE_URL = 2, + PROPBAG2_TYPE_OBJECT = 3, + PROPBAG2_TYPE_STREAM = 4, + PROPBAG2_TYPE_STORAGE = 5, + PROPBAG2_TYPE_MONIKER = 6 +} PROPBAG2_TYPE; + +typedef struct tagPROPBAG2 { + DWORD dwType; + VARTYPE vt; + CLIPFORMAT cfType; + DWORD dwHint; + LPOLESTR pstrName; + CLSID clsid; +} PROPBAG2; + +/***************************************************************************** + * IPropertyBag2 interface + */ +#ifndef __IPropertyBag2_INTERFACE_DEFINED__ +#define __IPropertyBag2_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IPropertyBag2, 0x22f55882, 0x280b, 0x11d0, 0xa8,0xa9, 0x00,0xa0,0xc9,0x0c,0x20,0x04); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPropertyBag2 : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Read( + ULONG cProperties, + PROPBAG2* pPropBag, + IErrorLog* pErrLog, + VARIANT* pvarValue, + HRESULT* phrError) = 0; + + virtual HRESULT STDMETHODCALLTYPE Write( + ULONG cProperties, + PROPBAG2* pPropBag, + VARIANT* pvarValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE CountProperties( + ULONG* pcProperties) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPropertyInfo( + ULONG iProperty, + ULONG cProperties, + PROPBAG2* pPropBag, + ULONG* pcProperties) = 0; + + virtual HRESULT STDMETHODCALLTYPE LoadObject( + LPCOLESTR pstrName, + DWORD dwHint, + IUnknown* pUnkObject, + IErrorLog* pErrLog) = 0; + +}; +#else +typedef struct IPropertyBag2Vtbl IPropertyBag2Vtbl; +struct IPropertyBag2 { + const IPropertyBag2Vtbl* lpVtbl; +}; +struct IPropertyBag2Vtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPropertyBag2* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPropertyBag2* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPropertyBag2* This); + + /*** IPropertyBag2 methods ***/ + HRESULT (STDMETHODCALLTYPE *Read)( + IPropertyBag2* This, + ULONG cProperties, + PROPBAG2* pPropBag, + IErrorLog* pErrLog, + VARIANT* pvarValue, + HRESULT* phrError); + + HRESULT (STDMETHODCALLTYPE *Write)( + IPropertyBag2* This, + ULONG cProperties, + PROPBAG2* pPropBag, + VARIANT* pvarValue); + + HRESULT (STDMETHODCALLTYPE *CountProperties)( + IPropertyBag2* This, + ULONG* pcProperties); + + HRESULT (STDMETHODCALLTYPE *GetPropertyInfo)( + IPropertyBag2* This, + ULONG iProperty, + ULONG cProperties, + PROPBAG2* pPropBag, + ULONG* pcProperties); + + HRESULT (STDMETHODCALLTYPE *LoadObject)( + IPropertyBag2* This, + LPCOLESTR pstrName, + DWORD dwHint, + IUnknown* pUnkObject, + IErrorLog* pErrLog); + +}; + +/*** IUnknown methods ***/ +#define IPropertyBag2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPropertyBag2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPropertyBag2_Release(p) (p)->lpVtbl->Release(p) +/*** IPropertyBag2 methods ***/ +#define IPropertyBag2_Read(p,a,b,c,d,e) (p)->lpVtbl->Read(p,a,b,c,d,e) +#define IPropertyBag2_Write(p,a,b,c) (p)->lpVtbl->Write(p,a,b,c) +#define IPropertyBag2_CountProperties(p,a) (p)->lpVtbl->CountProperties(p,a) +#define IPropertyBag2_GetPropertyInfo(p,a,b,c,d) (p)->lpVtbl->GetPropertyInfo(p,a,b,c,d) +#define IPropertyBag2_LoadObject(p,a,b,c,d) (p)->lpVtbl->LoadObject(p,a,b,c,d) + +#endif + +#define IPropertyBag2_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IPropertyBag2 methods ***/ \ + STDMETHOD_(HRESULT,Read)(THIS_ ULONG cProperties, PROPBAG2* pPropBag, IErrorLog* pErrLog, VARIANT* pvarValue, HRESULT* phrError) PURE; \ + STDMETHOD_(HRESULT,Write)(THIS_ ULONG cProperties, PROPBAG2* pPropBag, VARIANT* pvarValue) PURE; \ + STDMETHOD_(HRESULT,CountProperties)(THIS_ ULONG* pcProperties) PURE; \ + STDMETHOD_(HRESULT,GetPropertyInfo)(THIS_ ULONG iProperty, ULONG cProperties, PROPBAG2* pPropBag, ULONG* pcProperties) PURE; \ + STDMETHOD_(HRESULT,LoadObject)(THIS_ LPCOLESTR pstrName, DWORD dwHint, IUnknown* pUnkObject, IErrorLog* pErrLog) PURE; + +HRESULT CALLBACK IPropertyBag2_Read_Proxy( + IPropertyBag2* This, + ULONG cProperties, + PROPBAG2* pPropBag, + IErrorLog* pErrLog, + VARIANT* pvarValue, + HRESULT* phrError); +void __RPC_STUB IPropertyBag2_Read_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyBag2_Write_Proxy( + IPropertyBag2* This, + ULONG cProperties, + PROPBAG2* pPropBag, + VARIANT* pvarValue); +void __RPC_STUB IPropertyBag2_Write_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyBag2_CountProperties_Proxy( + IPropertyBag2* This, + ULONG* pcProperties); +void __RPC_STUB IPropertyBag2_CountProperties_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyBag2_GetPropertyInfo_Proxy( + IPropertyBag2* This, + ULONG iProperty, + ULONG cProperties, + PROPBAG2* pPropBag, + ULONG* pcProperties); +void __RPC_STUB IPropertyBag2_GetPropertyInfo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPropertyBag2_LoadObject_Proxy( + IPropertyBag2* This, + LPCOLESTR pstrName, + DWORD dwHint, + IUnknown* pUnkObject, + IErrorLog* pErrLog); +void __RPC_STUB IPropertyBag2_LoadObject_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPropertyBag2_INTERFACE_DEFINED__ */ + +#ifndef __IPersistPropertyBag2_FWD_DEFINED__ +#define __IPersistPropertyBag2_FWD_DEFINED__ +typedef struct IPersistPropertyBag2 IPersistPropertyBag2; +#endif + +typedef IPersistPropertyBag2 *LPPERSISTPROPERTYBAG2; + +/***************************************************************************** + * IPersistPropertyBag2 interface + */ +#ifndef __IPersistPropertyBag2_INTERFACE_DEFINED__ +#define __IPersistPropertyBag2_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IPersistPropertyBag2, 0x22f55881, 0x280b, 0x11d0, 0xa8,0xa9, 0x00,0xa0,0xc9,0x0c,0x20,0x04); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPersistPropertyBag2 : public IPersist +{ + virtual HRESULT STDMETHODCALLTYPE InitNew( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Load( + IPropertyBag2* pPropBag, + IErrorLog* pErrorLog) = 0; + + virtual HRESULT STDMETHODCALLTYPE Save( + IPropertyBag2* pPropBag, + BOOL fClearDirty, + BOOL fSaveAllProperties) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsDirty( + ) = 0; + +}; +#else +typedef struct IPersistPropertyBag2Vtbl IPersistPropertyBag2Vtbl; +struct IPersistPropertyBag2 { + const IPersistPropertyBag2Vtbl* lpVtbl; +}; +struct IPersistPropertyBag2Vtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPersistPropertyBag2* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPersistPropertyBag2* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPersistPropertyBag2* This); + + /*** IPersist methods ***/ + HRESULT (STDMETHODCALLTYPE *GetClassID)( + IPersistPropertyBag2* This, + CLSID* pClassID); + + /*** IPersistPropertyBag2 methods ***/ + HRESULT (STDMETHODCALLTYPE *InitNew)( + IPersistPropertyBag2* This); + + HRESULT (STDMETHODCALLTYPE *Load)( + IPersistPropertyBag2* This, + IPropertyBag2* pPropBag, + IErrorLog* pErrorLog); + + HRESULT (STDMETHODCALLTYPE *Save)( + IPersistPropertyBag2* This, + IPropertyBag2* pPropBag, + BOOL fClearDirty, + BOOL fSaveAllProperties); + + HRESULT (STDMETHODCALLTYPE *IsDirty)( + IPersistPropertyBag2* This); + +}; + +/*** IUnknown methods ***/ +#define IPersistPropertyBag2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPersistPropertyBag2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPersistPropertyBag2_Release(p) (p)->lpVtbl->Release(p) +/*** IPersist methods ***/ +#define IPersistPropertyBag2_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a) +/*** IPersistPropertyBag2 methods ***/ +#define IPersistPropertyBag2_InitNew(p) (p)->lpVtbl->InitNew(p) +#define IPersistPropertyBag2_Load(p,a,b) (p)->lpVtbl->Load(p,a,b) +#define IPersistPropertyBag2_Save(p,a,b,c) (p)->lpVtbl->Save(p,a,b,c) +#define IPersistPropertyBag2_IsDirty(p) (p)->lpVtbl->IsDirty(p) + +#endif + +#define IPersistPropertyBag2_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IPersist methods ***/ \ + STDMETHOD_(HRESULT,GetClassID)(THIS_ CLSID* pClassID) PURE; \ + /*** IPersistPropertyBag2 methods ***/ \ + STDMETHOD_(HRESULT,InitNew)(THIS) PURE; \ + STDMETHOD_(HRESULT,Load)(THIS_ IPropertyBag2* pPropBag, IErrorLog* pErrorLog) PURE; \ + STDMETHOD_(HRESULT,Save)(THIS_ IPropertyBag2* pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties) PURE; \ + STDMETHOD_(HRESULT,IsDirty)(THIS) PURE; + +HRESULT CALLBACK IPersistPropertyBag2_InitNew_Proxy( + IPersistPropertyBag2* This); +void __RPC_STUB IPersistPropertyBag2_InitNew_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistPropertyBag2_Load_Proxy( + IPersistPropertyBag2* This, + IPropertyBag2* pPropBag, + IErrorLog* pErrorLog); +void __RPC_STUB IPersistPropertyBag2_Load_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistPropertyBag2_Save_Proxy( + IPersistPropertyBag2* This, + IPropertyBag2* pPropBag, + BOOL fClearDirty, + BOOL fSaveAllProperties); +void __RPC_STUB IPersistPropertyBag2_Save_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPersistPropertyBag2_IsDirty_Proxy( + IPersistPropertyBag2* This); +void __RPC_STUB IPersistPropertyBag2_IsDirty_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPersistPropertyBag2_INTERFACE_DEFINED__ */ + +#ifndef __ISpecifyPropertyPages_FWD_DEFINED__ +#define __ISpecifyPropertyPages_FWD_DEFINED__ +typedef struct ISpecifyPropertyPages ISpecifyPropertyPages; +#endif + +typedef ISpecifyPropertyPages *LPSPECIFYPROPERTYPAGES; + +typedef struct tagCAUUID { + ULONG cElems; + GUID *pElems; +} CAUUID, *LPCAUUID; + +/***************************************************************************** + * ISpecifyPropertyPages interface + */ +#ifndef __ISpecifyPropertyPages_INTERFACE_DEFINED__ +#define __ISpecifyPropertyPages_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_ISpecifyPropertyPages, 0xb196b28b, 0xbab4, 0x101a, 0xb6,0x9c, 0x00,0xaa,0x00,0x34,0x1d,0x07); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ISpecifyPropertyPages : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetPages( + CAUUID* pPages) = 0; + +}; +#else +typedef struct ISpecifyPropertyPagesVtbl ISpecifyPropertyPagesVtbl; +struct ISpecifyPropertyPages { + const ISpecifyPropertyPagesVtbl* lpVtbl; +}; +struct ISpecifyPropertyPagesVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ISpecifyPropertyPages* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ISpecifyPropertyPages* This); + + ULONG (STDMETHODCALLTYPE *Release)( + ISpecifyPropertyPages* This); + + /*** ISpecifyPropertyPages methods ***/ + HRESULT (STDMETHODCALLTYPE *GetPages)( + ISpecifyPropertyPages* This, + CAUUID* pPages); + +}; + +/*** IUnknown methods ***/ +#define ISpecifyPropertyPages_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ISpecifyPropertyPages_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ISpecifyPropertyPages_Release(p) (p)->lpVtbl->Release(p) +/*** ISpecifyPropertyPages methods ***/ +#define ISpecifyPropertyPages_GetPages(p,a) (p)->lpVtbl->GetPages(p,a) + +#endif + +#define ISpecifyPropertyPages_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** ISpecifyPropertyPages methods ***/ \ + STDMETHOD_(HRESULT,GetPages)(THIS_ CAUUID* pPages) PURE; + +HRESULT CALLBACK ISpecifyPropertyPages_GetPages_Proxy( + ISpecifyPropertyPages* This, + CAUUID* pPages); +void __RPC_STUB ISpecifyPropertyPages_GetPages_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __ISpecifyPropertyPages_INTERFACE_DEFINED__ */ + +#ifndef __IPerPropertyBrowsing_FWD_DEFINED__ +#define __IPerPropertyBrowsing_FWD_DEFINED__ +typedef struct IPerPropertyBrowsing IPerPropertyBrowsing; +#endif + +typedef IPerPropertyBrowsing *LPPERPROPERTYBROWSING; + +typedef struct tagCALPOLESTR { + ULONG cElems; + LPOLESTR *pElems; +} CALPOLESTR, *LPCALPOLESTR; + +typedef struct tagCADWORD { + ULONG cElems; + DWORD *pElems; +} CADWORD, *LPCADWORD; + +/***************************************************************************** + * IPerPropertyBrowsing interface + */ +#ifndef __IPerPropertyBrowsing_INTERFACE_DEFINED__ +#define __IPerPropertyBrowsing_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IPerPropertyBrowsing, 0x376bd3aa, 0x3845, 0x101b, 0x84,0xed, 0x08,0x00,0x2b,0x2e,0xc7,0x13); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPerPropertyBrowsing : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetDisplayString( + DISPID dispID, + BSTR* pBstr) = 0; + + virtual HRESULT STDMETHODCALLTYPE MapPropertyToPage( + DISPID dispID, + CLSID* pClsid) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPredefinedStrings( + DISPID dispID, + CALPOLESTR* pCaStringsOut, + CADWORD* pCaCookiesOut) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPredefinedValue( + DISPID dispID, + DWORD dwCookie, + VARIANT* pVarOut) = 0; + +}; +#else +typedef struct IPerPropertyBrowsingVtbl IPerPropertyBrowsingVtbl; +struct IPerPropertyBrowsing { + const IPerPropertyBrowsingVtbl* lpVtbl; +}; +struct IPerPropertyBrowsingVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPerPropertyBrowsing* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPerPropertyBrowsing* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPerPropertyBrowsing* This); + + /*** IPerPropertyBrowsing methods ***/ + HRESULT (STDMETHODCALLTYPE *GetDisplayString)( + IPerPropertyBrowsing* This, + DISPID dispID, + BSTR* pBstr); + + HRESULT (STDMETHODCALLTYPE *MapPropertyToPage)( + IPerPropertyBrowsing* This, + DISPID dispID, + CLSID* pClsid); + + HRESULT (STDMETHODCALLTYPE *GetPredefinedStrings)( + IPerPropertyBrowsing* This, + DISPID dispID, + CALPOLESTR* pCaStringsOut, + CADWORD* pCaCookiesOut); + + HRESULT (STDMETHODCALLTYPE *GetPredefinedValue)( + IPerPropertyBrowsing* This, + DISPID dispID, + DWORD dwCookie, + VARIANT* pVarOut); + +}; + +/*** IUnknown methods ***/ +#define IPerPropertyBrowsing_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPerPropertyBrowsing_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPerPropertyBrowsing_Release(p) (p)->lpVtbl->Release(p) +/*** IPerPropertyBrowsing methods ***/ +#define IPerPropertyBrowsing_GetDisplayString(p,a,b) (p)->lpVtbl->GetDisplayString(p,a,b) +#define IPerPropertyBrowsing_MapPropertyToPage(p,a,b) (p)->lpVtbl->MapPropertyToPage(p,a,b) +#define IPerPropertyBrowsing_GetPredefinedStrings(p,a,b,c) (p)->lpVtbl->GetPredefinedStrings(p,a,b,c) +#define IPerPropertyBrowsing_GetPredefinedValue(p,a,b,c) (p)->lpVtbl->GetPredefinedValue(p,a,b,c) + +#endif + +#define IPerPropertyBrowsing_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IPerPropertyBrowsing methods ***/ \ + STDMETHOD_(HRESULT,GetDisplayString)(THIS_ DISPID dispID, BSTR* pBstr) PURE; \ + STDMETHOD_(HRESULT,MapPropertyToPage)(THIS_ DISPID dispID, CLSID* pClsid) PURE; \ + STDMETHOD_(HRESULT,GetPredefinedStrings)(THIS_ DISPID dispID, CALPOLESTR* pCaStringsOut, CADWORD* pCaCookiesOut) PURE; \ + STDMETHOD_(HRESULT,GetPredefinedValue)(THIS_ DISPID dispID, DWORD dwCookie, VARIANT* pVarOut) PURE; + +HRESULT CALLBACK IPerPropertyBrowsing_GetDisplayString_Proxy( + IPerPropertyBrowsing* This, + DISPID dispID, + BSTR* pBstr); +void __RPC_STUB IPerPropertyBrowsing_GetDisplayString_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPerPropertyBrowsing_MapPropertyToPage_Proxy( + IPerPropertyBrowsing* This, + DISPID dispID, + CLSID* pClsid); +void __RPC_STUB IPerPropertyBrowsing_MapPropertyToPage_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPerPropertyBrowsing_GetPredefinedStrings_Proxy( + IPerPropertyBrowsing* This, + DISPID dispID, + CALPOLESTR* pCaStringsOut, + CADWORD* pCaCookiesOut); +void __RPC_STUB IPerPropertyBrowsing_GetPredefinedStrings_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPerPropertyBrowsing_GetPredefinedValue_Proxy( + IPerPropertyBrowsing* This, + DISPID dispID, + DWORD dwCookie, + VARIANT* pVarOut); +void __RPC_STUB IPerPropertyBrowsing_GetPredefinedValue_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPerPropertyBrowsing_INTERFACE_DEFINED__ */ + +#ifndef __IAdviseSinkEx_FWD_DEFINED__ +#define __IAdviseSinkEx_FWD_DEFINED__ +typedef struct IAdviseSinkEx IAdviseSinkEx; +#endif + +typedef IAdviseSinkEx *LPADVISESINKEX; + +/***************************************************************************** + * IAdviseSinkEx interface + */ +#ifndef __IAdviseSinkEx_INTERFACE_DEFINED__ +#define __IAdviseSinkEx_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IAdviseSinkEx, 0x3af24290, 0x0c96, 0x11ce, 0xa0,0xcf, 0x00,0xaa,0x00,0x60,0x0a,0xb8); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IAdviseSinkEx : public IAdviseSink +{ + virtual void STDMETHODCALLTYPE OnViewStatusChange( + DWORD dwViewStatus) = 0; + +}; +#else +typedef struct IAdviseSinkExVtbl IAdviseSinkExVtbl; +struct IAdviseSinkEx { + const IAdviseSinkExVtbl* lpVtbl; +}; +struct IAdviseSinkExVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IAdviseSinkEx* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IAdviseSinkEx* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IAdviseSinkEx* This); + + /*** IAdviseSink methods ***/ + void (STDMETHODCALLTYPE *OnDataChange)( + IAdviseSinkEx* This, + FORMATETC* pFormatetc, + STGMEDIUM* pStgmed); + + void (STDMETHODCALLTYPE *OnViewChange)( + IAdviseSinkEx* This, + DWORD dwAspect, + LONG lindex); + + void (STDMETHODCALLTYPE *OnRename)( + IAdviseSinkEx* This, + IMoniker* pmk); + + void (STDMETHODCALLTYPE *OnSave)( + IAdviseSinkEx* This); + + void (STDMETHODCALLTYPE *OnClose)( + IAdviseSinkEx* This); + + /*** IAdviseSinkEx methods ***/ + void (STDMETHODCALLTYPE *OnViewStatusChange)( + IAdviseSinkEx* This, + DWORD dwViewStatus); + +}; + +/*** IUnknown methods ***/ +#define IAdviseSinkEx_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IAdviseSinkEx_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IAdviseSinkEx_Release(p) (p)->lpVtbl->Release(p) +/*** IAdviseSink methods ***/ +#define IAdviseSinkEx_OnDataChange(p,a,b) (p)->lpVtbl->OnDataChange(p,a,b) +#define IAdviseSinkEx_OnViewChange(p,a,b) (p)->lpVtbl->OnViewChange(p,a,b) +#define IAdviseSinkEx_OnRename(p,a) (p)->lpVtbl->OnRename(p,a) +#define IAdviseSinkEx_OnSave(p) (p)->lpVtbl->OnSave(p) +#define IAdviseSinkEx_OnClose(p) (p)->lpVtbl->OnClose(p) +/*** IAdviseSinkEx methods ***/ +#define IAdviseSinkEx_OnViewStatusChange(p,a) (p)->lpVtbl->OnViewStatusChange(p,a) + +#endif + +#define IAdviseSinkEx_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IAdviseSink methods ***/ \ + STDMETHOD_(void,OnDataChange)(THIS_ FORMATETC* pFormatetc, STGMEDIUM* pStgmed) PURE; \ + STDMETHOD_(void,OnViewChange)(THIS_ DWORD dwAspect, LONG lindex) PURE; \ + STDMETHOD_(void,OnRename)(THIS_ IMoniker* pmk) PURE; \ + STDMETHOD_(void,OnSave)(THIS) PURE; \ + STDMETHOD_(void,OnClose)(THIS) PURE; \ + /*** IAdviseSinkEx methods ***/ \ + STDMETHOD_(void,OnViewStatusChange)(THIS_ DWORD dwViewStatus) PURE; + +HRESULT CALLBACK IAdviseSinkEx_RemoteOnViewStatusChange_Proxy( + IAdviseSinkEx* This, + DWORD dwViewStatus); +void __RPC_STUB IAdviseSinkEx_RemoteOnViewStatusChange_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK IAdviseSinkEx_OnViewStatusChange_Proxy( + IAdviseSinkEx* This, + DWORD dwViewStatus); +HRESULT __RPC_STUB IAdviseSinkEx_OnViewStatusChange_Stub( + IAdviseSinkEx* This, + DWORD dwViewStatus); + +#endif /* __IAdviseSinkEx_INTERFACE_DEFINED__ */ + +#ifndef __IPointerInactive_FWD_DEFINED__ +#define __IPointerInactive_FWD_DEFINED__ +typedef struct IPointerInactive IPointerInactive; +#endif + +typedef IPointerInactive *LPPOINTERINACTIVE; + +/***************************************************************************** + * IPointerInactive interface + */ +#ifndef __IPointerInactive_INTERFACE_DEFINED__ +#define __IPointerInactive_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IPointerInactive, 0x55980ba0, 0x35aa, 0x11cf, 0xb6,0x71, 0x00,0xaa,0x00,0x4c,0xd6,0xd8); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPointerInactive : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetActivationPolicy( + DWORD* pdwPolicy) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnInactiveMouseMove( + LPCRECT pRectBounds, + LONG x, + LONG y, + DWORD grfKeyState) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnInactiveSetCursor( + LPCRECT pRectBounds, + LONG x, + LONG y, + DWORD dwMouseMsg, + BOOL fSetAlways) = 0; + +}; +#else +typedef struct IPointerInactiveVtbl IPointerInactiveVtbl; +struct IPointerInactive { + const IPointerInactiveVtbl* lpVtbl; +}; +struct IPointerInactiveVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPointerInactive* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPointerInactive* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPointerInactive* This); + + /*** IPointerInactive methods ***/ + HRESULT (STDMETHODCALLTYPE *GetActivationPolicy)( + IPointerInactive* This, + DWORD* pdwPolicy); + + HRESULT (STDMETHODCALLTYPE *OnInactiveMouseMove)( + IPointerInactive* This, + LPCRECT pRectBounds, + LONG x, + LONG y, + DWORD grfKeyState); + + HRESULT (STDMETHODCALLTYPE *OnInactiveSetCursor)( + IPointerInactive* This, + LPCRECT pRectBounds, + LONG x, + LONG y, + DWORD dwMouseMsg, + BOOL fSetAlways); + +}; + +/*** IUnknown methods ***/ +#define IPointerInactive_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPointerInactive_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPointerInactive_Release(p) (p)->lpVtbl->Release(p) +/*** IPointerInactive methods ***/ +#define IPointerInactive_GetActivationPolicy(p,a) (p)->lpVtbl->GetActivationPolicy(p,a) +#define IPointerInactive_OnInactiveMouseMove(p,a,b,c,d) (p)->lpVtbl->OnInactiveMouseMove(p,a,b,c,d) +#define IPointerInactive_OnInactiveSetCursor(p,a,b,c,d,e) (p)->lpVtbl->OnInactiveSetCursor(p,a,b,c,d,e) + +#endif + +#define IPointerInactive_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IPointerInactive methods ***/ \ + STDMETHOD_(HRESULT,GetActivationPolicy)(THIS_ DWORD* pdwPolicy) PURE; \ + STDMETHOD_(HRESULT,OnInactiveMouseMove)(THIS_ LPCRECT pRectBounds, LONG x, LONG y, DWORD grfKeyState) PURE; \ + STDMETHOD_(HRESULT,OnInactiveSetCursor)(THIS_ LPCRECT pRectBounds, LONG x, LONG y, DWORD dwMouseMsg, BOOL fSetAlways) PURE; + +HRESULT CALLBACK IPointerInactive_GetActivationPolicy_Proxy( + IPointerInactive* This, + DWORD* pdwPolicy); +void __RPC_STUB IPointerInactive_GetActivationPolicy_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPointerInactive_OnInactiveMouseMove_Proxy( + IPointerInactive* This, + LPCRECT pRectBounds, + LONG x, + LONG y, + DWORD grfKeyState); +void __RPC_STUB IPointerInactive_OnInactiveMouseMove_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPointerInactive_OnInactiveSetCursor_Proxy( + IPointerInactive* This, + LPCRECT pRectBounds, + LONG x, + LONG y, + DWORD dwMouseMsg, + BOOL fSetAlways); +void __RPC_STUB IPointerInactive_OnInactiveSetCursor_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPointerInactive_INTERFACE_DEFINED__ */ + +#ifndef __IOleUndoManager_FWD_DEFINED__ +#define __IOleUndoManager_FWD_DEFINED__ +typedef struct IOleUndoManager IOleUndoManager; +#endif + +#ifndef __IOleUndoUnit_FWD_DEFINED__ +#define __IOleUndoUnit_FWD_DEFINED__ +typedef struct IOleUndoUnit IOleUndoUnit; +#endif + +typedef IOleUndoUnit *LPOLEUNDOUNIT; + +/***************************************************************************** + * IOleUndoUnit interface + */ +#ifndef __IOleUndoUnit_INTERFACE_DEFINED__ +#define __IOleUndoUnit_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IOleUndoUnit, 0x894ad3b0, 0xef97, 0x11ce, 0x9b,0xc9, 0x00,0xaa,0x00,0x60,0x8e,0x01); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IOleUndoUnit : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Do( + IOleUndoManager* pUndoManager) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDescription( + BSTR* pBstr) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetUnitType( + CLSID* pClsid, + LONG* plID) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnNextAdd( + ) = 0; + +}; +#else +typedef struct IOleUndoUnitVtbl IOleUndoUnitVtbl; +struct IOleUndoUnit { + const IOleUndoUnitVtbl* lpVtbl; +}; +struct IOleUndoUnitVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IOleUndoUnit* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IOleUndoUnit* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IOleUndoUnit* This); + + /*** IOleUndoUnit methods ***/ + HRESULT (STDMETHODCALLTYPE *Do)( + IOleUndoUnit* This, + IOleUndoManager* pUndoManager); + + HRESULT (STDMETHODCALLTYPE *GetDescription)( + IOleUndoUnit* This, + BSTR* pBstr); + + HRESULT (STDMETHODCALLTYPE *GetUnitType)( + IOleUndoUnit* This, + CLSID* pClsid, + LONG* plID); + + HRESULT (STDMETHODCALLTYPE *OnNextAdd)( + IOleUndoUnit* This); + +}; + +/*** IUnknown methods ***/ +#define IOleUndoUnit_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IOleUndoUnit_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IOleUndoUnit_Release(p) (p)->lpVtbl->Release(p) +/*** IOleUndoUnit methods ***/ +#define IOleUndoUnit_Do(p,a) (p)->lpVtbl->Do(p,a) +#define IOleUndoUnit_GetDescription(p,a) (p)->lpVtbl->GetDescription(p,a) +#define IOleUndoUnit_GetUnitType(p,a,b) (p)->lpVtbl->GetUnitType(p,a,b) +#define IOleUndoUnit_OnNextAdd(p) (p)->lpVtbl->OnNextAdd(p) + +#endif + +#define IOleUndoUnit_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IOleUndoUnit methods ***/ \ + STDMETHOD_(HRESULT,Do)(THIS_ IOleUndoManager* pUndoManager) PURE; \ + STDMETHOD_(HRESULT,GetDescription)(THIS_ BSTR* pBstr) PURE; \ + STDMETHOD_(HRESULT,GetUnitType)(THIS_ CLSID* pClsid, LONG* plID) PURE; \ + STDMETHOD_(HRESULT,OnNextAdd)(THIS) PURE; + +HRESULT CALLBACK IOleUndoUnit_Do_Proxy( + IOleUndoUnit* This, + IOleUndoManager* pUndoManager); +void __RPC_STUB IOleUndoUnit_Do_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleUndoUnit_GetDescription_Proxy( + IOleUndoUnit* This, + BSTR* pBstr); +void __RPC_STUB IOleUndoUnit_GetDescription_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleUndoUnit_GetUnitType_Proxy( + IOleUndoUnit* This, + CLSID* pClsid, + LONG* plID); +void __RPC_STUB IOleUndoUnit_GetUnitType_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleUndoUnit_OnNextAdd_Proxy( + IOleUndoUnit* This); +void __RPC_STUB IOleUndoUnit_OnNextAdd_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IOleUndoUnit_INTERFACE_DEFINED__ */ + +#ifndef __IOleParentUndoUnit_FWD_DEFINED__ +#define __IOleParentUndoUnit_FWD_DEFINED__ +typedef struct IOleParentUndoUnit IOleParentUndoUnit; +#endif + +typedef IOleParentUndoUnit *LPOLEPARENTUNDOUNIT; + +/***************************************************************************** + * IOleParentUndoUnit interface + */ +#ifndef __IOleParentUndoUnit_INTERFACE_DEFINED__ +#define __IOleParentUndoUnit_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IOleParentUndoUnit, 0xa1faf330, 0xef97, 0x11ce, 0x9b,0xc9, 0x00,0xaa,0x00,0x60,0x8e,0x01); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IOleParentUndoUnit : public IOleUndoUnit +{ + virtual HRESULT STDMETHODCALLTYPE Open( + IOleParentUndoUnit* pPUU) = 0; + + virtual HRESULT STDMETHODCALLTYPE Close( + IOleParentUndoUnit* pPUU, + BOOL fCommit) = 0; + + virtual HRESULT STDMETHODCALLTYPE Add( + IOleUndoUnit* pUU) = 0; + + virtual HRESULT STDMETHODCALLTYPE FindUnit( + IOleUndoUnit* pUU) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetParentState( + DWORD* pdwState) = 0; + +}; +#else +typedef struct IOleParentUndoUnitVtbl IOleParentUndoUnitVtbl; +struct IOleParentUndoUnit { + const IOleParentUndoUnitVtbl* lpVtbl; +}; +struct IOleParentUndoUnitVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IOleParentUndoUnit* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IOleParentUndoUnit* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IOleParentUndoUnit* This); + + /*** IOleUndoUnit methods ***/ + HRESULT (STDMETHODCALLTYPE *Do)( + IOleParentUndoUnit* This, + IOleUndoManager* pUndoManager); + + HRESULT (STDMETHODCALLTYPE *GetDescription)( + IOleParentUndoUnit* This, + BSTR* pBstr); + + HRESULT (STDMETHODCALLTYPE *GetUnitType)( + IOleParentUndoUnit* This, + CLSID* pClsid, + LONG* plID); + + HRESULT (STDMETHODCALLTYPE *OnNextAdd)( + IOleParentUndoUnit* This); + + /*** IOleParentUndoUnit methods ***/ + HRESULT (STDMETHODCALLTYPE *Open)( + IOleParentUndoUnit* This, + IOleParentUndoUnit* pPUU); + + HRESULT (STDMETHODCALLTYPE *Close)( + IOleParentUndoUnit* This, + IOleParentUndoUnit* pPUU, + BOOL fCommit); + + HRESULT (STDMETHODCALLTYPE *Add)( + IOleParentUndoUnit* This, + IOleUndoUnit* pUU); + + HRESULT (STDMETHODCALLTYPE *FindUnit)( + IOleParentUndoUnit* This, + IOleUndoUnit* pUU); + + HRESULT (STDMETHODCALLTYPE *GetParentState)( + IOleParentUndoUnit* This, + DWORD* pdwState); + +}; + +/*** IUnknown methods ***/ +#define IOleParentUndoUnit_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IOleParentUndoUnit_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IOleParentUndoUnit_Release(p) (p)->lpVtbl->Release(p) +/*** IOleUndoUnit methods ***/ +#define IOleParentUndoUnit_Do(p,a) (p)->lpVtbl->Do(p,a) +#define IOleParentUndoUnit_GetDescription(p,a) (p)->lpVtbl->GetDescription(p,a) +#define IOleParentUndoUnit_GetUnitType(p,a,b) (p)->lpVtbl->GetUnitType(p,a,b) +#define IOleParentUndoUnit_OnNextAdd(p) (p)->lpVtbl->OnNextAdd(p) +/*** IOleParentUndoUnit methods ***/ +#define IOleParentUndoUnit_Open(p,a) (p)->lpVtbl->Open(p,a) +#define IOleParentUndoUnit_Close(p,a,b) (p)->lpVtbl->Close(p,a,b) +#define IOleParentUndoUnit_Add(p,a) (p)->lpVtbl->Add(p,a) +#define IOleParentUndoUnit_FindUnit(p,a) (p)->lpVtbl->FindUnit(p,a) +#define IOleParentUndoUnit_GetParentState(p,a) (p)->lpVtbl->GetParentState(p,a) + +#endif + +#define IOleParentUndoUnit_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IOleUndoUnit methods ***/ \ + STDMETHOD_(HRESULT,Do)(THIS_ IOleUndoManager* pUndoManager) PURE; \ + STDMETHOD_(HRESULT,GetDescription)(THIS_ BSTR* pBstr) PURE; \ + STDMETHOD_(HRESULT,GetUnitType)(THIS_ CLSID* pClsid, LONG* plID) PURE; \ + STDMETHOD_(HRESULT,OnNextAdd)(THIS) PURE; \ + /*** IOleParentUndoUnit methods ***/ \ + STDMETHOD_(HRESULT,Open)(THIS_ IOleParentUndoUnit* pPUU) PURE; \ + STDMETHOD_(HRESULT,Close)(THIS_ IOleParentUndoUnit* pPUU, BOOL fCommit) PURE; \ + STDMETHOD_(HRESULT,Add)(THIS_ IOleUndoUnit* pUU) PURE; \ + STDMETHOD_(HRESULT,FindUnit)(THIS_ IOleUndoUnit* pUU) PURE; \ + STDMETHOD_(HRESULT,GetParentState)(THIS_ DWORD* pdwState) PURE; + +HRESULT CALLBACK IOleParentUndoUnit_Open_Proxy( + IOleParentUndoUnit* This, + IOleParentUndoUnit* pPUU); +void __RPC_STUB IOleParentUndoUnit_Open_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleParentUndoUnit_Close_Proxy( + IOleParentUndoUnit* This, + IOleParentUndoUnit* pPUU, + BOOL fCommit); +void __RPC_STUB IOleParentUndoUnit_Close_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleParentUndoUnit_Add_Proxy( + IOleParentUndoUnit* This, + IOleUndoUnit* pUU); +void __RPC_STUB IOleParentUndoUnit_Add_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleParentUndoUnit_FindUnit_Proxy( + IOleParentUndoUnit* This, + IOleUndoUnit* pUU); +void __RPC_STUB IOleParentUndoUnit_FindUnit_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleParentUndoUnit_GetParentState_Proxy( + IOleParentUndoUnit* This, + DWORD* pdwState); +void __RPC_STUB IOleParentUndoUnit_GetParentState_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IOleParentUndoUnit_INTERFACE_DEFINED__ */ + +#ifndef __IEnumOleUndoUnits_FWD_DEFINED__ +#define __IEnumOleUndoUnits_FWD_DEFINED__ +typedef struct IEnumOleUndoUnits IEnumOleUndoUnits; +#endif + +typedef IEnumOleUndoUnits *LPENUMOLEUNDOUNITS; + +/***************************************************************************** + * IEnumOleUndoUnits interface + */ +#ifndef __IEnumOleUndoUnits_INTERFACE_DEFINED__ +#define __IEnumOleUndoUnits_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IEnumOleUndoUnits, 0xb3e7c340, 0xef97, 0x11ce, 0x9b,0xc9, 0x00,0xaa,0x00,0x60,0x8e,0x01); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IEnumOleUndoUnits : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Next( + ULONG cElt, + IOleUndoUnit** rgElt, + ULONG* pcEltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + ULONG cElt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + IEnumOleUndoUnits** ppEnum) = 0; + +}; +#else +typedef struct IEnumOleUndoUnitsVtbl IEnumOleUndoUnitsVtbl; +struct IEnumOleUndoUnits { + const IEnumOleUndoUnitsVtbl* lpVtbl; +}; +struct IEnumOleUndoUnitsVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IEnumOleUndoUnits* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IEnumOleUndoUnits* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IEnumOleUndoUnits* This); + + /*** IEnumOleUndoUnits methods ***/ + HRESULT (STDMETHODCALLTYPE *Next)( + IEnumOleUndoUnits* This, + ULONG cElt, + IOleUndoUnit** rgElt, + ULONG* pcEltFetched); + + HRESULT (STDMETHODCALLTYPE *Skip)( + IEnumOleUndoUnits* This, + ULONG cElt); + + HRESULT (STDMETHODCALLTYPE *Reset)( + IEnumOleUndoUnits* This); + + HRESULT (STDMETHODCALLTYPE *Clone)( + IEnumOleUndoUnits* This, + IEnumOleUndoUnits** ppEnum); + +}; + +/*** IUnknown methods ***/ +#define IEnumOleUndoUnits_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumOleUndoUnits_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumOleUndoUnits_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumOleUndoUnits methods ***/ +#define IEnumOleUndoUnits_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumOleUndoUnits_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumOleUndoUnits_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumOleUndoUnits_Clone(p,a) (p)->lpVtbl->Clone(p,a) + +#endif + +#define IEnumOleUndoUnits_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IEnumOleUndoUnits methods ***/ \ + STDMETHOD_(HRESULT,Next)(THIS_ ULONG cElt, IOleUndoUnit** rgElt, ULONG* pcEltFetched) PURE; \ + STDMETHOD_(HRESULT,Skip)(THIS_ ULONG cElt) PURE; \ + STDMETHOD_(HRESULT,Reset)(THIS) PURE; \ + STDMETHOD_(HRESULT,Clone)(THIS_ IEnumOleUndoUnits** ppEnum) PURE; + +HRESULT CALLBACK IEnumOleUndoUnits_RemoteNext_Proxy( + IEnumOleUndoUnits* This, + ULONG cElt, + IOleUndoUnit** rgElt, + ULONG* pcEltFetched); +void __RPC_STUB IEnumOleUndoUnits_RemoteNext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumOleUndoUnits_Next_Proxy( + IEnumOleUndoUnits* This, + ULONG cElt, + IOleUndoUnit** rgElt, + ULONG* pcEltFetched); +HRESULT __RPC_STUB IEnumOleUndoUnits_Next_Stub( + IEnumOleUndoUnits* This, + ULONG cElt, + IOleUndoUnit** rgElt, + ULONG* pcEltFetched); +HRESULT CALLBACK IEnumOleUndoUnits_Skip_Proxy( + IEnumOleUndoUnits* This, + ULONG cElt); +void __RPC_STUB IEnumOleUndoUnits_Skip_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumOleUndoUnits_Reset_Proxy( + IEnumOleUndoUnits* This); +void __RPC_STUB IEnumOleUndoUnits_Reset_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumOleUndoUnits_Clone_Proxy( + IEnumOleUndoUnits* This, + IEnumOleUndoUnits** ppEnum); +void __RPC_STUB IEnumOleUndoUnits_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IEnumOleUndoUnits_INTERFACE_DEFINED__ */ + +typedef IOleUndoManager *LPOLEUNDOMANAGER; + +/***************************************************************************** + * IOleUndoManager interface + */ +#ifndef __IOleUndoManager_INTERFACE_DEFINED__ +#define __IOleUndoManager_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IOleUndoManager, 0xd001f200, 0xef97, 0x11ce, 0x9b,0xc9, 0x00,0xaa,0x00,0x60,0x8e,0x01); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IOleUndoManager : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Open( + IOleParentUndoUnit* pPUU) = 0; + + virtual HRESULT STDMETHODCALLTYPE Close( + IOleParentUndoUnit* pPUU, + BOOL fCommit) = 0; + + virtual HRESULT STDMETHODCALLTYPE Add( + IOleUndoUnit* pUU) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOpenParentState( + DWORD* pdwState) = 0; + + virtual HRESULT STDMETHODCALLTYPE DiscardFrom( + IOleUndoUnit* pUU) = 0; + + virtual HRESULT STDMETHODCALLTYPE UndoTo( + IOleUndoUnit* pUU) = 0; + + virtual HRESULT STDMETHODCALLTYPE RedoTo( + IOleUndoUnit* pUU) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumUndoable( + IEnumOleUndoUnits** ppEnum) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumRedoable( + IEnumOleUndoUnits** ppEnum) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetLastUndoDescription( + BSTR* pBstr) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetLastRedoDescription( + BSTR* pBstr) = 0; + + virtual HRESULT STDMETHODCALLTYPE Enable( + BOOL fEnable) = 0; + +}; +#else +typedef struct IOleUndoManagerVtbl IOleUndoManagerVtbl; +struct IOleUndoManager { + const IOleUndoManagerVtbl* lpVtbl; +}; +struct IOleUndoManagerVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IOleUndoManager* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IOleUndoManager* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IOleUndoManager* This); + + /*** IOleUndoManager methods ***/ + HRESULT (STDMETHODCALLTYPE *Open)( + IOleUndoManager* This, + IOleParentUndoUnit* pPUU); + + HRESULT (STDMETHODCALLTYPE *Close)( + IOleUndoManager* This, + IOleParentUndoUnit* pPUU, + BOOL fCommit); + + HRESULT (STDMETHODCALLTYPE *Add)( + IOleUndoManager* This, + IOleUndoUnit* pUU); + + HRESULT (STDMETHODCALLTYPE *GetOpenParentState)( + IOleUndoManager* This, + DWORD* pdwState); + + HRESULT (STDMETHODCALLTYPE *DiscardFrom)( + IOleUndoManager* This, + IOleUndoUnit* pUU); + + HRESULT (STDMETHODCALLTYPE *UndoTo)( + IOleUndoManager* This, + IOleUndoUnit* pUU); + + HRESULT (STDMETHODCALLTYPE *RedoTo)( + IOleUndoManager* This, + IOleUndoUnit* pUU); + + HRESULT (STDMETHODCALLTYPE *EnumUndoable)( + IOleUndoManager* This, + IEnumOleUndoUnits** ppEnum); + + HRESULT (STDMETHODCALLTYPE *EnumRedoable)( + IOleUndoManager* This, + IEnumOleUndoUnits** ppEnum); + + HRESULT (STDMETHODCALLTYPE *GetLastUndoDescription)( + IOleUndoManager* This, + BSTR* pBstr); + + HRESULT (STDMETHODCALLTYPE *GetLastRedoDescription)( + IOleUndoManager* This, + BSTR* pBstr); + + HRESULT (STDMETHODCALLTYPE *Enable)( + IOleUndoManager* This, + BOOL fEnable); + +}; + +/*** IUnknown methods ***/ +#define IOleUndoManager_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IOleUndoManager_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IOleUndoManager_Release(p) (p)->lpVtbl->Release(p) +/*** IOleUndoManager methods ***/ +#define IOleUndoManager_Open(p,a) (p)->lpVtbl->Open(p,a) +#define IOleUndoManager_Close(p,a,b) (p)->lpVtbl->Close(p,a,b) +#define IOleUndoManager_Add(p,a) (p)->lpVtbl->Add(p,a) +#define IOleUndoManager_GetOpenParentState(p,a) (p)->lpVtbl->GetOpenParentState(p,a) +#define IOleUndoManager_DiscardFrom(p,a) (p)->lpVtbl->DiscardFrom(p,a) +#define IOleUndoManager_UndoTo(p,a) (p)->lpVtbl->UndoTo(p,a) +#define IOleUndoManager_RedoTo(p,a) (p)->lpVtbl->RedoTo(p,a) +#define IOleUndoManager_EnumUndoable(p,a) (p)->lpVtbl->EnumUndoable(p,a) +#define IOleUndoManager_EnumRedoable(p,a) (p)->lpVtbl->EnumRedoable(p,a) +#define IOleUndoManager_GetLastUndoDescription(p,a) (p)->lpVtbl->GetLastUndoDescription(p,a) +#define IOleUndoManager_GetLastRedoDescription(p,a) (p)->lpVtbl->GetLastRedoDescription(p,a) +#define IOleUndoManager_Enable(p,a) (p)->lpVtbl->Enable(p,a) + +#endif + +#define IOleUndoManager_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IOleUndoManager methods ***/ \ + STDMETHOD_(HRESULT,Open)(THIS_ IOleParentUndoUnit* pPUU) PURE; \ + STDMETHOD_(HRESULT,Close)(THIS_ IOleParentUndoUnit* pPUU, BOOL fCommit) PURE; \ + STDMETHOD_(HRESULT,Add)(THIS_ IOleUndoUnit* pUU) PURE; \ + STDMETHOD_(HRESULT,GetOpenParentState)(THIS_ DWORD* pdwState) PURE; \ + STDMETHOD_(HRESULT,DiscardFrom)(THIS_ IOleUndoUnit* pUU) PURE; \ + STDMETHOD_(HRESULT,UndoTo)(THIS_ IOleUndoUnit* pUU) PURE; \ + STDMETHOD_(HRESULT,RedoTo)(THIS_ IOleUndoUnit* pUU) PURE; \ + STDMETHOD_(HRESULT,EnumUndoable)(THIS_ IEnumOleUndoUnits** ppEnum) PURE; \ + STDMETHOD_(HRESULT,EnumRedoable)(THIS_ IEnumOleUndoUnits** ppEnum) PURE; \ + STDMETHOD_(HRESULT,GetLastUndoDescription)(THIS_ BSTR* pBstr) PURE; \ + STDMETHOD_(HRESULT,GetLastRedoDescription)(THIS_ BSTR* pBstr) PURE; \ + STDMETHOD_(HRESULT,Enable)(THIS_ BOOL fEnable) PURE; + +HRESULT CALLBACK IOleUndoManager_Open_Proxy( + IOleUndoManager* This, + IOleParentUndoUnit* pPUU); +void __RPC_STUB IOleUndoManager_Open_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleUndoManager_Close_Proxy( + IOleUndoManager* This, + IOleParentUndoUnit* pPUU, + BOOL fCommit); +void __RPC_STUB IOleUndoManager_Close_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleUndoManager_Add_Proxy( + IOleUndoManager* This, + IOleUndoUnit* pUU); +void __RPC_STUB IOleUndoManager_Add_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleUndoManager_GetOpenParentState_Proxy( + IOleUndoManager* This, + DWORD* pdwState); +void __RPC_STUB IOleUndoManager_GetOpenParentState_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleUndoManager_DiscardFrom_Proxy( + IOleUndoManager* This, + IOleUndoUnit* pUU); +void __RPC_STUB IOleUndoManager_DiscardFrom_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleUndoManager_UndoTo_Proxy( + IOleUndoManager* This, + IOleUndoUnit* pUU); +void __RPC_STUB IOleUndoManager_UndoTo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleUndoManager_RedoTo_Proxy( + IOleUndoManager* This, + IOleUndoUnit* pUU); +void __RPC_STUB IOleUndoManager_RedoTo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleUndoManager_EnumUndoable_Proxy( + IOleUndoManager* This, + IEnumOleUndoUnits** ppEnum); +void __RPC_STUB IOleUndoManager_EnumUndoable_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleUndoManager_EnumRedoable_Proxy( + IOleUndoManager* This, + IEnumOleUndoUnits** ppEnum); +void __RPC_STUB IOleUndoManager_EnumRedoable_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleUndoManager_GetLastUndoDescription_Proxy( + IOleUndoManager* This, + BSTR* pBstr); +void __RPC_STUB IOleUndoManager_GetLastUndoDescription_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleUndoManager_GetLastRedoDescription_Proxy( + IOleUndoManager* This, + BSTR* pBstr); +void __RPC_STUB IOleUndoManager_GetLastRedoDescription_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOleUndoManager_Enable_Proxy( + IOleUndoManager* This, + BOOL fEnable); +void __RPC_STUB IOleUndoManager_Enable_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IOleUndoManager_INTERFACE_DEFINED__ */ + +#ifndef __IQuickActivate_FWD_DEFINED__ +#define __IQuickActivate_FWD_DEFINED__ +typedef struct IQuickActivate IQuickActivate; +#endif + +typedef IQuickActivate *LPQUICKACTIVATE; + +typedef enum tagQACONTAINERFLAGS { + QACONTAINER_SHOWHATCHING = 0x1, + QACONTAINER_SHOWGRABHANDLES = 0x2, + QACONTAINER_USERMODE = 0x4, + QACONTAINER_DISPLAYASDEFAULT = 0x8, + QACONTAINER_UIDEAD = 0x10, + QACONTAINER_AUTOCLIP = 0x20, + QACONTAINER_MESSAGEREFLECT = 0x40, + QACONTAINER_SUPPORTSMNEMONICS = 0x80 +} QACONTAINERFLAGS; + +typedef DWORD OLE_COLOR; + +typedef struct tagQACONTAINER { + ULONG cbSize; + IOleClientSite *pClientSite; + IAdviseSinkEx *pAdviseSink; + IPropertyNotifySink *pPropertyNotifySink; + IUnknown *pUnkEventSink; + DWORD dwAmbientFlags; + OLE_COLOR colorFore; + OLE_COLOR colorBack; + IFont *pFont; + IOleUndoManager *pUndoMgr; + DWORD dwAppearance; + LONG lcid; + HPALETTE hpal; + IBindHost *pBindHost; + IOleControlSite *pOleControlSite; + IServiceProvider *pServiceProvider; +} QACONTAINER; + +typedef struct tagQACONTROL { + ULONG cbSize; + DWORD dwMiscStatus; + DWORD dwViewStatus; + DWORD dwEventCookie; + DWORD dwPropNotifyCookie; + DWORD dwPointerActivationPolicy; +} QACONTROL; + +/***************************************************************************** + * IQuickActivate interface + */ +#ifndef __IQuickActivate_INTERFACE_DEFINED__ +#define __IQuickActivate_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IQuickActivate, 0xcf51ed10, 0x62fe, 0x11cf, 0xbf,0x86, 0x00,0xa0,0xc9,0x03,0x48,0x36); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IQuickActivate : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE QuickActivate( + QACONTAINER* pQaContainer, + QACONTROL* pQaControl) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetContentExtent( + LPSIZEL pSizel) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetContentExtent( + LPSIZEL pSizel) = 0; + +}; +#else +typedef struct IQuickActivateVtbl IQuickActivateVtbl; +struct IQuickActivate { + const IQuickActivateVtbl* lpVtbl; +}; +struct IQuickActivateVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IQuickActivate* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IQuickActivate* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IQuickActivate* This); + + /*** IQuickActivate methods ***/ + HRESULT (STDMETHODCALLTYPE *QuickActivate)( + IQuickActivate* This, + QACONTAINER* pQaContainer, + QACONTROL* pQaControl); + + HRESULT (STDMETHODCALLTYPE *SetContentExtent)( + IQuickActivate* This, + LPSIZEL pSizel); + + HRESULT (STDMETHODCALLTYPE *GetContentExtent)( + IQuickActivate* This, + LPSIZEL pSizel); + +}; + +/*** IUnknown methods ***/ +#define IQuickActivate_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IQuickActivate_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IQuickActivate_Release(p) (p)->lpVtbl->Release(p) +/*** IQuickActivate methods ***/ +#define IQuickActivate_QuickActivate(p,a,b) (p)->lpVtbl->QuickActivate(p,a,b) +#define IQuickActivate_SetContentExtent(p,a) (p)->lpVtbl->SetContentExtent(p,a) +#define IQuickActivate_GetContentExtent(p,a) (p)->lpVtbl->GetContentExtent(p,a) + +#endif + +#define IQuickActivate_METHODS \ + ICOM_MSVTABLE_COMPAT_FIELDS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IQuickActivate methods ***/ \ + STDMETHOD_(HRESULT,QuickActivate)(THIS_ QACONTAINER* pQaContainer, QACONTROL* pQaControl) PURE; \ + STDMETHOD_(HRESULT,SetContentExtent)(THIS_ LPSIZEL pSizel) PURE; \ + STDMETHOD_(HRESULT,GetContentExtent)(THIS_ LPSIZEL pSizel) PURE; + +HRESULT CALLBACK IQuickActivate_RemoteQuickActivate_Proxy( + IQuickActivate* This, + QACONTAINER* pQaContainer, + QACONTROL* pQaControl); +void __RPC_STUB IQuickActivate_RemoteQuickActivate_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IQuickActivate_QuickActivate_Proxy( + IQuickActivate* This, + QACONTAINER* pQaContainer, + QACONTROL* pQaControl); +HRESULT __RPC_STUB IQuickActivate_QuickActivate_Stub( + IQuickActivate* This, + QACONTAINER* pQaContainer, + QACONTROL* pQaControl); +HRESULT CALLBACK IQuickActivate_SetContentExtent_Proxy( + IQuickActivate* This, + LPSIZEL pSizel); +void __RPC_STUB IQuickActivate_SetContentExtent_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IQuickActivate_GetContentExtent_Proxy( + IQuickActivate* This, + LPSIZEL pSizel); +void __RPC_STUB IQuickActivate_GetContentExtent_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IQuickActivate_INTERFACE_DEFINED__ */ + +#ifdef __cplusplus +} +#endif +#endif /* __WIDL_OCIDL_H */ diff --git a/include/ocidl.idl b/include/ocidl.idl new file mode 100644 index 00000000000..8cadfa762d5 --- /dev/null +++ b/include/ocidl.idl @@ -0,0 +1,1259 @@ +/* + * Copyright (C) 1999 Paul Quinn + * Copyright (C) 1999 Francis Beaudet + * Copyright (C) 2003 Alexandre Julliard + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +import "oleidl.idl"; +import "oaidl.idl"; +import "servprov.idl"; +import "urlmon.idl"; + + +/***************************************************************************** + * IOleControlTypes interface + */ +[ + pointer_default(unique) +] +interface IOleControlTypes +{ + typedef enum tagREADYSTATE + { + READYSTATE_UNINITIALIZED = 0, + READYSTATE_LOADING = 1, + READYSTATE_LOADED = 2, + READYSTATE_INTERACTIVE = 3, + READYSTATE_COMPLETE = 4 + } READYSTATE; + + typedef struct tagVARIANT_BLOB + { + DWORD clSize; + DWORD rpcReserved; + [size_is(clSize-1)] ULONGLONG ahData[]; + } wireVARIANT_BLOB; + + typedef struct tagUserVARIANT + { + wireVARIANT_BLOB pVarBlob; + } UserVARIANT; +} + + +/***************************************************************************** + * IFont interface + */ +[ + object, + uuid(bef6e002-a874-101a-8bba-00aa00300cab), + pointer_default(unique) +] +interface IFont : IUnknown +{ + typedef IFont *LPFONT; + typedef TEXTMETRICW TEXTMETRICOLE, *LPTEXTMETRICOLE; + + HRESULT get_Name( [out] BSTR *pname); + HRESULT put_Name( [in] BSTR name ); + HRESULT get_Size( [out] CY *psize ); + HRESULT put_Size( [in] CY size ); + HRESULT get_Bold( [out] BOOL *pbold ); + HRESULT put_Bold( [in] BOOL bold ); + HRESULT get_Italic( [out] BOOL *pitalic ); + HRESULT put_Italic( [in] BOOL italic ); + HRESULT get_Underline( [out] BOOL *punderline ); + HRESULT put_Underline( [in] BOOL underline ); + HRESULT get_Strikethrough( [out] BOOL *pstrikethrough ); + HRESULT put_Strikethrough( [in] BOOL strikethrough ); + HRESULT get_Weight( [out] SHORT *pweight ); + HRESULT put_Weight( [in] SHORT weight ); + HRESULT get_Charset( [out] SHORT *pcharset ); + HRESULT put_Charset( [in] SHORT charset ); + HRESULT get_hFont( [out] HFONT *phfont ); + HRESULT Clone( [out] IFont **ppfont ); + HRESULT IsEqual( [in] IFont *pFontOther ); + HRESULT SetRatio( [in] LONG cyLogical, [in] LONG cyHimetric ); + HRESULT QueryTextMetrics( [out] TEXTMETRICOLE * ptm ); + HRESULT AddRefHfont( [in] HFONT hfont ); + HRESULT ReleaseHfont( [in] HFONT hfont ); + HRESULT SetHdc( [in] HDC hdc ); +} + + +/***************************************************************************** + * IFontDisp interface + */ +[ + object, + uuid(bef6e003-a874-101a-8bba-00aa00300cab), + pointer_default(unique) +] +interface IFontDisp : IDispatch +{ + typedef IFontDisp *LPFONTDISP; +} + + +/***************************************************************************** + * IPicture interface + */ +[ + object, + uuid(7bf80980-bf32-101a-8bbb-00aa00300cab), + pointer_default(unique) +] +interface IPicture : IUnknown +{ + typedef IPicture *LPPICTURE; + + typedef enum tagPicture + { + PICTURE_SCALABLE = 0x1, + PICTURE_TRANSPARENT = 0x2 + } PICTUREATTRIBUTES; + + typedef UINT OLE_HANDLE; + typedef LONG OLE_XPOS_HIMETRIC; + typedef LONG OLE_YPOS_HIMETRIC; + typedef LONG OLE_XSIZE_HIMETRIC; + typedef LONG OLE_YSIZE_HIMETRIC; + + HRESULT get_Handle( [out] OLE_HANDLE *pHandle ); + HRESULT get_hPal( [out] OLE_HANDLE *phPal ); + HRESULT get_Type( [out] SHORT *pType ); + HRESULT get_Width( [out] OLE_XSIZE_HIMETRIC *pWidth ); + HRESULT get_Height( [out] OLE_YSIZE_HIMETRIC *pHeight ); + + HRESULT Render( + [in] HDC hdc, + [in] LONG x, + [in] LONG y, + [in] LONG cx, + [in] LONG cy, + [in] OLE_XPOS_HIMETRIC xSrc, + [in] OLE_YPOS_HIMETRIC ySrc, + [in] OLE_XSIZE_HIMETRIC cxSrc, + [in] OLE_YSIZE_HIMETRIC cySrc, + [in] LPCRECT pRcWBounds); + + HRESULT set_hPal( [in] OLE_HANDLE hPal ); + + HRESULT get_CurDC( [out] HDC *phDC ); + + HRESULT SelectPicture( + [in] HDC hDCIn, + [out] HDC * phDCOut, + [out] OLE_HANDLE * phBmpOut); + + HRESULT get_KeepOriginalFormat( [out] BOOL *pKeep ); + + HRESULT put_KeepOriginalFormat( [in] BOOL keep ); + + HRESULT PictureChanged(); + + HRESULT SaveAsFile( + [in] LPSTREAM pStream, + [in] BOOL fSaveMemCopy, + [out] LONG *pCbSize); + + HRESULT get_Attributes( [out] DWORD *pDwAttr ); +} + + +/***************************************************************************** + * IPictureDisp interface + */ +[ + object, + uuid(7bf80981-bf32-101a-8bbb-00aa00300cab), + pointer_default(unique) +] +interface IPictureDisp : IDispatch +{ + typedef IPictureDisp *LPPICTUREDISP; +} + + +/***************************************************************************** + * IOleControl interface + */ +[ + object, + uuid(b196b288-bab4-101a-b69c-00aa00341d07), + pointer_default(unique) +] + +interface IOleControl : IUnknown +{ + typedef IOleControl *LPOLECONTROL; + + typedef struct tagCONTROLINFO + { + ULONG cb; + HACCEL hAccel; + USHORT cAccel; + DWORD dwFlags; + } CONTROLINFO, *LPCONTROLINFO; + + typedef enum tagCTRLINFO + { + CTRLINFO_EATS_RETURN = 1, + CTRLINFO_EATS_ESCAPE = 2 + } CTRLINFO; + + HRESULT GetControlInfo( [out] CONTROLINFO *pCI ); + HRESULT OnMnemonic( [in] MSG *pMsg ); + HRESULT OnAmbientPropertyChange( [in] DISPID dispID ); + HRESULT FreezeEvents( [in] BOOL bFreeze ); +} + + +/***************************************************************************** + * IOleControlSite interface + */ +[ + object, + uuid(b196b289-bab4-101a-b69c-00aa00341d07), + pointer_default(unique) +] +interface IOleControlSite : IUnknown +{ + typedef IOleControlSite *LPOLECONTROLSITE; + + typedef struct tagPOINTF + { + FLOAT x; + FLOAT y; + } POINTF, *LPPOINTF; + + typedef enum tagXFORMCOORDS + { + XFORMCOORDS_POSITION = 0x1, + XFORMCOORDS_SIZE = 0x2, + XFORMCOORDS_HIMETRICTOCONTAINER = 0x4, + XFORMCOORDS_CONTAINERTOHIMETRIC = 0x8, + XFORMCOORDS_EVENTCOMPAT = 0x10 + } XFORMCOORDS; + + HRESULT OnControlInfoChanged(); + + HRESULT LockInPlaceActive( [in] BOOL fLock ); + + HRESULT GetExtendedControl( [out] IDispatch ** ppDisp ); + + HRESULT TransformCoords( + [in, out] POINTL *pPtlHimetric, + [in, out] POINTF *pPtfContainer, + [in] DWORD dwFlags); + + HRESULT TranslateAccelerator( [in] MSG *pMsg, [in] DWORD grfModifiers ); + + HRESULT OnFocus( [in] BOOL fGotFocus ); + + HRESULT ShowPropertyFrame(); +} + + +/***************************************************************************** + * IOleInPlaceSiteEx interface + */ +[ + object, + uuid(9c2cad80-3424-11cf-b670-00aa004cd6d8), + pointer_default(unique) +] +interface IOleInPlaceSiteEx : IOleInPlaceSite +{ + typedef IOleInPlaceSiteEx *LPOLEINPLACESITEEX; + + typedef enum tagACTIVATEFLAGS + { + ACTIVATE_WINDOWLESS = 1 + } ACTIVATE_FLAGS; + + HRESULT OnInPlaceActivateEx( [out] BOOL * pfNoRedraw, [in] DWORD dwFlags ); + HRESULT OnInPlaceDeactivateEx( [in] BOOL fNoRedraw ); + HRESULT RequestUIActivate(); +} + + +/***************************************************************************** + * IOleInPlaceSiteWindowless interface + */ +[ + local, + object, + uuid(922eada0-3424-11cf-b670-00aa004cd6d8), + pointer_default(unique) +] +interface IOleInPlaceSiteWindowless : IOleInPlaceSiteEx +{ + typedef IOleInPlaceSiteWindowless *LPOLEINPLACESITEWINDOWLESS; + + typedef enum tagOLEDCFLAGS + { + OLEDC_NODRAW = 0x1, + OLEDC_PAINTBKGND = 0x2, + OLEDC_OFFSCREEN = 0x4 + } OLEDCFLAGS; + + HRESULT CanWindowlessActivate(); + + HRESULT GetCapture(); + + HRESULT SetCapture( [in] BOOL fCapture ); + + HRESULT GetFocus(); + + HRESULT SetFocus( [in] BOOL fFocus ); + + HRESULT GetDC( + [in] LPCRECT pRect, + [in] DWORD grfFlags, + [out] HDC *phDC); + + HRESULT ReleaseDC( [in] HDC hDC ); + + HRESULT InvalidateRect( + [in] LPCRECT pRect, + [in] BOOL fErase); + + HRESULT InvalidateRgn( + [in] HRGN hRGN, + [in] BOOL fErase); + + HRESULT ScrollRect( + [in] INT dx, + [in] INT dy, + [in] LPCRECT pRectScroll, + [in] LPCRECT pRectClip); + + HRESULT AdjustRect( [in, out] LPRECT prc ); + + HRESULT OnDefWindowMessage( + [in] UINT msg, + [in] WPARAM wParam, + [in] LPARAM lParam, + [out] LRESULT *plResult); +} + + +/***************************************************************************** + * IOleInPlaceObjectWindowless interface + */ +[ + local, + object, + uuid(1c2056cc-5ef4-101b-8bc8-00aa003e3b29), + pointer_default(unique) +] +interface IOleInPlaceObjectWindowless : IOleInPlaceObject +{ + typedef IOleInPlaceObjectWindowless *LPOLEINPLACEOBJECTWINDOWLESS; + + HRESULT OnWindowMessage( + [in] UINT msg, + [in] WPARAM wParam, + [in] LPARAM lParam, + [out] LRESULT *plResult); + + HRESULT GetDropTarget( [out] IDropTarget **ppDropTarget ); +} + + +/***************************************************************************** + * IClassFactory2 interface + */ +[ + object, + uuid(b196b28f-bab4-101a-b69c-00aa00341d07), + pointer_default(unique) +] +interface IClassFactory2 : IClassFactory +{ + typedef IClassFactory2 *LPCLASSFACTORY2; + + typedef struct tagLICINFO + { + LONG cbLicInfo; + BOOL fRuntimeKeyAvail; + BOOL fLicVerified; + } LICINFO, *LPLICINFO; + + HRESULT GetLicInfo( [out] LICINFO *pLicInfo ); + + HRESULT RequestLicKey( + [in] DWORD dwReserved, + [out] BSTR *pBstrKey); + + [local] + HRESULT CreateInstanceLic( + [in] IUnknown *pUnkOuter, + [in] IUnknown *pUnkReserved, + [in] REFIID riid, + [in] BSTR bstrKey, + [out, iid_is(riid)] PVOID *ppvObj); + + [call_as(CreateInstanceLic)] + HRESULT RemoteCreateInstanceLic( + [in] REFIID riid, + [in] BSTR bstrKey, + [out, iid_is(riid)] IUnknown **ppvObj); +} + + +/***************************************************************************** + * IViewObject interface + */ +[ + local, + object, + uuid(3af24292-0c96-11ce-a0cf-00aa00600ab8), + pointer_default(unique) +] +interface IViewObjectEx : IViewObject2 +{ + typedef IViewObjectEx *LPVIEWOBJECTEX; + + typedef enum tagVIEWSTATUS + { + VIEWSTATUS_OPAQUE = 1, + VIEWSTATUS_SOLIDBKGND = 2, + VIEWSTATUS_DVASPECTOPAQUE = 4, + VIEWSTATUS_DVASPECTTRANSPARENT = 8, + VIEWSTATUS_SURFACE = 16, + VIEWSTATUS_3DSURFACE = 32 + } VIEWSTATUS; + + typedef enum tagHITRESULT + { + HITRESULT_OUTSIDE = 0, + HITRESULT_TRANSPARENT = 1, + HITRESULT_CLOSE = 2, + HITRESULT_HIT = 3 + } HITRESULT; + + typedef enum tagDVASPECT2 + { + DVASPECT_OPAQUE = 16, + DVASPECT_TRANSPARENT = 32 + } DVASPECT2; + + typedef struct tagExtentInfo + { + ULONG cb; + DWORD dwExtentMode; + SIZEL sizelProposed; + } DVEXTENTINFO; + + typedef enum tagAspectInfoFlag + { + DVASPECTINFOFLAG_CANOPTIMIZE = 1 + } DVASPECTINFOFLAG; + + typedef struct tagAspectInfo + { + ULONG cb; + DWORD dwFlags; + } DVASPECTINFO; + + HRESULT GetRect( + [in] DWORD dwAspect, + [out] LPRECTL pRect); + + HRESULT GetViewStatus( [out] DWORD *pdwStatus ); + + HRESULT QueryHitPoint( + [in] DWORD dwAspect, + [in] LPCRECT pRectBounds, + [in] POINT ptlLoc, + [in] LONG lCloseHint, + [out] DWORD *pHitResult); + + HRESULT QueryHitRect( + [in] DWORD dwAspect, + [in] LPCRECT pRectBounds, + [in] LPCRECT pRectLoc, + [in] LONG lCloseHint, + [out] DWORD *pHitResult); + + HRESULT GetNaturalExtent ( + [in] DWORD dwAspect, + [in] LONG lindex, + [in] DVTARGETDEVICE *ptd, + [in] HDC hicTargetDev, + [in] DVEXTENTINFO *pExtentInfo, + [out] LPSIZEL pSizel); +} + + +/***************************************************************************** + * IProvideClassInfo interface + */ +[ + object, + uuid(b196b283-bab4-101a-b69c-00aa00341d07), + pointer_default(unique) +] +interface IProvideClassInfo : IUnknown +{ + typedef IProvideClassInfo *LPPROVIDECLASSINFO; + +cpp_quote("#ifdef __WINESRC__") +cpp_quote("#undef GetClassInfo") +cpp_quote("#endif") + + HRESULT GetClassInfo( [out] ITypeInfo ** ppTI ); +} + + +/***************************************************************************** + * IProvideClassInfo2 interface + */ +[ + object, + uuid(a6bc3ac0-dbaa-11ce-9de3-00aa004bb851), + pointer_default(unique) +] +interface IProvideClassInfo2 : IProvideClassInfo +{ + typedef IProvideClassInfo2 *LPPROVIDECLASSINFO2; + + typedef enum tagGUIDKIND + { + GUIDKIND_DEFAULT_SOURCE_DISP_IID = 1 + } GUIDKIND; + + HRESULT GetGUID( + [in] DWORD dwGuidKind, + [out] GUID *pGUID ); +} + + +/***************************************************************************** + * IConnectionPoint interface + */ +interface IConnectionPointContainer; /* forward declarations */ +interface IEnumConnections; + +[ + object, + uuid(b196b286-bab4-101a-b69c-00aa00341d07), + pointer_default(unique) +] +interface IConnectionPoint : IUnknown +{ + typedef IConnectionPoint *PCONNECTIONPOINT, *LPCONNECTIONPOINT; + + HRESULT GetConnectionInterface( [out] IID *pIID ); + HRESULT GetConnectionPointContainer( [out] IConnectionPointContainer **ppCPC ); + HRESULT Advise( [in] IUnknown *pUnkSink, [out] DWORD *pdwCookie ); + HRESULT Unadvise( [in] DWORD dwCookie ); + HRESULT EnumConnections( [out] IEnumConnections **ppEnum ); +} + + +/***************************************************************************** + * IConnectionPointContainer interface + */ +interface IEnumConnectionPoints; /* forward declaration */ +[ + object, + uuid(b196b284-bab4-101a-b69c-00aa00341d07), + pointer_default(unique) +] +interface IConnectionPointContainer : IUnknown +{ + typedef IConnectionPointContainer *PCONNECTIONPOINTCONTAINER, *LPCONNECTIONPOINTCONTAINER; + + HRESULT EnumConnectionPoints( [out] IEnumConnectionPoints **ppEnum ); + HRESULT FindConnectionPoint( [in] REFIID riid, [out] IConnectionPoint **ppCP ); +} + + +/***************************************************************************** + * IEnumConnections interface + */ +[ + object, + uuid(b196b287-bab4-101a-b69c-00aa00341d07), + pointer_default(unique) +] +interface IEnumConnections : IUnknown +{ + typedef IEnumConnections *PENUMCONNECTIONS, *LPENUMCONNECTIONS; + + typedef struct tagCONNECTDATA + { + IUnknown *pUnk; + DWORD dwCookie; + } CONNECTDATA, *PCONNECTDATA, *LPCONNECTDATA; + + [local] + HRESULT Next( + [in] ULONG cConnections, + [out, size_is(cConnections), length_is(*pcFetched)] LPCONNECTDATA rgcd, + [out] ULONG *pcFetched); + + [call_as(Next)] + HRESULT RemoteNext( + [in] ULONG cConnections, + [out, size_is(cConnections), length_is(*pcFetched)] LPCONNECTDATA rgcd, + [out] ULONG *pcFetched); + + HRESULT Skip( [in] ULONG cConnections ); + + HRESULT Reset(); + + HRESULT Clone( [out] IEnumConnections **ppEnum ); +} + + +/***************************************************************************** + * IEnumConnectionPoints interface + */ +[ + object, + uuid(b196b285-bab4-101a-b69c-00aa00341d07), + pointer_default(unique) +] +interface IEnumConnectionPoints : IUnknown +{ + typedef IEnumConnectionPoints *PENUMCONNECTIONPOINTS, *LPENUMCONNECTIONPOINTS; + + [local] + HRESULT Next( + [in] ULONG cConnections, + [out, size_is(cConnections), length_is(*pcFetched)] LPCONNECTIONPOINT *ppCP, + [out] ULONG *pcFetched); + + [call_as(Next)] + HRESULT RemoteNext( + [in] ULONG cConnections, + [out, size_is(cConnections), length_is(*pcFetched)] LPCONNECTIONPOINT *ppCP, + [out] ULONG *pcFetched); + + HRESULT Skip( [in] ULONG cConnections ); + + HRESULT Reset(); + + HRESULT Clone( [out] IEnumConnectionPoints **ppEnum ); +} + + +/***************************************************************************** + * IPropertyPage interface + */ +interface IPropertyPageSite; /* forward declaration */ +[ + object, + uuid(b196b28d-bab4-101a-b69c-00aa00341d07), + pointer_default(unique) +] +interface IPropertyPage : IUnknown +{ + typedef IPropertyPage *LPPROPERTYPAGE; + + typedef struct tagPROPPAGEINFO + { + ULONG cb; + LPOLESTR pszTitle; + SIZE size; + LPOLESTR pszDocString; + LPOLESTR pszHelpFile; + DWORD dwHelpContext; + } PROPPAGEINFO, *LPPROPPAGEINFO; + + HRESULT SetPageSite( [in] IPropertyPageSite *pPageSite ); + + HRESULT Activate( + [in] HWND hWndParent, + [in] LPCRECT pRect, + [in] BOOL bModal); + + HRESULT Deactivate(); + + HRESULT GetPageInfo( [out] PROPPAGEINFO *pPageInfo ); + + HRESULT SetObjects( + [in] ULONG cObjects, + [in, size_is(cObjects)] IUnknown **ppUnk); + + HRESULT Show( [in] UINT nCmdShow ); + + HRESULT Move( [in] LPCRECT pRect ); + + HRESULT IsPageDirty(); + + HRESULT Apply(); + + HRESULT Help( [in] LPCOLESTR pszHelpDir ); + + HRESULT TranslateAccelerator( [in] MSG *pMsg ); +} + + +/***************************************************************************** + * IPropertyPage2 interface + */ +[ + object, + uuid(01e44665-24ac-101b-84ed-08002b2ec713), + pointer_default(unique) +] +interface IPropertyPage2 : IPropertyPage +{ + typedef IPropertyPage2 *LPPROPERTYPAGE2; + + HRESULT EditProperty( [in] DISPID dispID ); +} + + +/***************************************************************************** + * IPropertyPageSite interface + */ +[ + object, + uuid(b196b28c-bab4-101a-b69c-00aa00341d07), + pointer_default(unique) +] +interface IPropertyPageSite : IUnknown +{ + typedef IPropertyPageSite *LPPROPERTYPAGESITE; + + typedef enum tagPROPPAGESTATUS + { + PROPPAGESTATUS_DIRTY = 0x1, + PROPPAGESTATUS_VALIDATE = 0x2, + PROPPAGESTATUS_CLEAN = 0x4 + } PROPPAGESTATUS; + + HRESULT OnStatusChange( [in] DWORD dwFlags ); + HRESULT GetLocaleID( [out] LCID *pLocaleID ); + HRESULT GetPageContainer( [out] IUnknown **ppUnk ); + HRESULT TranslateAccelerator( [in] MSG *pMsg ); +} + + +/***************************************************************************** + * IPropertyNotifySink interface + */ +[ + object, + uuid(9bfbbc02-eff1-101a-84ed-00aa00341d07), + pointer_default(unique) +] +interface IPropertyNotifySink : IUnknown +{ + typedef IPropertyNotifySink *LPPROPERTYNOTIFYSINK; + + HRESULT OnChanged( [in] DISPID dispID ); + HRESULT OnRequestEdit( [in] DISPID dispID ); +} + + +/***************************************************************************** + * ISimpleFrameSite interface + */ +[ + object, + uuid(742b0e01-14e6-101b-914e-00aa00300cab), + pointer_default(unique) +] +interface ISimpleFrameSite : IUnknown +{ + typedef ISimpleFrameSite *LPSIMPLEFRAMESITE; + + HRESULT PreMessageFilter( + [in] HWND hWnd, + [in] UINT msg, + [in] WPARAM wp, + [in] LPARAM lp, + [out] LRESULT *plResult, + [out] DWORD *pdwCookie); + + HRESULT PostMessageFilter( + [in] HWND hWnd, + [in] UINT msg, + [in] WPARAM wp, + [in] LPARAM lp, + [out] LRESULT *plResult, + [in] DWORD dwCookie); +} + + +/***************************************************************************** + * IPersistStreamInit interface + */ +[ + object, + uuid(7fd52380-4e07-101b-ae2d-08002b2ec713), + pointer_default(unique) +] +interface IPersistStreamInit : IPersist +{ + typedef IPersistStreamInit *LPPERSISTSTREAMINIT; + + HRESULT IsDirty(); + HRESULT Load( [in] LPSTREAM pStm ); + HRESULT Save( [in] LPSTREAM pStm, [in] BOOL fClearDirty ); + HRESULT GetSizeMax( [out] ULARGE_INTEGER *pcbSize ); + HRESULT InitNew(); +} + + +/***************************************************************************** + * IPersistMemory interface + */ +[ + object, + uuid(bd1ae5e0-a6ae-11ce-bd37-504200c10000), + pointer_default(unique) +] +interface IPersistMemory : IPersist +{ + typedef IPersistMemory *LPPERSISTMEMORY; + + HRESULT IsDirty(); + + [local] + HRESULT Load( + [in, size_is(cbSize)] LPVOID pMem, + [in] ULONG cbSize); + + [call_as(Load)] + HRESULT RemoteLoad( + [in, size_is(cbSize)] BYTE *pMem, + [in] ULONG cbSize); + + [local] + HRESULT Save( + [out, size_is(cbSize)] LPVOID pMem, + [in] BOOL fClearDirty, + [in] ULONG cbSize); + + [call_as(Save)] + HRESULT RemoteSave( + [out, size_is(cbSize)] BYTE *pMem, + [in] BOOL fClearDirty, + [in] ULONG cbSize); + + HRESULT GetSizeMax( [out] ULONG *pCbSize ); + HRESULT InitNew(); +} + + +/***************************************************************************** + * IPersistPropertyBag interface + */ +[ + object, + uuid(37d84f60-42cb-11ce-8135-00aa004bb851), + pointer_default(unique) +] +interface IPersistPropertyBag : IPersist +{ + typedef IPersistPropertyBag *LPPERSISTPROPERTYBAG; + + HRESULT InitNew(); + + HRESULT Load( + [in] IPropertyBag *pPropBag, + [in] IErrorLog *pErrorLog); + + HRESULT Save( + [in] IPropertyBag *pPropBag, + [in] BOOL fClearDirty, + [in] BOOL fSaveAllProperties); +} + + +/***************************************************************************** + * IPropertyBag2 interface + */ +[ + object, + uuid(22f55882-280b-11d0-a8a9-00a0c90c2004), + pointer_default(unique) +] +interface IPropertyBag2 : IUnknown +{ + typedef IPropertyBag2 *LPPROPERTYBAG2; + + typedef enum tagPROPBAG2_TYPE + { + PROPBAG2_TYPE_UNDEFINED = 0, + PROPBAG2_TYPE_DATA = 1, + PROPBAG2_TYPE_URL = 2, + PROPBAG2_TYPE_OBJECT = 3, + PROPBAG2_TYPE_STREAM = 4, + PROPBAG2_TYPE_STORAGE = 5, + PROPBAG2_TYPE_MONIKER = 6 + } PROPBAG2_TYPE; + + typedef struct tagPROPBAG2 + { + DWORD dwType; + VARTYPE vt; + CLIPFORMAT cfType; + DWORD dwHint; + LPOLESTR pstrName; + CLSID clsid; + } PROPBAG2; + + HRESULT Read( + [in] ULONG cProperties, + [in] PROPBAG2 *pPropBag, + [in] IErrorLog *pErrLog, + [out] VARIANT *pvarValue, + [out] HRESULT *phrError); + + HRESULT Write( + [in] ULONG cProperties, + [in] PROPBAG2 *pPropBag, + [in] VARIANT *pvarValue); + + HRESULT CountProperties( + [out] ULONG *pcProperties ); + + HRESULT GetPropertyInfo( + [in] ULONG iProperty, + [in] ULONG cProperties, + [out] PROPBAG2 *pPropBag, + [out] ULONG *pcProperties); + + HRESULT LoadObject( + [in] LPCOLESTR pstrName, + [in] DWORD dwHint, + [in] IUnknown *pUnkObject, + [in] IErrorLog *pErrLog); +} + + +/***************************************************************************** + * IPersistPropertyBag2 interface + */ +[ + object, + uuid(22f55881-280b-11d0-a8a9-00a0c90c2004), + pointer_default(unique) +] +interface IPersistPropertyBag2 : IPersist +{ + typedef IPersistPropertyBag2 *LPPERSISTPROPERTYBAG2; + + HRESULT InitNew(); + + HRESULT Load( + [in] IPropertyBag2 *pPropBag, + [in] IErrorLog *pErrorLog); + + HRESULT Save( + [in] IPropertyBag2 *pPropBag, + [in] BOOL fClearDirty, + [in] BOOL fSaveAllProperties); + + HRESULT IsDirty(); +} + + +/***************************************************************************** + * ISpecifyPropertyPages interface + */ +[ + object, + uuid(b196b28b-bab4-101a-b69c-00aa00341d07), + pointer_default(unique) +] +interface ISpecifyPropertyPages : IUnknown +{ + typedef ISpecifyPropertyPages *LPSPECIFYPROPERTYPAGES; + + typedef struct tagCAUUID + { + ULONG cElems; + [size_is(cElems)] GUID *pElems; + } CAUUID, *LPCAUUID; + + HRESULT GetPages( [out] CAUUID *pPages ); +} + + +/***************************************************************************** + * IPerPropertyBrowsing interface + */ +[ + object, + uuid(376bd3aa-3845-101b-84ed-08002b2ec713), + pointer_default(unique) +] +interface IPerPropertyBrowsing : IUnknown +{ + typedef IPerPropertyBrowsing *LPPERPROPERTYBROWSING; + + typedef struct tagCALPOLESTR + { + ULONG cElems; + [size_is(cElems)] LPOLESTR *pElems; + } CALPOLESTR, *LPCALPOLESTR; + + typedef struct tagCADWORD + { + ULONG cElems; + [size_is(cElems)] DWORD *pElems; + } CADWORD, *LPCADWORD; + + HRESULT GetDisplayString( + [in] DISPID dispID, + [out] BSTR *pBstr); + + HRESULT MapPropertyToPage( + [in] DISPID dispID, + [out] CLSID *pClsid); + + HRESULT GetPredefinedStrings( + [in] DISPID dispID, + [out] CALPOLESTR *pCaStringsOut, + [out] CADWORD *pCaCookiesOut); + + HRESULT GetPredefinedValue( + [in] DISPID dispID, + [in] DWORD dwCookie, + [out] VARIANT *pVarOut); +} + + +/***************************************************************************** + * IAdviseSinkEx interface + */ +[ + object, + uuid(3af24290-0c96-11ce-a0cf-00aa00600ab8), + pointer_default(unique) +] +interface IAdviseSinkEx : IAdviseSink +{ + typedef IAdviseSinkEx *LPADVISESINKEX; + + [local] + void OnViewStatusChange( [in] DWORD dwViewStatus ); + + [call_as(OnViewStatusChange)] + HRESULT RemoteOnViewStatusChange( [in] DWORD dwViewStatus ); +} + + +/***************************************************************************** + * IPointerInactive interface + */ +[ + object, + uuid(55980ba0-35aa-11cf-b671-00aa004cd6d8), + pointer_default(unique) +] +interface IPointerInactive : IUnknown +{ + typedef IPointerInactive *LPPOINTERINACTIVE; + + HRESULT GetActivationPolicy( + [out] DWORD *pdwPolicy); + + HRESULT OnInactiveMouseMove( + [in] LPCRECT pRectBounds, + [in] LONG x, + [in] LONG y, + [in] DWORD grfKeyState); + + HRESULT OnInactiveSetCursor( + [in] LPCRECT pRectBounds, + [in] LONG x, + [in] LONG y, + [in] DWORD dwMouseMsg, + [in] BOOL fSetAlways); +} + + +/***************************************************************************** + * IOleUndoUnit interface + */ +interface IOleUndoManager; /* forward declaration */ +[ + object, + uuid(894ad3b0-ef97-11ce-9bc9-00aa00608e01), + pointer_default(unique) +] +interface IOleUndoUnit : IUnknown +{ + typedef IOleUndoUnit *LPOLEUNDOUNIT; + + HRESULT Do( [in] IOleUndoManager *pUndoManager ); + HRESULT GetDescription( [out] BSTR *pBstr ); + HRESULT GetUnitType( [out] CLSID *pClsid, [out] LONG *plID ); + HRESULT OnNextAdd(); +} + + +/***************************************************************************** + * IOleParentUndoUnit interface + */ +[ + object, + uuid(a1faf330-ef97-11ce-9bc9-00aa00608e01), + pointer_default(unique) +] +interface IOleParentUndoUnit : IOleUndoUnit +{ + typedef IOleParentUndoUnit *LPOLEPARENTUNDOUNIT; + + HRESULT Open( [in] IOleParentUndoUnit *pPUU ); + HRESULT Close( [in] IOleParentUndoUnit *pPUU, [in] BOOL fCommit ); + HRESULT Add( [in] IOleUndoUnit *pUU ); + HRESULT FindUnit( [in] IOleUndoUnit *pUU ); + HRESULT GetParentState( [out] DWORD *pdwState ); +} + + +/***************************************************************************** + * IEnumOleUndoUnits interface + */ +[ + object, + uuid(b3e7c340-ef97-11ce-9bc9-00aa00608e01), + pointer_default(unique) +] +interface IEnumOleUndoUnits : IUnknown +{ + typedef IEnumOleUndoUnits *LPENUMOLEUNDOUNITS; + + [local] + HRESULT Next( + [in] ULONG cElt, + [out, size_is(cElt), length_is(*pcEltFetched)] IOleUndoUnit **rgElt, + [out] ULONG *pcEltFetched); + + [call_as(Next)] + HRESULT RemoteNext( + [in] ULONG cElt, + [out, size_is(cElt), length_is(*pcEltFetched)] IOleUndoUnit **rgElt, + [out] ULONG *pcEltFetched); + + HRESULT Skip( [in] ULONG cElt ); + + HRESULT Reset(); + + HRESULT Clone( [out] IEnumOleUndoUnits **ppEnum ); +} + + +/***************************************************************************** + * IOleUndoManager interface + */ +[ + object, + uuid(d001f200-ef97-11ce-9bc9-00aa00608e01), + pointer_default(unique) +] +interface IOleUndoManager : IUnknown +{ + typedef IOleUndoManager *LPOLEUNDOMANAGER; + + HRESULT Open( [in] IOleParentUndoUnit *pPUU ); + HRESULT Close( [in] IOleParentUndoUnit *pPUU, [in] BOOL fCommit ); + HRESULT Add( [in] IOleUndoUnit *pUU ); + HRESULT GetOpenParentState( [out] DWORD *pdwState ); + HRESULT DiscardFrom( [in] IOleUndoUnit *pUU ); + HRESULT UndoTo( [in] IOleUndoUnit *pUU ); + HRESULT RedoTo( [in] IOleUndoUnit *pUU ); + HRESULT EnumUndoable( [out] IEnumOleUndoUnits **ppEnum ); + HRESULT EnumRedoable( [out] IEnumOleUndoUnits **ppEnum ); + HRESULT GetLastUndoDescription( [out] BSTR *pBstr ); + HRESULT GetLastRedoDescription( [out] BSTR *pBstr ); + HRESULT Enable( [in] BOOL fEnable ); +} + + +/***************************************************************************** + * IQuickActivate interface + */ +[ + object, + uuid(cf51ed10-62fe-11cf-bf86-00a0c9034836), + pointer_default(unique) +] +interface IQuickActivate : IUnknown +{ + typedef IQuickActivate *LPQUICKACTIVATE; + + typedef enum tagQACONTAINERFLAGS + { + QACONTAINER_SHOWHATCHING = 0x1, + QACONTAINER_SHOWGRABHANDLES = 0x2, + QACONTAINER_USERMODE = 0x4, + QACONTAINER_DISPLAYASDEFAULT = 0x8, + QACONTAINER_UIDEAD = 0x10, + QACONTAINER_AUTOCLIP = 0x20, + QACONTAINER_MESSAGEREFLECT = 0x40, + QACONTAINER_SUPPORTSMNEMONICS = 0x80 + } QACONTAINERFLAGS; + + typedef DWORD OLE_COLOR; + + typedef struct tagQACONTAINER + { + ULONG cbSize; + IOleClientSite *pClientSite; + IAdviseSinkEx *pAdviseSink; + IPropertyNotifySink *pPropertyNotifySink; + IUnknown *pUnkEventSink; + DWORD dwAmbientFlags; + OLE_COLOR colorFore; + OLE_COLOR colorBack; + IFont *pFont; + IOleUndoManager *pUndoMgr; + DWORD dwAppearance; + LONG lcid; + HPALETTE hpal; + IBindHost *pBindHost; + IOleControlSite *pOleControlSite; + IServiceProvider *pServiceProvider; + } QACONTAINER; + + typedef struct tagQACONTROL + { + ULONG cbSize; + DWORD dwMiscStatus; + DWORD dwViewStatus; + DWORD dwEventCookie; + DWORD dwPropNotifyCookie; + DWORD dwPointerActivationPolicy; + } QACONTROL; + + [local] + HRESULT QuickActivate( + [in] QACONTAINER *pQaContainer, + [in,out] QACONTROL *pQaControl); + + [call_as(QuickActivate)] + HRESULT RemoteQuickActivate( + [in] QACONTAINER *pQaContainer, + [out] QACONTROL *pQaControl); + + HRESULT SetContentExtent( [in] LPSIZEL pSizel ); + + HRESULT GetContentExtent( [out] LPSIZEL pSizel ); +} diff --git a/include/oleidl.h b/include/oleidl.h index 065d119b7f2..11015bfef35 100644 --- a/include/oleidl.h +++ b/include/oleidl.h @@ -2500,7 +2500,6 @@ typedef enum tagOLECLOSE { OLECLOSE_PROMPTSAVE = 2 } OLECLOSE; -struct tagLOGPALETTE; /***************************************************************************** * IOleObject interface */ @@ -2589,11 +2588,7 @@ struct IOleObject : public IUnknown DWORD* pdwStatus) = 0; virtual HRESULT STDMETHODCALLTYPE SetColorScheme( - struct tagLOGPALETTE { - WORD palVersion; - WORD palNumEntries; - PALETTEENTRY palPalEntry[1]; - }* pLogpal) = 0; + LOGPALETTE* pLogpal) = 0; }; #else @@ -2714,7 +2709,7 @@ struct IOleObjectVtbl { HRESULT (STDMETHODCALLTYPE *SetColorScheme)( IOleObject* This, - struct tagLOGPALETTE* pLogpal); + LOGPALETTE* pLogpal); }; @@ -2774,7 +2769,7 @@ struct IOleObjectVtbl { STDMETHOD_(HRESULT,Unadvise)(THIS_ DWORD dwConnection) PURE; \ STDMETHOD_(HRESULT,EnumAdvise)(THIS_ IEnumSTATDATA** ppenumAdvise) PURE; \ STDMETHOD_(HRESULT,GetMiscStatus)(THIS_ DWORD dwAspect, DWORD* pdwStatus) PURE; \ - STDMETHOD_(HRESULT,SetColorScheme)(THIS_ struct tagLOGPALETTE* pLogpal) PURE; + STDMETHOD_(HRESULT,SetColorScheme)(THIS_ LOGPALETTE* pLogpal) PURE; HRESULT CALLBACK IOleObject_SetClientSite_Proxy( IOleObject* This, @@ -2953,7 +2948,7 @@ void __RPC_STUB IOleObject_GetMiscStatus_Stub( DWORD* pdwStubPhase); HRESULT CALLBACK IOleObject_SetColorScheme_Proxy( IOleObject* This, - struct tagLOGPALETTE* pLogpal); + LOGPALETTE* pLogpal); void __RPC_STUB IOleObject_SetColorScheme_Stub( struct IRpcStubBuffer* This, struct IRpcChannelBuffer* pRpcChannelBuffer, @@ -3231,7 +3226,7 @@ struct IViewObject : public IUnknown void* pvAspect, DVTARGETDEVICE* ptd, HDC hicTargetDev, - struct tagLOGPALETTE** ppColorSet) = 0; + LOGPALETTE** ppColorSet) = 0; virtual HRESULT STDMETHODCALLTYPE Freeze( DWORD dwDrawAspect, @@ -3294,7 +3289,7 @@ struct IViewObjectVtbl { void* pvAspect, DVTARGETDEVICE* ptd, HDC hicTargetDev, - struct tagLOGPALETTE** ppColorSet); + LOGPALETTE** ppColorSet); HRESULT (STDMETHODCALLTYPE *Freeze)( IViewObject* This, @@ -3343,7 +3338,7 @@ struct IViewObjectVtbl { STDMETHOD_(ULONG,Release)(THIS) PURE; \ /*** IViewObject methods ***/ \ STDMETHOD_(HRESULT,Draw)(THIS_ DWORD dwDrawAspect, LONG lindex, void* pvAspect, DVTARGETDEVICE* ptd, HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBounds, BOOL (STDMETHODCALLTYPE *pfnContinue)(ULONG_PTR dwContinue), ULONG_PTR dwContinue) PURE; \ - STDMETHOD_(HRESULT,GetColorSet)(THIS_ DWORD dwDrawAspect, LONG lindex, void* pvAspect, DVTARGETDEVICE* ptd, HDC hicTargetDev, struct tagLOGPALETTE** ppColorSet) PURE; \ + STDMETHOD_(HRESULT,GetColorSet)(THIS_ DWORD dwDrawAspect, LONG lindex, void* pvAspect, DVTARGETDEVICE* ptd, HDC hicTargetDev, LOGPALETTE** ppColorSet) PURE; \ STDMETHOD_(HRESULT,Freeze)(THIS_ DWORD dwDrawAspect, LONG lindex, void* pvAspect, DWORD* pdwFreeze) PURE; \ STDMETHOD_(HRESULT,Unfreeze)(THIS_ DWORD dwFreeze) PURE; \ STDMETHOD_(HRESULT,SetAdvise)(THIS_ DWORD aspects, DWORD advf, IAdviseSink* pAdvSink) PURE; \ @@ -3395,7 +3390,7 @@ HRESULT CALLBACK IViewObject_RemoteGetColorSet_Proxy( ULONG_PTR pvAspect, DVTARGETDEVICE* ptd, ULONG_PTR hicTargetDev, - struct tagLOGPALETTE** ppColorSet); + LOGPALETTE** ppColorSet); void __RPC_STUB IViewObject_RemoteGetColorSet_Stub( struct IRpcStubBuffer* This, struct IRpcChannelBuffer* pRpcChannelBuffer, @@ -3408,7 +3403,7 @@ HRESULT CALLBACK IViewObject_GetColorSet_Proxy( void* pvAspect, DVTARGETDEVICE* ptd, HDC hicTargetDev, - struct tagLOGPALETTE** ppColorSet); + LOGPALETTE** ppColorSet); HRESULT __RPC_STUB IViewObject_GetColorSet_Stub( IViewObject* This, DWORD dwDrawAspect, @@ -3416,7 +3411,7 @@ HRESULT __RPC_STUB IViewObject_GetColorSet_Stub( ULONG_PTR pvAspect, DVTARGETDEVICE* ptd, ULONG_PTR hicTargetDev, - struct tagLOGPALETTE** ppColorSet); + LOGPALETTE** ppColorSet); HRESULT CALLBACK IViewObject_RemoteFreeze_Proxy( IViewObject* This, DWORD dwDrawAspect, @@ -3546,7 +3541,7 @@ struct IViewObject2Vtbl { void* pvAspect, DVTARGETDEVICE* ptd, HDC hicTargetDev, - struct tagLOGPALETTE** ppColorSet); + LOGPALETTE** ppColorSet); HRESULT (STDMETHODCALLTYPE *Freeze)( IViewObject2* This, @@ -3605,7 +3600,7 @@ struct IViewObject2Vtbl { STDMETHOD_(ULONG,Release)(THIS) PURE; \ /*** IViewObject methods ***/ \ STDMETHOD_(HRESULT,Draw)(THIS_ DWORD dwDrawAspect, LONG lindex, void* pvAspect, DVTARGETDEVICE* ptd, HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBounds, BOOL (STDMETHODCALLTYPE *pfnContinue)(ULONG_PTR dwContinue), ULONG_PTR dwContinue) PURE; \ - STDMETHOD_(HRESULT,GetColorSet)(THIS_ DWORD dwDrawAspect, LONG lindex, void* pvAspect, DVTARGETDEVICE* ptd, HDC hicTargetDev, struct tagLOGPALETTE** ppColorSet) PURE; \ + STDMETHOD_(HRESULT,GetColorSet)(THIS_ DWORD dwDrawAspect, LONG lindex, void* pvAspect, DVTARGETDEVICE* ptd, HDC hicTargetDev, LOGPALETTE** ppColorSet) PURE; \ STDMETHOD_(HRESULT,Freeze)(THIS_ DWORD dwDrawAspect, LONG lindex, void* pvAspect, DWORD* pdwFreeze) PURE; \ STDMETHOD_(HRESULT,Unfreeze)(THIS_ DWORD dwFreeze) PURE; \ STDMETHOD_(HRESULT,SetAdvise)(THIS_ DWORD aspects, DWORD advf, IAdviseSink* pAdvSink) PURE; \ diff --git a/include/oleidl.idl b/include/oleidl.idl index 9601c691a59..cac48e8f8b5 100644 --- a/include/oleidl.idl +++ b/include/oleidl.idl @@ -728,10 +728,8 @@ interface IOleObject : IUnknown [in] DWORD dwAspect, [out] DWORD *pdwStatus); -cpp_quote("struct tagLOGPALETTE;") /* FIXME */ - HRESULT SetColorScheme( - [in] struct tagLOGPALETTE *pLogpal); + [in] LOGPALETTE *pLogpal); } @@ -821,7 +819,7 @@ interface IViewObject : IUnknown [in, unique] void *pvAspect, [in, unique] DVTARGETDEVICE *ptd, [in] HDC hicTargetDev, - [out] struct tagLOGPALETTE **ppColorSet); + [out] LOGPALETTE **ppColorSet); [call_as(GetColorSet)] HRESULT RemoteGetColorSet( @@ -830,7 +828,7 @@ interface IViewObject : IUnknown [in] ULONG_PTR pvAspect, [in, unique] DVTARGETDEVICE *ptd, [in] ULONG_PTR hicTargetDev, - [out] struct tagLOGPALETTE **ppColorSet); + [out] LOGPALETTE **ppColorSet); [local] HRESULT Freeze( diff --git a/include/wine/obj_connection.h b/include/wine/obj_connection.h deleted file mode 100644 index 815604f8981..00000000000 --- a/include/wine/obj_connection.h +++ /dev/null @@ -1,159 +0,0 @@ -/* - * Defines the COM interfaces and APIs related to structured data storage. - * - * Depends on 'obj_base.h'. - * - * Copyright (C) 1999 Paul Quinn - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __WINE_WINE_OBJ_CONNECTION_H -#define __WINE_WINE_OBJ_CONNECTION_H - -#ifdef __cplusplus -extern "C" { -#endif /* defined(__cplusplus) */ - -/***************************************************************************** - * Declare the structures - */ - -typedef struct tagCONNECTDATA -{ - IUnknown *pUnk; - DWORD dwCookie; -} CONNECTDATA, *LPCONNECTDATA; - -/***************************************************************************** - * Predeclare the interfaces - */ -DEFINE_GUID(IID_IConnectionPoint, 0xb196b286, 0xbab4, 0x101a, 0xb6, 0x9c, 0x00, 0xaa, 0x00, 0x34, 0x1d, 0x07); -typedef struct IConnectionPoint IConnectionPoint, *LPCONNECTIONPOINT; - -DEFINE_GUID(IID_IConnectionPointContainer, 0xb196b284, 0xbab4, 0x101a, 0xb6, 0x9c, 0x00, 0xaa, 0x00, 0x34, 0x1d, 0x07); -typedef struct IConnectionPointContainer IConnectionPointContainer, *LPCONNECTIONPOINTCONTAINER; - -DEFINE_GUID(IID_IEnumConnections, 0xb196b287, 0xbab4, 0x101a, 0xb6, 0x9c, 0x00, 0xaa, 0x00, 0x34, 0x1d, 0x07); -typedef struct IEnumConnections IEnumConnections, *LPENUMCONNECTIONS; - -DEFINE_GUID(IID_IEnumConnectionPoints, 0xb196b285, 0xbab4, 0x101a, 0xb6, 0x9c, 0x00, 0xaa, 0x00, 0x34, 0x1d, 0x07); -typedef struct IEnumConnectionPoints IEnumConnectionPoints, *LPENUMCONNECTIONPOINTS; - -/***************************************************************************** - * IConnectionPoint interface - */ -#define INTERFACE IConnectionPoint -#define IConnectionPoint_METHODS \ - IUnknown_METHODS \ - STDMETHOD(GetConnectionInterface)(THIS_ IID *pIID) PURE; \ - STDMETHOD(GetConnectionPointContainer)(THIS_ IConnectionPointContainer **ppCPC) PURE; \ - STDMETHOD(Advise)(THIS_ IUnknown *pUnkSink, DWORD *pdwCookie) PURE; \ - STDMETHOD(Unadvise)(THIS_ DWORD dwCookie) PURE; \ - STDMETHOD(EnumConnections)(THIS_ IEnumConnections **ppEnum) PURE; -ICOM_DEFINE(IConnectionPoint,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IConnectionPoint_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IConnectionPoint_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IConnectionPoint_Release(p) (p)->lpVtbl->Release(p) -/*** IConnectionPointContainer methods ***/ -#define IConnectionPoint_GetConnectionInterface(p,a) (p)->lpVtbl->GetConnectionInterface(p,a) -#define IConnectionPoint_GetConnectionPointContainer(p,a) (p)->lpVtbl->GetConnectionPointContainer(p,a) -#define IConnectionPoint_Advise(p,a,b) (p)->lpVtbl->Advise(p,a,b) -#define IConnectionPoint_Unadvise(p,a) (p)->lpVtbl->Unadvise(p,a) -#define IConnectionPoint_EnumConnections(p,a) (p)->lpVtbl->EnumConnections(p,a) -#endif - - -/***************************************************************************** - * IConnectionPointContainer interface - */ -#define INTERFACE IConnectionPointContainer -#define IConnectionPointContainer_METHODS \ - IUnknown_METHODS \ - STDMETHOD(EnumConnectionPoints)(THIS_ IEnumConnectionPoints **ppEnum) PURE; \ - STDMETHOD(FindConnectionPoint)(THIS_ REFIID riid, IConnectionPoint **ppCP) PURE; -ICOM_DEFINE(IConnectionPointContainer,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IConnectionPointContainer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IConnectionPointContainer_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IConnectionPointContainer_Release(p) (p)->lpVtbl->Release(p) -/*** IConnectionPointContainer methods ***/ -#define IConnectionPointContainer_EnumConnectionPoints(p,a) (p)->lpVtbl->EnumConnectionPoints(p,a) -#define IConnectionPointContainer_FindConnectionPoint(p,a,b) (p)->lpVtbl->FindConnectionPoint(p,a,b) -#endif - - -/***************************************************************************** - * IEnumConnections interface - */ -#define INTERFACE IEnumConnections -#define IEnumConnections_METHODS \ - IUnknown_METHODS \ - STDMETHOD(Next)(THIS_ ULONG cConnections, LPCONNECTDATA rgcd, ULONG *pcFectched) PURE; \ - STDMETHOD(Skip)(THIS_ ULONG cConnections) PURE; \ - STDMETHOD(Reset)(THIS) PURE; \ - STDMETHOD(Clone)(THIS_ IEnumConnections **ppEnum) PURE; -ICOM_DEFINE(IEnumConnections,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IEnumConnections_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IEnumConnections_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IEnumConnections_Release(p) (p)->lpVtbl->Release(p) -/*** IConnectionPointContainer methods ***/ -#define IEnumConnections_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) -#define IEnumConnections_Skip(p,a) (p)->lpVtbl->Skip(p,a) -#define IEnumConnections_Reset(p) (p)->lpVtbl->Reset(p) -#define IEnumConnections_Clone(p,a) (p)->lpVtbl->Clone(p,a) -#endif - -/***************************************************************************** - * IEnumConnectionPoints interface - */ -#define INTERFACE IEnumConnectionPoints -#define IEnumConnectionPoints_METHODS \ - IUnknown_METHODS \ - STDMETHOD(Next)(THIS_ ULONG cConnections, LPCONNECTIONPOINT *ppCP, ULONG *pcFectched) PURE; \ - STDMETHOD(Skip)(THIS_ ULONG cConnections) PURE; \ - STDMETHOD(Reset)(THIS) PURE; \ - STDMETHOD(Clone)(THIS_ IEnumConnections **ppEnum) PURE; -ICOM_DEFINE(IEnumConnectionPoints,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IEnumConnectionPoints_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IEnumConnectionPoints_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IEnumConnectionPoints_Release(p) (p)->lpVtbl->Release(p) -/*** IConnectionPointContainer methods ***/ -#define IEnumConnectionPoints_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) -#define IEnumConnectionPoints_Skip(p,a) (p)->lpVtbl->Skip(p,a) -#define IEnumConnectionPoints_Reset(p) (p)->lpVtbl->Reset(p) -#define IEnumConnectionPoints_Clone(p,a) (p)->lpVtbl->Clone(p,a) -#endif - -#ifdef __cplusplus -} /* extern "C" */ -#endif /* defined(__cplusplus) */ - -#endif /* __WINE_WINE_OBJ_CONTROL_H */ diff --git a/include/wine/obj_control.h b/include/wine/obj_control.h deleted file mode 100644 index 3f2d203605f..00000000000 --- a/include/wine/obj_control.h +++ /dev/null @@ -1,474 +0,0 @@ -/* - * Defines the COM interfaces and APIs related to structured data storage. - * - * Depends on 'obj_base.h'. - * - * Copyright (C) 1999 Paul Quinn - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __WINE_WINE_OBJ_CONTROL_H -#define __WINE_WINE_OBJ_CONTROL_H - -struct tagMSG; - -#ifdef __cplusplus -extern "C" { -#endif /* defined(__cplusplus) */ - -/***************************************************************************** - * Declare the structures - */ -typedef enum tagGUIDKIND -{ - GUIDKIND_DEFAULT_SOURCE_DISP_IID = 1 -} GUIDKIND; - -typedef enum tagREADYSTATE -{ - READYSTATE_UNINITIALIZED = 0, - READYSTATE_LOADING = 1, - READYSTATE_LOADED = 2, - READYSTATE_INTERACTIVE = 3, - READYSTATE_COMPLETE = 4 -} READYSTATE; - -typedef struct tagExtentInfo -{ - ULONG cb; - DWORD dwExtentMode; - SIZEL sizelProposed; -} DVEXTENTINFO; - -typedef struct tagVARIANT_BLOB -{ - DWORD clSize; - DWORD rpcReserved; - ULONGLONG ahData[1]; -} wireVARIANT_BLOB; - -typedef struct tagUserVARIANT -{ - wireVARIANT_BLOB pVarBlob; -} UserVARIANT; - -typedef struct tagLICINFO -{ - LONG cbLicInfo; - BOOL fRuntimeKeyAvail; - BOOL fLicVerified; -} LICINFO, *LPLICINFO; - -typedef struct tagCONTROLINFO -{ - ULONG cb; - HACCEL hAccel; - USHORT cAccel; - DWORD dwFlags; -} CONTROLINFO, *LPCONTROLINFO; - -typedef enum tagCTRLINFO -{ - CTRLINFO_EATS_RETURN = 1, - CTRLINFO_EATS_ESCAPE = 2 -} CTRLINFO; - -typedef struct tagPOINTF -{ - FLOAT x; - FLOAT y; -} POINTF, *LPPOINTF; - -typedef enum tagXFORMCOORDS -{ - XFORMCOORDS_POSITION = 0x1, - XFORMCOORDS_SIZE = 0x2, - XFORMCOORDS_HIMETRICTOCONTAINER = 0x4, - XFORMCOORDS_CONTAINERTOHIMETRIC = 0x8 -} XFORMCOORDS; - -typedef enum tagACTIVATEFLAGS -{ - ACTIVATE_WINDOWLESS = 1 -} ACTIVATE_FLAGS; - -typedef enum tagOLEDCFLAGS -{ - OLEDC_NODRAW = 0x1, - OLEDC_PAINTBKGND = 0x2, - OLEDC_OFFSCREEN = 0x4 -} OLEDCFLAGS; - -typedef enum tagDVASPECT2 -{ - DVASPECT_OPAQUE = 16, - DVASPECT_TRANSPARENT = 32 -} DVASPECT2; - -typedef enum tagHITRESULT -{ - HITRESULT_OUTSIDE = 0, - HITRESULT_TRANSPARENT = 1, - HITRESULT_CLOSE = 2, - HITRESULT_HIT = 3 -} HITRESULT; - -typedef enum tagAspectInfoFlag -{ - DVASPECTINFOFLAG_CANOPTIMIZE = 1 -} DVASPECTINFOFLAG; - -typedef struct tagAspectInfo -{ - ULONG cb; - DWORD dwFlags; -} DVASPECTINFO; - -typedef enum tagVIEWSTATUS -{ - VIEWSTATUS_OPAQUE = 1, - VIEWSTATUS_SOLIDBKGND = 2, - VIEWSTATUS_DVASPECTOPAQUE = 4, - VIEWSTATUS_DVASPECTTRANSPARENT = 8 -} VIEWSTATUS; - -/***************************************************************************** - * Predeclare the interfaces - */ -DEFINE_GUID(IID_IOleControl, 0xb196b288, 0xbab4, 0x101a, 0xb6, 0x9c, 0x00, 0xaa, 0x00, 0x34, 0x1d, 0x07); -typedef struct IOleControl IOleControl, *LPOLECONTROL; - -DEFINE_GUID(IID_IOleControlSite, 0xb196b289, 0xbab4, 0x101a, 0xb6, 0x9c, 0x00, 0xaa, 0x00, 0x34, 0x1d, 0x07); -typedef struct IOleControlSite IOleControlSite, *LPOLECONTROLSITE; - -DEFINE_GUID(IID_IOleInPlaceSiteEx, 0x9c2cad80L, 0x3424, 0x11cf, 0xb6, 0x70, 0x00, 0xaa, 0x00, 0x4c, 0xd6, 0xd8); -typedef struct IOleInPlaceSiteEx IOleInPlaceSiteEx, *LPOLEINPLACESITEEX; - -DEFINE_OLEGUID(IID_IOleInPlaceSiteWindowless, 0x00000000L, 0, 0); /* FIXME - NEED GUID */ -typedef struct IOleInPlaceSiteWindowless IOleInPlaceSiteWindowless, *LPOLEINPLACESITEWINDOWLESS; - -DEFINE_OLEGUID(IID_IOleInPlaceObjectWindowless, 0x00000000L, 0, 0); /* FIXME - NEED GUID */ -typedef struct IOleInPlaceObjectWindowless IOleInPlaceObjectWindowless, *LPOLEINPLACEOBJECTWINDOWLESS; - -DEFINE_GUID(IID_IClassFactory2, 0xb196b28f, 0xbab4, 0x101a, 0xb6, 0x9c, 0x00, 0xaa, 0x00, 0x34, 0x1d, 0x07); -typedef struct IClassFactory2 IClassFactory2, *LPCLASSFACTORY2; - -DEFINE_GUID(IID_IViewObjectEx, 0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00); /* FIXME need GUID */ -typedef struct IViewObjectEx IViewObjectEx, *LPVIEWOBJECTEX; - -DEFINE_GUID(IID_IProvideClassInfo, 0xb196b283, 0xbab4, 0x101a, 0xb6, 0x9c, 0x00, 0xaa, 0x00, 0x34, 0x1d, 0x07); -typedef struct IProvideClassInfo IProvideClassInfo, *LPPROVIDECLASSINFO; - -DEFINE_GUID(IID_IProvideClassInfo2, 0xa6bc3ac0, 0xdbaa, 0x11ce, 0x9d, 0xe3, 0x00, 0xaa, 0x00, 0x4b, 0xb8, 0x51); -typedef struct IProvideClassInfo2 IProvideClassInfo2, *LPPROVIDECLASSINFO2; - -/***************************************************************************** - * IOleControl interface - */ -#define INTERFACE IOleControl -#define IOleControl_METHODS \ - IUnknown_METHODS \ - STDMETHOD(GetControlInfo)(THIS_ CONTROLINFO *pCI) PURE; \ - STDMETHOD(OnMnemonic)(THIS_ struct tagMSG *pMsg) PURE; \ - STDMETHOD(OnAmbientPropertyChange)(THIS_ DISPID dispID) PURE; \ - STDMETHOD(FreezeEvents)(THIS_ BOOL bFreeze) PURE; -ICOM_DEFINE(IOleControl,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IOleControl_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IOleControl_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IOleControl_Release(p) (p)->lpVtbl->Release(p) -/*** IOleControl methods ***/ -#define IOleControl_GetControlInfo(p,a) (p)->lpVtbl->GetControlInfo(p,a) -#define IOleControl_OnMnemonic(p,a) (p)->lpVtbl->OnMnemonic(p,a) -#define IOleControl_OnAmbientPropertyChange(p,a) (p)->lpVtbl->OnAmbientPropertyChange(p,a) -#define IOleControl_FreezeEvents(p,a) (p)->lpVtbl->FreezeEvents(p,a) -#endif - - -/***************************************************************************** - * IOleControlSite interface - */ -#define INTERFACE IOleControlSite -#define IOleControlSite_METHODS \ - IUnknown_METHODS \ - STDMETHOD(OnControlInfoChanged)(THIS) PURE; \ - STDMETHOD(LockInPlaceActive)(THIS_ BOOL fLock) PURE; \ - STDMETHOD(GetExtendedControl)(THIS_ IDispatch **ppDisp) PURE; \ - STDMETHOD(TransformCoords)(THIS_ POINTL *pPtlHimetric, POINTF *pPtfContainer, DWORD dwFlags) PURE; \ - STDMETHOD(TranslateAccelerator)(THIS_ struct tagMSG *pMsg, DWORD grfModifiers) PURE; \ - STDMETHOD(OnFocus)(THIS_ BOOL fGotFocus) PURE; \ - STDMETHOD(ShowPropertyFrame)(THIS) PURE; -ICOM_DEFINE(IOleControlSite,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IOleControlSite_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IOleControlSite_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IOleControlSite_Release(p) (p)->lpVtbl->Release(p) -/*** IOleControlSite methods ***/ -#define IOleControlSite_OnControlInfoChanged(p) (p)->lpVtbl->OnControlInfoChanged(p) -#define IOleControlSite_LockInPlaceActive(p,a) (p)->lpVtbl->LockInPlaceActive(p,a) -#define IOleControlSite_GetExtendedControl(p,a) (p)->lpVtbl->GetExtendedControl(p,a) -#define IOleControlSite_TransformCoords(p,a,b,c) (p)->lpVtbl->TransformCoords(p,a,b,c) -#define IOleControlSite_TranslateAccelerator(p,a,b) (p)->lpVtbl->TranslateAccelerator(p,a,b) -#define IOleControlSite_OnFocus(p,a) (p)->lpVtbl->OnFocus(p,a) -#define IOleControlSite_ShowPropertyFrame(p) (p)->lpVtbl->ShowPropertyFrame(p) -#endif - - -/***************************************************************************** - * IOleInPlaceSiteEx interface - */ -#define INTERFACE IOleInPlaceSiteEx -#define IOleInPlaceSiteEx_METHODS \ - IOleInPlaceSite_METHODS \ - STDMETHOD(OnInPlaceActivateEx)(THIS_ BOOL *pfNoRedraw, DWORD dwFlags) PURE; \ - STDMETHOD(OnInPlaceDeactivateEx)(THIS_ BOOL fNoRedraw) PURE; \ - STDMETHOD(RequestUIActivate)(THIS) PURE; -ICOM_DEFINE(IOleInPlaceSiteEx,IOleInPlaceSite) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IOleInPlaceSiteEx_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IOleInPlaceSiteEx_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IOleInPlaceSiteEx_Release(p) (p)->lpVtbl->Release(p) -/*** IOleWindow methods ***/ -#define IOleInPlaceSiteEx_GetWindow(p,a) (p)->lpVtbl->GetWindow(p,a) -#define IOleInPlaceSiteEx_ContextSensitiveHelp(p,a) (p)->lpVtbl->ContextSensitiveHelp(p,a) -/*** IOleInPlaceSite methods ***/ -#define IOleInPlaceSiteEx_CanInPlaceActivate(p) (p)->lpVtbl->CanInPlaceActivate(p) -#define IOleInPlaceSiteEx_OnInPlaceActivate(p) (p)->lpVtbl->OnInPlaceActivate(p) -#define IOleInPlaceSiteEx_OnUIActivate(p) (p)->lpVtbl->OnUIActivate(p) -#define IOleInPlaceSiteEx_GetWindowContext(p,a,b,c,d,e) (p)->lpVtbl->GetWindowContext(p,a,b,c,d,e) -#define IOleInPlaceSiteEx_Scroll(p,a) (p)->lpVtbl->Scroll(p,a) -#define IOleInPlaceSiteEx_OnUIDeactivate(p,a) (p)->lpVtbl->OnUIDeactivate(p,a) -#define IOleInPlaceSiteEx_OnInPlaceDeactivate(p) (p)->lpVtbl->OnInPlaceDeactivate(p) -#define IOleInPlaceSiteEx_DiscardUndoState(p) (p)->lpVtbl->DiscardUndoState(p) -#define IOleInPlaceSiteEx_DeactivateAndUndo(p) (p)->lpVtbl->DeactivateAndUndo(p) -#define IOleInPlaceSiteEx_OnPosRectChange(p,a) (p)->lpVtbl->OnPosRectChange(p,a) -/*** IOleInPlaceSiteEx methods ***/ -#define IOleInPlaceSiteEx_OnInPlaceActivateEx(p,a,b) (p)->lpVtbl->OnInPlaceActivateEx(p,a,b) -#define IOleInPlaceSiteEx_OnInPlaceDeactivateEx(p,a) (p)->lpVtbl->OnInPlaceDeactivateEx(p,a) -#define IOleInPlaceSiteEx_RequestUIActivate(p) (p)->lpVtbl->RequestUIActivate(p) -#endif - - -/***************************************************************************** - * IOleInPlaceSiteWindowless interface - */ -#define INTERFACE IOleInPlaceSiteWindowless -#define IOleInPlaceSiteWindowless_METHODS \ - IOleInPlaceSite_METHODS \ - STDMETHOD(CanWindowlessActivate)(THIS) PURE; \ - STDMETHOD(GetCapture)(THIS) PURE; \ - STDMETHOD(SetCapture)(THIS_ BOOL fCapture) PURE; \ - STDMETHOD(GetFocus)(THIS) PURE; \ - STDMETHOD(SetFocus)(THIS_ BOOL fFocus) PURE; \ - STDMETHOD(GetDC)(THIS_ LPCRECT pRect, DWORD grfFlags, HDC *phDC) PURE; \ - STDMETHOD(ReleaseDC)(THIS_ HDC hDC) PURE; \ - STDMETHOD(InvalidateRect)(THIS_ LPCRECT pRect, BOOL fErase) PURE; \ - STDMETHOD(InvalidateRgn)(THIS_ HRGN hRgn, BOOL fErase) PURE; \ - STDMETHOD(ScrollRect)(THIS_ INT dx, INT dy, LPCRECT pRectScroll, LPCRECT pRectClip) PURE; \ - STDMETHOD(AdjustRect)(THIS_ LPRECT prc) PURE; \ - STDMETHOD(OnDefWindowMessage)(THIS_ UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *plResult) PURE; -ICOM_DEFINE(IOleInPlaceSiteWindowless,IOleInPlaceSite) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IOleInPlaceSiteWindowless_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IOleInPlaceSiteWindowless_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IOleInPlaceSiteWindowless_Release(p) (p)->lpVtbl->Release(p) -/*** IOleWindow methods ***/ -#define IOleInPlaceSiteWindowless_GetWindow(p,a) (p)->lpVtbl->GetWindow(p,a) -#define IOleInPlaceSiteWindowless_ContextSensitiveHelp(p,a) (p)->lpVtbl->ContextSensitiveHelp(p,a) -/*** IOleInPlaceSitemethods ***/ -#define IOleInPlaceSiteWindowless_CanInPlaceActivate(p) (p)->lpVtbl->CanInPlaceActivate(p) -#define IOleInPlaceSiteWindowless_OnInPlaceActivate(p) (p)->lpVtbl->OnInPlaceActivate(p) -#define IOleInPlaceSiteWindowless_OnUIActivate(p) (p)->lpVtbl->OnUIActivate(p) -#define IOleInPlaceSiteWindowless_GetWindowContext(p,a,b,c,d,e) (p)->lpVtbl->GetWindowContext(p,a,b,c,d,e) -#define IOleInPlaceSiteWindowless_Scroll(p,a) (p)->lpVtbl->Scroll(p,a) -#define IOleInPlaceSiteWindowless_OnUIDeactivate(p,a) (p)->lpVtbl->OnUIDeactivate(p,a) -#define IOleInPlaceSiteWindowless_OnInPlaceDeactivate(p) (p)->lpVtbl->OnInPlaceDeactivate(p) -#define IOleInPlaceSiteWindowless_DiscardUndoState(p) (p)->lpVtbl->DiscardUndoState(p) -#define IOleInPlaceSiteWindowless_DeactivateAndUndo(p) (p)->lpVtbl->DeactivateAndUndo(p) -#define IOleInPlaceSiteWindowless_OnPosRectChange(p,a) (p)->lpVtbl->OnPosRectChange(p,a) -/*** IOleInPlaceSitemethods ***/ -#define IOleInPlaceSiteWindowless_CanWindowlessActivate(p) (p)->lpVtbl->CanInPlaceActivate(p) -#define IOleInPlaceSiteWindowless_GetCapture(p) (p)->lpVtbl->OnInPlaceActivate(p) -#define IOleInPlaceSiteWindowless_SetCapture(p,a) (p)->lpVtbl->OnUIActivate(p,a) -#define IOleInPlaceSiteWindowless_GetFocus(p) (p)->lpVtbl->GetWindowContext(p) -#define IOleInPlaceSiteWindowless_SetFocus(p,a) (p)->lpVtbl->Scroll(p,a) -#define IOleInPlaceSiteWindowless_GetDC(p,a,b,c) (p)->lpVtbl->OnUIDeactivate(p,a,b,c) -#define IOleInPlaceSiteWindowless_ReleaseDC(p,a) (p)->lpVtbl->OnInPlaceDeactivate(p,a) -#define IOleInPlaceSiteWindowless_InvalidateRect(p,a,b) (p)->lpVtbl->DiscardUndoState(p,a,b) -#define IOleInPlaceSiteWindowless_InvalidateRgn(p,a,b) (p)->lpVtbl->DeactivateAndUndo(p,a,b) -#define IOleInPlaceSiteWindowless_ScrollRect(p,a,b,c,d) (p)->lpVtbl->OnPosRectChange(p,a,b,c,d) -#define IOleInPlaceSiteWindowless_AdjustRect(p,a) (p)->lpVtbl->OnPosRectChange(p,a) -#define IOleInPlaceSiteWindowless_OnDefWindowMessage(p,a,b,c,d) (p)->lpVtbl->OnPosRectChange(p,a,b,c,d) -#endif - - -/***************************************************************************** - * IOleInPlaceObjectWindowless interface - */ -#define INTERFACE IOleInPlaceObjectWindowless -#define IOleInPlaceObjectWindowless_METHODS \ - IOleInPlaceObject_METHODS \ - STDMETHOD(OnWindowMessage)(THIS_ UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *plResult) PURE; \ - STDMETHOD(GetDropTarget)(THIS_ IDropTarget **ppDropTarget) PURE; -ICOM_DEFINE(IOleInPlaceObjectWindowless,IOleInPlaceObject) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IOleInPlaceObjectWindowless_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IOleInPlaceObjectWindowless_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IOleInPlaceObjectWindowless_Release(p) (p)->lpVtbl->Release(p) -/*** IOleWindow methods ***/ -#define IOleInPlaceObjectWindowless_GetWindow(p,a) (p)->lpVtbl->GetWindow(p,a) -#define IOleInPlaceObjectWindowless_ContextSensitiveHelp(p,a) (p)->lpVtbl->ContextSensitiveHelp(p,a) -/*** IOleInPlaceObject methods ***/ -#define IOleInPlaceObjectWindowless_InPlaceDeactivate(p) (p)->lpVtbl->InPlaceDeactivate(p) -#define IOleInPlaceObjectWindowless_UIDeactivate(p) (p)->lpVtbl->UIDeactivate(p) -#define IOleInPlaceObjectWindowless_SetObjectRects(p,a,b) (p)->lpVtbl->SetObjectRects(p,a,b) -#define IOleInPlaceObjectWindowless_ReactivateAndUndo(p) (p)->lpVtbl->ReactivateAndUndo(p) -/*** IOleInPlaceObjectWindowless methods ***/ -#define IOleInPlaceObjectWindowless_OnWindowMessage(p,a,b,c,d) (p)->lpVtbl->OnWindowMessage(p,a,b,c,d) -#define IOleInPlaceObjectWindowless_GetDropTarget(p,a) (p)->lpVtbl->GetDropTarget(p,a) -#endif - - -/***************************************************************************** - * IClassFactory2 interface - */ -#define INTERFACE IClassFactory2 -#define IClassFactory2_METHODS \ - IClassFactory_METHODS \ - STDMETHOD(GetLicInfo)(THIS_ LICINFO *pLicInfo) PURE; \ - STDMETHOD(RequestLicKey)(THIS_ DWORD dwReserved, BSTR *pBstrKey) PURE; \ - STDMETHOD(CreateInstanceLic)(THIS_ IUnknown *pUnkOuter, IUnknown *pUnkReserved, REFIID riid, BSTR bstrKey, PVOID *ppvObj) PURE; -ICOM_DEFINE(IClassFactory2,IClassFactory) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IClassFactory2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IClassFactory2_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IClassFactory2_Release(p) (p)->lpVtbl->Release(p) -/*** IClassFactory methods ***/ -#define IClassFactory2_CreateInstance(p,a,b,c) (p)->lpVtbl->CreateInstance(p,a,b,c) -#define IClassFactory2_LockServer(p,a) (p)->lpVtbl->LockServer(p,a) -/*** IClassFactory2 methods ***/ -#define IClassFactory2_GetLicInfo(p,a) (p)->lpVtbl->GetLicInfo(p,a) -#define IClassFactory2_RequestLicKey(p,a,b) (p)->lpVtbl->RequestLicKey(p,a,b) -#define IClassFactory2_CreateInstanceLic(p,a,b,c,d,e) (p)->lpVtbl->CreateInstanceLic(p,a,b,c,d,e) -#endif - - -/***************************************************************************** - * IViewObject interface - */ -#define INTERFACE IViewObjectEx -#define IViewObjectEx_METHODS \ - IViewObject2_METHODS \ - STDMETHOD(GetRect)(THIS_ DWORD dwAspect, LPRECTL pRect) PURE; \ - STDMETHOD(GetViewStatus)(THIS_ DWORD *pdwStatus) PURE; \ - STDMETHOD(QueryHitPoint)(THIS_ DWORD dwAspect, LPCRECT pRectBounds, POINT ptlLoc, LONG lCloseHint, DWORD *pHitResult) PURE; \ - STDMETHOD(QueryHitRect)(THIS_ DWORD dwAspect, LPCRECT pRectBounds, LPCRECT pRectLoc, LONG lCloseHint, DWORD *pHitResult) PURE; \ - STDMETHOD(GetNaturalExtent)(THIS_ DWORD dwAspect, LONG lindex, DVTARGETDEVICE *ptd, HDC hicTargetDev, DVEXTENTINFO *pExtentInfo, LPSIZEL pSizel) PURE; -ICOM_DEFINE(IViewObjectEx,IViewObject2) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IViewObjectEx_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IViewObjectEx_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IViewObjectEx_Release(p) (p)->lpVtbl->Release(p) -/*** IViewObject methods ***/ -#define IViewObjectEx_Draw(p,a,b,c,d,e,f,g,h,i,j) (p)->lpVtbl->Draw(p,a,b,c,d,e,f,g,h,i,j) -#define IViewObjectEx_GetColorSet(p,a,b,c,d,e,f) (p)->lpVtbl->GetColorSet(p,a,b,c,d,e,f) -#define IViewObjectEx_Freeze(p,a,b,c,d) (p)->lpVtbl->Freeze(p,a,b,c,d) -#define IViewObjectEx_Unfreeze(p,a) (p)->lpVtbl->Unfreeze(p,a) -#define IViewObjectEx_SetAdvise(p,a,b,c) (p)->lpVtbl->SetAdvise(p,a,b,c) -#define IViewObjectEx_GetAdvise(p,a,b,c) (p)->lpVtbl->GetAdvise(p,a,b,c) -/*** IViewObject2 methods ***/ -#define IViewObjectEx_GetExtent(p,a,b,c,d) (p)->lpVtbl->GetExtent(p,a,b,c,d) -/*** IViewObjectEx methods ***/ -#define IViewObjectEx_GetRect(p,a,b) (p)->lpVtbl->GetRect(p,a,b) -#define IViewObjectEx_GetViewStatus(p,a) (p)->lpVtbl->GetViewStatus(p,a) -#define IViewObjectEx_QueryHitPoint(p,a,b,c,d,e) (p)->lpVtbl->QueryHitPoint(p,a,b,c,d,e) -#define IViewObjectEx_QueryHitRect(p,a,b,c,d,e) (p)->lpVtbl->QueryHitRect(p,a,b,c,d,e) -#define IViewObjectEx_GetNaturalExtent(p,a,b,c,d,e,f) (p)->lpVtbl->GetNaturalExtent(p,a,b,c,d,e,f) -#endif - - -/***************************************************************************** - * IProvideClassInfo interface - */ -#ifdef __WINESRC__ -#undef GetClassInfo -#endif - -#define INTERFACE IProvideClassInfo -#define IProvideClassInfo_METHODS \ - IUnknown_METHODS \ - STDMETHOD(GetClassInfo)(THIS_ ITypeInfo **ppTI) PURE; -ICOM_DEFINE(IProvideClassInfo,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IProvideClassInfo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IProvideClassInfo_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IProvideClassInfo_Release(p) (p)->lpVtbl->Release(p) -/*** IProvideClassInfo methods ***/ -#define IProvideClassInfo_GetClassInfo(p,a) (p)->lpVtbl->GetClassInfo(p,a) -#endif - - - -/***************************************************************************** - * IProvideClassInfo2 interface - */ -#define INTERFACE IProvideClassInfo2 -#define IProvideClassInfo2_METHODS \ - IProvideClassInfo_METHODS \ - STDMETHOD(GetGUID)(THIS_ DWORD dwGuidKind, GUID *pGUID) PURE; -ICOM_DEFINE(IProvideClassInfo2,IProvideClassInfo) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IProvideClassInfo2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IProvideClassInfo2_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IProvideClassInfo2_Release(p) (p)->lpVtbl->Release(p) -/*** IProvideClassInfo methods ***/ -#define IProvideClassInfo2_GetClassInfo(p,a) (p)->lpVtbl->GetClassInfo(p,a) -/*** IProvideClassInfo2 methods ***/ -#define IProvideClassInfo2_GetGUID(p,a,b) (p)->lpVtbl->GetGUID(p,a,b) -#endif - -#ifdef __cplusplus -} /* extern "C" */ -#endif /* defined(__cplusplus) */ - -#endif /* __WINE_WINE_OBJ_CONTROL_H */ diff --git a/include/wine/obj_olefont.h b/include/wine/obj_olefont.h deleted file mode 100644 index e4d55c5c596..00000000000 --- a/include/wine/obj_olefont.h +++ /dev/null @@ -1,133 +0,0 @@ -/* - * Defines the COM interfaces and APIs related to OLE font support. - * - * Depends on 'obj_base.h'. - * - * Copyright (C) 1999 Francis Beaudet - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __WINE_WINE_OBJ_OLEFONT_H -#define __WINE_WINE_OBJ_OLEFONT_H - -#ifdef __cplusplus -extern "C" { -#endif /* defined(__cplusplus) */ - -/***************************************************************************** - * Predeclare the interfaces - */ -DEFINE_GUID(IID_IFont, 0xBEF6E002, 0xA874, 0x101A, 0x8B, 0xBA, 0x00, 0xAA, 0x00, 0x30, 0x0C, 0xAB); -typedef struct IFont IFont,*LPFONT; - -DEFINE_GUID(IID_IFontDisp, 0xBEF6E003, 0xA874, 0x101A, 0x8B, 0xBA, 0x00, 0xAA, 0x00, 0x30, 0x0C, 0xAB); -typedef struct IFontDisp IFontDisp,*LPFONTDISP; - -typedef TEXTMETRICW TEXTMETRICOLE; - -/***************************************************************************** - * IFont interface - */ -#define INTERFACE IFont -#define IFont_METHODS \ - IUnknown_METHODS \ - STDMETHOD(get_Name)(THIS_ BSTR * pname) PURE; \ - STDMETHOD(put_Name)(THIS_ BSTR name) PURE; \ - STDMETHOD(get_Size)(THIS_ CY * psize) PURE; \ - STDMETHOD(put_Size)(THIS_ CY size) PURE; \ - STDMETHOD(get_Bold)(THIS_ BOOL * pbold) PURE; \ - STDMETHOD(put_Bold)(THIS_ BOOL bold) PURE; \ - STDMETHOD(get_Italic)(THIS_ BOOL * pitalic) PURE; \ - STDMETHOD(put_Italic)(THIS_ BOOL italic) PURE; \ - STDMETHOD(get_Underline)(THIS_ BOOL * punderline) PURE; \ - STDMETHOD(put_Underline)(THIS_ BOOL underline) PURE; \ - STDMETHOD(get_Strikethrough)(THIS_ BOOL * pstrikethrough) PURE; \ - STDMETHOD(put_Strikethrough)(THIS_ BOOL strikethrough) PURE; \ - STDMETHOD(get_Weight)(THIS_ short * pweight) PURE; \ - STDMETHOD(put_Weight)(THIS_ short weight) PURE; \ - STDMETHOD(get_Charset)(THIS_ short * pcharset) PURE; \ - STDMETHOD(put_Charset)(THIS_ short charset) PURE; \ - STDMETHOD(get_hFont)(THIS_ HFONT * phfont) PURE; \ - STDMETHOD(Clone)(THIS_ IFont ** ppfont) PURE; \ - STDMETHOD(IsEqual)(THIS_ IFont * pFontOther) PURE; \ - STDMETHOD(SetRatio)(THIS_ long cyLogical, long cyHimetric) PURE; \ - STDMETHOD(QueryTextMetrics)(THIS_ TEXTMETRICOLE * ptm) PURE; \ - STDMETHOD(AddRefHfont)(THIS_ HFONT hfont) PURE; \ - STDMETHOD(ReleaseHfont)(THIS_ HFONT hfont) PURE; \ - STDMETHOD(SetHdc)(THIS_ HDC hdc) PURE; -ICOM_DEFINE(IFont,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IFont_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IFont_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IFont_Release(p) (p)->lpVtbl->Release(p) -/*** IFont methods ***/ -#define IFont_getName(p,a) (p)->lpVtbl->get_Name(p,a) -#define IFont_putName(p,a) (p)->lpVtbl->put_Name(p,a) -#define IFont_get_Size(p,a) (p)->lpVtbl->get_Size(p,a) -#define IFont_put_Size(p,a) (p)->lpVtbl->put_Size(p,a) -#define IFont_get_Bold(p,a) (p)->lpVtbl->get_Bold(p,a) -#define IFont_put_Bold(p,a) (p)->lpVtbl->put_Bold(p,a) -#define IFont_get_Italic(p,a) (p)->lpVtbl->get_Italic(p,a) -#define IFont_put_Italic(p,a) (p)->lpVtbl->put_Italic(p,a) -#define IFont_get_Underline(p,a) (p)->lpVtbl->get_Underline(p,a) -#define IFont_put_Underline(p,a) (p)->lpVtbl->put_Underline(p,a) -#define IFont_get_Strikethrough(p,a) (p)->lpVtbl->get_Strikethrough(p,a) -#define IFont_put_Strikethrough(p,a) (p)->lpVtbl->put_Strikethrough(p,a) -#define IFont_get_Weight(p,a) (p)->lpVtbl->get_Weight(p,a) -#define IFont_put_Weight(p,a) (p)->lpVtbl->put_Weight(p,a) -#define IFont_get_Charset(p,a) (p)->lpVtbl->get_Charset(p,a) -#define IFont_put_Charset(p,a) (p)->lpVtbl->put_Charset(p,a) -#define IFont_get_hFont(p,a) (p)->lpVtbl->get_hFont(p,a) -#define IFont_put_hFont(p,a) (p)->lpVtbl->put_hFont(p,a) -#define IFont_Clone(p,a) (p)->lpVtbl->Clone(p,a) -#define IFont_IsEqual(p,a) (p)->lpVtbl->IsEqual(p,a) -#define IFont_SetRatio(p,a,b) (p)->lpVtbl->SetRatio(p,a,b) -#define IFont_QueryTextMetrics(p,a) (p)->lpVtbl->QueryTextMetrics(p,a) -#define IFont_AddRefHfont(p,a) (p)->lpVtbl->AddRefHfont(p,a) -#define IFont_ReleaseHfont(p,a) (p)->lpVtbl->ReleaseHfont(p,a) -#define IFont_SetHdc(p,a) (p)->lpVtbl->SetHdc(p,a) -#endif - -/***************************************************************************** - * IFont interface - */ -#define INTERFACE IFontDisp -#define IFontDisp_METHODS \ - IDispatch_METHODS -ICOM_DEFINE(IFontDisp,IDispatch) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IFontDisp_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IFontDisp_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IFontDisp_Release(p) (p)->lpVtbl->Release(p) -/*** IDispatch methods ***/ -#define IFontDisp_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a) -#define IFontDisp_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c) -#define IFontDisp_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e) -#define IFontDisp_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h) -/*** IFontDisp methods ***/ -#endif - -#ifdef __cplusplus -} /* extern "C" */ -#endif /* defined(__cplusplus) */ - -#endif /* __WINE_WINE_OBJ_OLEFONT_H */ diff --git a/include/wine/obj_oleundo.h b/include/wine/obj_oleundo.h deleted file mode 100644 index de47426038b..00000000000 --- a/include/wine/obj_oleundo.h +++ /dev/null @@ -1,304 +0,0 @@ -/* - * Defines the COM interfaces and APIs from ocidl.h which pertain to Undo/Redo - * - * Depends on 'obj_base.h'. - * - * Copyright (C) 1999 Paul Quinn - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __WINE_WINE_OBJ_OLEUNDO_H -#define __WINE_WINE_OBJ_OLEUNDO_H - -#ifdef __cplusplus -extern "C" { -#endif /* defined(__cplusplus) */ - -/***************************************************************************** - * Predeclare the interfaces - */ -DEFINE_GUID(IID_IQuickActivate, 0xcf51ed10, 0x62fe, 0x11cf, 0xbf, 0x86, 0x00, 0xa0, 0xc9, 0x03, 0x48, 0x36); -typedef struct IQuickActivate IQuickActivate,*LPQUICKACTIVATE; - -DEFINE_GUID(IID_IPointerInactive, 0x55980ba0, 0x35aa, 0x11cf, 0xb6, 0x71, 0x00, 0xaa, 0x00, 0x4c, 0xd6, 0xd8); -typedef struct IPointerInactive IPointerInactive,*LPPOINTERINACTIVE; - -DEFINE_GUID(IID_IAdviseSinkEx, 0x3af24290, 0x0c96, 0x11ce, 0xa0, 0xcf, 0x00, 0xaa, 0x00, 0x60, 0x0a, 0xb8); -typedef struct IAdviseSinkEx IAdviseSinkEx,*LPADVISESINKEX; - -DEFINE_GUID(IID_IOleUndoManager, 0xd001f200, 0xef97, 0x11ce, 0x9b, 0xc9, 0x00, 0xaa, 0x00, 0x60, 0x8e, 0x01); -typedef struct IOleUndoManager IOleUndoManager,*LPOLEUNDOMANAGER; - -DEFINE_GUID(IID_IOleUndoUnit, 0x894ad3b0, 0xef97, 0x11ce, 0x9b, 0xc9, 0x00, 0xaa, 0x00, 0x60, 0x8e, 0x01); -typedef struct IOleUndoUnit IOleUndoUnit,*LPOLEUNDOUNIT; - -DEFINE_GUID(IID_IOleParentUndoUnit, 0xa1faf330, 0xef97, 0x11ce, 0x9b, 0xc9, 0x00, 0xaa, 0x00, 0x60, 0x8e, 0x01); -typedef struct IOleParentUndoUnit IOleParentUndoUnit,*LPOLEPARENTUNDOUNIT; - -DEFINE_GUID(IID_IEnumOleUndoUnits, 0xb3e7c340, 0xef97, 0x11ce, 0x9b, 0xc9, 0x00, 0xaa, 0x00, 0x60, 0x8e, 0x01); -typedef struct IEnumOleUndoUnits IEnumOleUndoUnits,*LPENUMOLEUNDOUNITS; - -/***************************************************************************** - * Declare the structures - */ -typedef enum tagQACONTAINERFLAGS -{ - QACONTAINER_SHOWHATCHING = 0x1, - QACONTAINER_SHOWGRABHANDLES = 0x2, - QACONTAINER_USERMODE = 0x4, - QACONTAINER_DISPLAYASDEFAULT = 0x8, - QACONTAINER_UIDEAD = 0x10, - QACONTAINER_AUTOCLIP = 0x20, - QACONTAINER_MESSAGEREFLECT = 0x40, - QACONTAINER_SUPPORTSMNEMONICS = 0x80 -} QACONTAINERFLAGS; - -typedef DWORD OLE_COLOR; - -typedef struct tagQACONTROL -{ - ULONG cbSize; - DWORD dwMiscStatus; - DWORD dwViewStatus; - DWORD dwEventCookie; - DWORD dwPropNotifyCookie; - DWORD dwPointerActivationPolicy; -} QACONTROL; - -typedef struct tagQACONTAINER -{ - ULONG cbSize; - IOleClientSite *pClientSite; - IAdviseSinkEx *pAdviseSink; - IPropertyNotifySink *pPropertyNotifySink; - IUnknown *pUnkEventSink; - DWORD dwAmbientFlags; - OLE_COLOR colorFore; - OLE_COLOR colorBack; - IFont *pFont; - IOleUndoManager *pUndoMgr; - DWORD dwAppearance; - LONG lcid; - HPALETTE hpal; - struct IBindHost *pBindHost; -} QACONTAINER; - -/***************************************************************************** - * IQuickActivate interface - */ -#define INTERFACE IQuickActivate -#define IQuickActivate_METHODS \ - IUnknown_METHODS \ - STDMETHOD(QuickActivate)(THIS_ QACONTAINER *pQaContainer, QACONTROL *pQaControl) PURE; \ - STDMETHOD(SetContentExtent)(THIS_ LPSIZEL pSizel) PURE; \ - STDMETHOD(GetContentExtent)(THIS_ LPSIZEL pSizel) PURE; -ICOM_DEFINE(IQuickActivate,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IQuickActivate_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IQuickActivate_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IQuickActivate_Release(p) (p)->lpVtbl->Release(p) -/*** IQuickActivate methods ***/ -#define IQuickActivate_QuickActivate(p,a,b) (p)->lpVtbl->QuickActivate(p,a,b) -#define IQuickActivate_SetContentExtent(p,a) (p)->lpVtbl->SetContentExtent(p,a) -#define IQuickActivate_GetContentExtent(p,a) (p)->lpVtbl->GetContentExtent(p,a) -#endif - - -/***************************************************************************** - * IPointerInactive interface - */ -#define INTERFACE IPointerInactive -#define IPointerInactive_METHODS \ - IUnknown_METHODS \ - STDMETHOD(GetActivationPolicy)(THIS_ DWORD *pdwPolicy) PURE; \ - STDMETHOD(OnInactiveMouseMove)(THIS_ LPCRECT pRectBounds, LONG x, LONG y, DWORD grfKeyState) PURE; \ - STDMETHOD(OnInactiveSetCursor)(THIS_ LPCRECT pRectBounds, LONG x, LONG y, DWORD dwMouseMsg, BOOL fSetAlways) PURE; -ICOM_DEFINE(IPointerInactive,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IPointerInactive_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IPointerInactive_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IPointerInactive_Release(p) (p)->lpVtbl->Release(p) -/*** IPointerInactive methods ***/ -#define IPointerInactive_GetActivationPolicy(p,a) (p)->lpVtbl->GetActivationPolicy(p,a) -#define IPointerInactive_OnInactiveMoveMouse(p,a,b,c,d) (p)->lpVtbl->OnInactiveMoveMouse(p,a,b,c,d) -#define IPointerInactive_OnInactiveSetCursor(p,a,b,c,d,e) (p)->lpVtbl->OnInactiveSetCursor(p,a,b,d,e) -#endif - - -/***************************************************************************** - * IAdviseSinkEx interface - */ -#define INTERFACE IAdviseSinkEx -#define IAdviseSinkEx_METHODS \ - IAdviseSink_METHODS \ - STDMETHOD(OnViewStatusChange)(THIS_ DWORD dwViewStatus) PURE; -ICOM_DEFINE(IAdviseSinkEx,IAdviseSink) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IAdviseSinkEx_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IAdviseSinkEx_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IAdviseSinkEx_Release(p) (p)->lpVtbl->Release(p) -/*** IAdviseSink methods ***/ -#define IAdviseSinkEx_OnDataChange(p,a,b) (p)->lpVtbl->OnDataChange(p,a,b) -#define IAdviseSinkEx_OnViewChange(p,a,b) (p)->lpVtbl->OnViewChange(p,a,b) -#define IAdviseSinkEx_OnRename(p,a) (p)->lpVtbl->OnRename(p,a) -#define IAdviseSinkEx_OnSave(p) (p)->lpVtbl->OnSave(p) -#define IAdviseSinkEx_OnClose(p) (p)->lpVtbl->OnClose(p) -/*** IAdviseSinkEx methods ***/ -#define IAdviseSinkEx_OnViewStatusChange(p,a) (p)->lpVtbl->OnViewStatusChange(p,a) -#endif - - -/***************************************************************************** - * IOleUndoManager interface - */ -#define INTERFACE IOleUndoManager -#define IOleUndoManager_METHODS \ - IUnknown_METHODS \ - STDMETHOD(Open)(THIS_ IOleParentUndoUnit *pPUU) PURE; \ - STDMETHOD(Close)(THIS_ IOleParentUndoUnit *pPUU, BOOL fCommit) PURE; \ - STDMETHOD(Add)(THIS_ IOleUndoUnit *pUU) PURE; \ - STDMETHOD(GetOpenParentState)(THIS_ DWORD *pdwState) PURE; \ - STDMETHOD(DiscardFrom)(THIS_ IOleUndoUnit *pUU) PURE; \ - STDMETHOD(UndoTo)(THIS_ IOleUndoUnit *pUU) PURE; \ - STDMETHOD(RedoTo)(THIS_ IOleUndoUnit *pUU) PURE; \ - STDMETHOD(EnumUndoable)(THIS_ IEnumOleUndoUnits **ppEnum) PURE; \ - STDMETHOD(EnumRedoable)(THIS_ IEnumOleUndoUnits **ppEnum) PURE; \ - STDMETHOD(GetLastUndoDescription)(THIS_ BSTR *pBstr) PURE; \ - STDMETHOD(GetLastRedoDescription)(THIS_ BSTR *pBstr) PURE; \ - STDMETHOD(Enable)(THIS_ BOOL fEnable) PURE; -ICOM_DEFINE(IOleUndoManager,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IOleUndoManager_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IOleUndoManager_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IOleUndoManager_Release(p) (p)->lpVtbl->Release(p) -/*** IOleUndoManager methods ***/ -#define IOleUndoManager_Open(p,a) (p)->lpVtbl->Open(p,a) -#define IOleUndoManager_Close(p,a,b) (p)->lpVtbl->Close(p,a,b) -#define IOleUndoManager_Add(p,a) (p)->lpVtbl->Add(p,a) -#define IOleUndoManager_GetOpenParentState(p,a) (p)->lpVtbl->GetOpenParentState(p,a) -#define IOleUndoManager_DiscardFrom(p,a) (p)->lpVtbl->DiscardFrom(p,a) -#define IOleUndoManager_UndoTo(p,a) (p)->lpVtbl->UndoTo(p,a) -#define IOleUndoManager_RedoTo(p,a) (p)->lpVtbl->RedoTo(p,a) -#define IOleUndoManager_EnumUndoable(p,a) (p)->lpVtbl->EnumUndoable(p,a) -#define IOleUndoManager_EnumRedoable(p,a) (p)->lpVtbl->EnumRedoable(p,a) -#define IOleUndoManager_GetLastUndoDescription(p,a) (p)->lpVtbl->GetLastUndoDescription(p,a) -#define IOleUndoManager_GetLastRedoDescription(p,a) (p)->lpVtbl->GetLastRedoDescription(p,a) -#define IOleUndoManager_Enable(p,a) (p)->lpVtbl->Enable(p,a) -#endif - - -/***************************************************************************** - * IOleUndoUnit interface - */ -#define INTERFACE IOleUndoUnit -#define IOleUndoUnit_METHODS \ - IUnknown_METHODS \ - STDMETHOD(Do)(THIS_ IOleUndoManager *pUndoManager) PURE; \ - STDMETHOD(GetDescription)(THIS_ BSTR *pBstr) PURE; \ - STDMETHOD(GetUnitType)(THIS_ CLSID *pClsid, LONG *plID) PURE; \ - STDMETHOD(OnNextAdd)(THIS) PURE; -ICOM_DEFINE(IOleUndoUnit,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IOleUndoUnit_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IOleUndoUnit_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IOleUndoUnit_Release(p) (p)->lpVtbl->Release(p) -/*** IOleUndoUnit methods ***/ -#define IOleUndoUnit_Do(p,a) (p)->lpVtbl->Do(p,a) -#define IOleUndoUnit_GetDescription(p,a) (p)->lpVtbl->GetDescription(p,a) -#define IOleUndoUnit_GetUnitType(p,a,b) (p)->lpVtbl->GetUnitType(p,a,b) -#define IOleUndoUnit_OnNextAdd(p) (p)->lpVtbl->OnNextAdd(p) -#endif - - - -/***************************************************************************** - * IOleUndoUnit interface - */ -#define INTERFACE IOleParentUndoUnit -#define IOleParentUndoUnit_METHODS \ - IOleUndoUnit_METHODS \ - STDMETHOD(Open)(THIS_ IOleParentUndoUnit *pPUU) PURE; \ - STDMETHOD(Close)(THIS_ IOleParentUndoUnit *pPUU, BOOL fCommit) PURE; \ - STDMETHOD(Add)(THIS_ IOleUndoUnit *pUU) PURE; \ - STDMETHOD(FindUnit)(THIS_ IOleUndoUnit *pUU) PURE; \ - STDMETHOD(GetParentState)(THIS_ DWORD *pdwState) PURE; -ICOM_DEFINE(IOleParentUndoUnit,IOleUndoUnit) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IOleParentUndoUnit_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IOleParentUndoUnit_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IOleParentUndoUnit_Release(p) (p)->lpVtbl->Release(p) -/*** IOleUndoUnit methods ***/ -#define IOleParentUndoUnit_Do(p,a) (p)->lpVtbl->Do(p,a) -#define IOleParentUndoUnit_GetDescription(p,a) (p)->lpVtbl->GetDescription(p,a) -#define IOleParentUndoUnit_GetUnitType(p,a,b) (p)->lpVtbl->GetUnitType(p,a,b) -#define IOleParentUndoUnit_OnNextAdd(p) (p)->lpVtbl->OnNextAdd(p) -/*** IOleParentUndoUnit methods ***/ -#define IOleParentUndoUnit_Open(p,a) (p)->lpVtbl->Open(p,a) -#define IOleParentUndoUnit_Close(p,a,b) (p)->lpVtbl->Close(p,a,b) -#define IOleParentUndoUnit_Add(p,a) (p)->lpVtbl->Add(p,a) -#define IOleParentUndoUnit_FindUnit(p,a) (p)->lpVtbl->FindUnit(p,a) -#define IOleParentUndoUnit_GetParentState(p,a,b) (p)->lpVtbl->GetParentState(p,a) -#endif - - -/***************************************************************************** - * IEnumOleUndoUnits interface - */ -#define INTERFACE IEnumOleUndoUnits -#define IEnumOleUndoUnits_METHODS \ - IUnknown_METHODS \ - STDMETHOD(Next)(THIS_ ULONG cElt, IOleUndoUnit **rgElt, ULONG *pcEltFetched) PURE; \ - STDMETHOD(Skip)(THIS_ ULONG cElt) PURE; \ - STDMETHOD(Reset)(THIS) PURE; \ - STDMETHOD(Clone)(THIS_ IEnumOleUndoUnits **ppEnum) PURE; -ICOM_DEFINE(IEnumOleUndoUnits,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IEnumOleUndoUnits_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IEnumOleUndoUnits_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IEnumOleUndoUnits_Release(p) (p)->lpVtbl->Release(p) -/*** IEnumOleUndoUnits methods ***/ -#define IEnumOleUndoUnits_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) -#define IEnumOleUndoUnits_Skip(p,a) (p)->lpVtbl->Skip(p,a) -#define IEnumOleUndoUnits_Reset(p,a) (p)->lpVtbl->Reset(p,a) -#define IEnumOleUndoUnits_Clone(p,a) (p)->lpVtbl->Clone(p,a) -#endif - -#ifdef __cplusplus -} /* extern "C" */ -#endif /* defined(__cplusplus) */ - -#endif /* __WINE_WINE_OBJ_OLEUNDO_H */ diff --git a/include/wine/obj_picture.h b/include/wine/obj_picture.h deleted file mode 100644 index 8f8e505018e..00000000000 --- a/include/wine/obj_picture.h +++ /dev/null @@ -1,125 +0,0 @@ -/* - * Defines the COM interfaces and APIs related to OLE picture support. - * - * Depends on 'obj_base.h'. - * - * Copyright (C) 1999 Paul Quinn - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __WINE_WINE_OBJ_PICTURE_H -#define __WINE_WINE_OBJ_PICTURE_H - -#ifdef __cplusplus -extern "C" { -#endif /* defined(__cplusplus) */ - -/***************************************************************************** - * Predeclare the structures - */ -typedef UINT OLE_HANDLE; -typedef LONG OLE_XPOS_HIMETRIC; -typedef LONG OLE_YPOS_HIMETRIC; -typedef LONG OLE_XSIZE_HIMETRIC; -typedef LONG OLE_YSIZE_HIMETRIC; - -typedef enum tagPicture { /* bitmasks */ - PICTURE_SCALABLE = 0x1, - PICTURE_TRANSPARENT = 0x2 -} PICTUREATTRIBUTES; - -/***************************************************************************** - * Predeclare the interfaces - */ -DEFINE_GUID(IID_IPicture, 0x7bf80980, 0xbf32, 0x101a, 0x8b, 0xbb, 0x00, 0xAA, 0x00, 0x30, 0x0C, 0xAB); -typedef struct IPicture IPicture, *LPPICTURE; - -DEFINE_GUID(IID_IPictureDisp, 0x7bf80981, 0xbf32, 0x101a, 0x8b, 0xbb, 0x00, 0xAA, 0x00, 0x30, 0x0C, 0xAB); -typedef struct IPictureDisp IPictureDisp, *LPPICTUREDISP; - -/***************************************************************************** - * IPicture interface - */ -#define INTERFACE IPicture -#define IPicture_METHODS \ - IUnknown_METHODS \ - STDMETHOD(get_Handle)(THIS_ OLE_HANDLE *pHandle) PURE; \ - STDMETHOD(get_hPal)(THIS_ OLE_HANDLE *phPal) PURE; \ - STDMETHOD(get_Type)(THIS_ SHORT *pType) PURE; \ - STDMETHOD(get_Width)(THIS_ OLE_XSIZE_HIMETRIC *pWidth) PURE; \ - STDMETHOD(get_Height)(THIS_ OLE_YSIZE_HIMETRIC *pHeight) PURE; \ - STDMETHOD(Render)(THIS_ HDC hdc, LONG x, LONG y, LONG cx, LONG cy, OLE_XPOS_HIMETRIC xSrc, OLE_YPOS_HIMETRIC ySrc, OLE_XSIZE_HIMETRIC cxSrc, OLE_YSIZE_HIMETRIC cySrc, LPCRECT pRcWBounds) PURE; \ - STDMETHOD(set_hPal)(THIS_ OLE_HANDLE hPal) PURE; \ - STDMETHOD(get_CurDC)(THIS_ HDC *phDC) PURE; \ - STDMETHOD(SelectPicture)(THIS_ HDC hDCIn, HDC *phDCOut, OLE_HANDLE *phBmpOut) PURE; \ - STDMETHOD(get_KeepOriginalFormat)(THIS_ BOOL *pKeep) PURE; \ - STDMETHOD(put_KeepOriginalFormat)(THIS_ BOOL Keep) PURE; \ - STDMETHOD(PictureChanged)(THIS) PURE; \ - STDMETHOD(SaveAsFile)(THIS_ LPSTREAM pStream, BOOL fSaveMemCopy, LONG *pCbSize) PURE; \ - STDMETHOD(get_Attributes)(THIS_ DWORD *pDwAttr) PURE; -ICOM_DEFINE(IPicture,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IPicture_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IPicture_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IPicture_Release(p) (p)->lpVtbl->Release(p) -/*** IPicture methods ***/ -#define IPicture_get_Handle(p,a) (p)->lpVtbl->get_Handle(p,a) -#define IPicture_get_hPal(p,a) (p)->lpVtbl->get_hPal(p,a) -#define IPicture_get_Type(p,a) (p)->lpVtbl->get_Type(p,a) -#define IPicture_get_Width(p,a) (p)->lpVtbl->get_Width(p,a) -#define IPicture_get_Height(p,a) (p)->lpVtbl->get_Height(p,a) -#define IPicture_Render(p,a,b,c,d,e,f,g,h,i,j) (p)->lpVtbl->Render(p,a,b,c,d,e,f,g,h,i,j) -#define IPicture_set_hPal(p,a) (p)->lpVtbl->set_hPal(p,a) -#define IPicture_get_CurDC(p,a) (p)->lpVtbl->get_CurDC(p,a) -#define IPicture_SelectPicture(p,a,b,c) (p)->lpVtbl->SelectPicture(p,a,b,c) -#define IPicture_get_KeepOriginalFormat(p,a) (p)->lpVtbl->get_KeepOriginalFormat(p,a) -#define IPicture_put_KeepOriginalFormat(p,a) (p)->lpVtbl->put_KeepOriginalFormat(p,a) -#define IPicture_PictureChanged(p) (p)->lpVtbl->PictureChanged(p) -#define IPicture_SaveAsFile(p,a,b,c) (p)->lpVtbl->SaveAsFile(p,a,b,c) -#define IPicture_get_Attributes(p,a) (p)->lpVtbl->get_Attributes(p,a) -#endif - - -/***************************************************************************** - * IPictureDisp interface - */ -#define INTERFACE IPictureDisp -#define IPictureDisp_METHODS \ - IDispatch_METHODS -ICOM_DEFINE(IPictureDisp,IDispatch) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IPictureDisp_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IPictureDisp_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IPictureDisp_Release(p) (p)->lpVtbl->Release(p) -/*** IDispatch methods ***/ -#define IPictureDisp_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a) -#define IPictureDisp_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,b,c) -#define IPictureDisp_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e) -#define IPictureDisp_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h) -/*** IPictureDisp methods ***/ -#endif - -#ifdef __cplusplus -} /* extern "C" */ -#endif /* defined(__cplusplus) */ - -#endif /* __WINE_WINE_OBJ_PICTURE_H */ diff --git a/include/wine/obj_property.h b/include/wine/obj_property.h deleted file mode 100644 index 8d2de3a62ed..00000000000 --- a/include/wine/obj_property.h +++ /dev/null @@ -1,511 +0,0 @@ -/* - * Defines the COM interfaces and APIs from ocidl.h related to property - * - * Depends on 'obj_base.h'. - * - * Copyright (C) 1999 Paul Quinn - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __WINE_WINE_OBJ_PROPERTY_H -#define __WINE_WINE_OBJ_PROPERTY_H - -#ifdef __cplusplus -extern "C" { -#endif /* defined(__cplusplus) */ - -/***************************************************************************** - * Declare the structures - */ -typedef struct tagPROPPAGEINFO -{ - ULONG cb; - LPOLESTR pszTitle; - SIZE size; - LPOLESTR pszDocString; - LPOLESTR pszHelpFile; - DWORD dwHelpContext; -} PROPPAGEINFO, *LPPROPPAGEINFO; - -typedef enum tagPROPPAGESTATUS -{ - PROPPAGESTATUS_DIRTY = 0x1, - PROPPAGESTATUS_VALIDATE = 0x2, - PROPPAGESTATUS_CLEAN = 0x4 -} PROPPAGESTATUS; - -typedef struct tagCAUUID -{ - ULONG cElems; - GUID* pElems; -} CAUUID, *LPCAUUID; - -typedef struct tagCALPOLESTR -{ - ULONG cElems; - LPOLESTR *pElems; -} CALPOLESTR, *LPCALPOLESTR; - -typedef struct tagCADWORD -{ - ULONG cElems; - DWORD *pElems; -} CADWORD, *LPCADWORD; - - -typedef enum tagPROPBAG2_TYPE -{ - PROPBAG2_TYPE_UNDEFINED = 0, - PROPBAG2_TYPE_DATA = 1, - PROPBAG2_TYPE_URL = 2, - PROPBAG2_TYPE_OBJECT = 3, - PROPBAG2_TYPE_STREAM = 4, - PROPBAG2_TYPE_STORAGE = 5, - PROPBAG2_TYPE_MONIKER = 6 -} PROPBAG2_TYPE; - -typedef struct tagPROPBAG2 -{ - DWORD dwType; - VARTYPE vt; - CLIPFORMAT cfType; - DWORD dwHint; - LPOLESTR pstrName; - CLSID clsid; -} PROPBAG2; - -/***************************************************************************** - * Predeclare the interfaces - */ -DEFINE_GUID(IID_IPropertyPage, 0xb196b28dL, 0xbab4, 0x101a, 0xb6, 0x9c, 0x00, 0xaa, 0x00, 0x34, 0x1d, 0x07); -typedef struct IPropertyPage IPropertyPage, *LPPROPERTYPAGE; - -DEFINE_GUID(IID_IPropertyPage2, 0x01e44665L, 0x24ac, 0x101b, 0x84, 0xed, 0x08, 0x00, 0x2b, 0x2e, 0xc7, 0x13); -typedef struct IPropertyPage2 IPropertyPage2, *LPPROPERTYPAGE2; - -DEFINE_GUID(IID_IPropertyPageSite, 0xb196b28cL, 0xbab4, 0x101a, 0xb6, 0x9c, 0x00, 0xaa, 0x00, 0x34, 0x1d, 0x07); -typedef struct IPropertyPageSite IPropertyPageSite, *LPPROPERTYPAGESITE; - -DEFINE_GUID(IID_IPropertyNotifySink, 0x9bfbbc02L, 0xeff1, 0x101a, 0x84, 0xed, 0x00, 0xaa, 0x00, 0x34, 0x1d, 0x07); -typedef struct IPropertyNotifySink IPropertyNotifySink, *LPPROPERTYNOTIFYSINK; - -DEFINE_GUID(IID_ISimpleFrameSite, 0x742b0e01L, 0x14e6, 0x101b, 0x91, 0x4e, 0x00, 0xaa, 0x00, 0x30, 0x0c, 0xab); -typedef struct ISimpleFrameSite ISimpleFrameSite, *LPSIMPLEFRAMESITE; - -DEFINE_GUID(IID_IPersistStreamInit, 0x7fd52380L, 0x4e07, 0x101b, 0xae, 0x2d, 0x08, 0x00, 0x2b, 0x2e, 0xc7, 0x13); -typedef struct IPersistStreamInit IPersistStreamInit,*LPPERSISTSTREAMINIT; - -DEFINE_GUID(IID_IPersistMemory, 0xbd1ae5e0L, 0xa6ae, 0x11ce, 0xbd, 0x37, 0x50, 0x42, 0x00, 0xc1, 0x00, 0x00); -typedef struct IPersistMemory IPersistMemory,*LPPERSISTMEMORY; - -DEFINE_GUID(IID_IPersistPropertyBag, 0x37d84f60, 0x42cb, 0x11ce, 0x81, 0x35, 0x00, 0xaa, 0x00, 0x4b, 0xb8, 0x51); -typedef struct IPersistPropertyBag IPersistPropertyBag,*LPPERSISTPROPERTYBAG; - -DEFINE_GUID(IID_IPersistPropertyBag2, 0x22f55881, 0x280b, 0x11d0, 0xa8, 0xa9, 0x00, 0xa0, 0xc9, 0x0c, 0x20, 0x04); -typedef struct IPersistPropertyBag2 IPersistPropertyBag2,*LPPERSISTPROPERTYBAG2; - -DEFINE_GUID(IID_IErrorLog, 0x3127ca40L, 0x446e, 0x11ce, 0x81, 0x35, 0x00, 0xaa, 0x00, 0x4b, 0xb8, 0x51); -typedef struct IErrorLog IErrorLog,*LPERRORLOG; - -DEFINE_GUID(IID_IPropertyBag, 0x55272a00L, 0x42cb, 0x11ce, 0x81, 0x35, 0x00, 0xaa, 0x00, 0x4b, 0xb8, 0x51); -typedef struct IPropertyBag IPropertyBag,*LPPROPERTYBAG; - -DEFINE_GUID(IID_IPropertyBag2, 0x22f55882, 0x280b, 0x11d0, 0xa8, 0xa9, 0x00, 0xa0, 0xc9, 0x0c, 0x20, 0x04); -typedef struct IPropertyBag2 IPropertyBag2,*LPPROPERTYBAG2; - -DEFINE_GUID(IID_ISpecifyPropertyPages, 0xb196b28b, 0xbab4, 0x101a, 0xb6, 0x9c, 0x00, 0xaa, 0x00, 0x34, 0x1d, 0x07); -typedef struct ISpecifyPropertyPages ISpecifyPropertyPages,*LPSPECIFYPROPERTYPAGES; - -DEFINE_GUID(IID_IPerPropertyBrowsing, 0xb196b28b, 0xbab4, 0x101a, 0xb6, 0x9c, 0x00, 0xaa, 0x00, 0x34, 0x1d, 0x07); -typedef struct IPerPropertyBrowsing IPerPropertyBrowsing,*LPPERPROPERTYBROWSING; - - -/***************************************************************************** - * IPropertPage interface - */ -#define INTERFACE IPropertyPage -#define IPropertyPage_METHODS \ - IUnknown_METHODS \ - STDMETHOD(SetPageSite)(THIS_ IPropertyPageSite *pPageSite) PURE; \ - STDMETHOD(Activate)(THIS_ HWND hWndParent, LPCRECT pRect, BOOL bModal) PURE; \ - STDMETHOD(Deactivate)(THIS) PURE; \ - STDMETHOD(GetPageInfo)(THIS_ PROPPAGEINFO *pPageInfo) PURE; \ - STDMETHOD(SetObjects)(THIS_ ULONG cObjects, IUnknown **ppUnk) PURE; \ - STDMETHOD(Show)(THIS_ UINT nCmdShow) PURE; \ - STDMETHOD(Move)(THIS_ LPCRECT pRect) PURE; \ - STDMETHOD(IsPageDirty)(THIS) PURE; \ - STDMETHOD(Apply)(THIS) PURE; \ - STDMETHOD(Help)(THIS_ LPCOLESTR pszHelpDir) PURE; \ - STDMETHOD(TranslateAccelerator)(THIS_ MSG *pMsg) PURE; -ICOM_DEFINE(IPropertyPage,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IPropertyPage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IPropertyPage_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IPropertyPage_Release(p) (p)->lpVtbl->Release(p) -/*** IPropertyPage methods ***/ -#define IPropertyPage_SetPageSite(p,a) (p)->lpVtbl->SetPageSite(p,a) -#define IPropertyPage_Activate(p,a,b,c) (p)->lpVtbl->Activate(p,a,b,c) -#define IPropertyPage_Deactivate(p) (p)->lpVtbl->Deactivate(p) -#define IPropertyPage_GetPageInfo(p,a) (p)->lpVtbl->GetPageInfo(p,a) -#define IPropertyPage_SetObjects(p,a,b) (p)->lpVtbl->SetObjects(p,a,b) -#define IPropertyPage_Show(p,a) (p)->lpVtbl->Show(p,a) -#define IPropertyPage_Move(p,a) (p)->lpVtbl->Move(p,a) -#define IPropertyPage_IsPageDirty(p) (p)->lpVtbl->IsPageDirty(p) -#define IPropertyPage_Apply(p) (p)->lpVtbl->Apply(p) -#define IPropertyPage_Help(p,a) (p)->lpVtbl->Help(p,a) -#define IPropertyPage_TranslateAccelerator(p,a) (p)->lpVtbl->TranslateAccelerator(p,a) -#endif - - -/***************************************************************************** - * IPropertPage2 interface - */ -#define INTERFACE IPropertyPage2 -#define IPropertyPage2_METHODS \ - IPropertyPage_METHODS \ - STDMETHOD(EditProperty)(THIS_ DISPID dispID) PURE; -ICOM_DEFINE(IPropertyPage2,IPropertyPage) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IPropertyPage2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IPropertyPage2_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IPropertyPage2_Release(p) (p)->lpVtbl->Release(p) -/*** IPropertyPage methods ***/ -#define IPropertyPage2_SetPageSite(p,a) (p)->lpVtbl->SetPageSite(p,a) -#define IPropertyPage2_Activate(p,a,b,c) (p)->lpVtbl->Activate(p,a,b,c) -#define IPropertyPage2_Deactivate(p) (p)->lpVtbl->Deactivate(p) -#define IPropertyPage2_GetPageInfo(p,a) (p)->lpVtbl->GetPageInfo(p,a) -#define IPropertyPage2_SetObjects(p,a,b) (p)->lpVtbl->SetObjects(p,a,b) -#define IPropertyPage2_Show(p,a) (p)->lpVtbl->Show(p,a) -#define IPropertyPage2_Move(p,a) (p)->lpVtbl->Move(p,a) -#define IPropertyPage2_IsPageDirty(p) (p)->lpVtbl->IsPageDirty(p) -#define IPropertyPage2_Apply(p) (p)->lpVtbl->Apply(p) -#define IPropertyPage2_Help(p,a) (p)->lpVtbl->Help(p,a) -#define IPropertyPage2_TranslateAccelerator(p,a) (p)->lpVtbl->TranslateAccelerator(p,a) -/*** IPropertyPage2 methods ***/ -#define IPropertyPage2_EditProperty(p,a) (p)->lpVtbl->EditProperty(p,a) -#endif - - -/***************************************************************************** - * IPropertPageSite interface - */ -#define INTERFACE IPropertyPageSite -#define IPropertyPageSite_METHODS \ - IUnknown_METHODS \ - STDMETHOD(OnStatusChange)(THIS_ DWORD dwFlags) PURE; \ - STDMETHOD(GetLocaleID)(THIS_ LCID *pLocaleID) PURE; \ - STDMETHOD(GetPageContainer)(THIS_ IUnknown **ppUnk) PURE; \ - STDMETHOD(TranslateAccelerator)(THIS_ MSG *pMsg) PURE; -ICOM_DEFINE(IPropertyPageSite,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IPropertyPageSite_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IPropertyPageSite_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IPropertyPageSite_Release(p) (p)->lpVtbl->Release(p) -/*** IPropertyPageSite methods ***/ -#define IPropertyPageSite_OnStatusChange(p,a) (p)->lpVtbl->OnStatusChange(p,a) -#define IPropertyPageSite_GetLocaleID(p,a) (p)->lpVtbl->GetLocaleID(p,a) -#define IPropertyPageSite_GetPageContainer(p,a) (p)->lpVtbl->GetPageContainer(p,a) -#define IPropertyPageSite_TranslateAccelerator(p,a) (p)->lpVtbl->TranslateAccelerator(p,a) -#endif - - -/***************************************************************************** - * IPropertyNotifySink interface - */ -#define INTERFACE IPropertyNotifySink -#define IPropertyNotifySink_METHODS \ - IUnknown_METHODS \ - STDMETHOD(OnChanged)(THIS_ DISPID dispID) PURE; \ - STDMETHOD(OnRequestEdit)(THIS_ DISPID dispID) PURE; -ICOM_DEFINE(IPropertyNotifySink,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IPropertyNotifySink_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IPropertyNotifySink_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IPropertyNotifySink_Release(p) (p)->lpVtbl->Release(p) -/*** IPropertyNotifySink methods ***/ -#define IPropertyNotifySink_OnChanged(p,a) (p)->lpVtbl->OnChanged(p,a) -#define IPropertyNotifySink_OnRequestEdit(p,a) (p)->lpVtbl->OnRequestEdit(p,a) -#endif - - -/***************************************************************************** - * IPropertyNotifySink interface - */ -#define INTERFACE ISimpleFrameSite -#define ISimpleFrameSite_METHODS \ - IUnknown_METHODS \ - STDMETHOD(PreMessageFilter)(THIS_ HWND hWnd, UINT msg, WPARAM wp, LPARAM lp, LRESULT *plResult, DWORD *pwdCookie) PURE; \ - STDMETHOD(PostMessageFilter)(THIS_ HWND hWnd, UINT msg, WPARAM wp, LPARAM lp, LRESULT *plResult, DWORD pwdCookie) PURE; -ICOM_DEFINE(ISimpleFrameSite,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define ISimpleFrameSite_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define ISimpleFrameSite_AddRef(p) (p)->lpVtbl->AddRef(p) -#define ISimpleFrameSite_Release(p) (p)->lpVtbl->Release(p) -/*** IPropertyNotifySink methods ***/ -#define ISimpleFrameSite_PreMessageFilter(p,a,b,c,d,e,f) (p)->lpVtbl->PreMessageFilter(p,a,b,c,d,e,f) -#define ISimpleFrameSite_PostMessageFilter(p,a,b,c,d,e,f) (p)->lpVtbl->PostMessageFilter(p,a,b,c,d,e,f) -#endif - - -/***************************************************************************** - * IPersistStreamInit interface - */ -#define INTERFACE IPersistStreamInit -#define IPersistStreamInit_METHODS \ - IPersist_METHODS \ - STDMETHOD(IsDirty)(THIS) PURE; \ - STDMETHOD(Load)(THIS_ LPSTREAM pStm) PURE; \ - STDMETHOD(Save)(THIS_ LPSTREAM pStm, BOOL fClearDirty) PURE; \ - STDMETHOD(GetSizeMax)(THIS_ ULARGE_INTEGER *pcbSize) PURE; \ - STDMETHOD(InitNew)(THIS) PURE; -ICOM_DEFINE(IPersistStreamInit,IPersist) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IPersistStreamInit_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IPersistStreamInit_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IPersistStreamInit_Release(p) (p)->lpVtbl->Release(p) -/*** IPersist methods ***/ -#define IPersistStreamInit_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a) -/*** IPersistStreamInit methods ***/ -#define IPersistStreamInit_IsDirty(p) (p)->lpVtbl->IsDirty(p) -#define IPersistStreamInit_Load(p,a) (p)->lpVtbl->Load(p,a) -#define IPersistStreamInit_Save(p,a,b) (p)->lpVtbl->Save(p,a,b) -#define IPersistStreamInit_GetSizeMax(p,a) (p)->lpVtbl->GetSizeMax(p,a) -#define IPersistStreamInit_InitNew(p) (p)->lpVtbl->InitNew(p) -#endif - - -/***************************************************************************** - * IPersistMemory interface - */ -#define INTERFACE IPersistMemory -#define IPersistMemory_METHODS \ - IPersist_METHODS \ - STDMETHOD(IsDirty)(THIS) PURE; \ - STDMETHOD(Load)(THIS_ LPVOID pMem, ULONG cbSize) PURE; \ - STDMETHOD(Save)(THIS_ LPVOID pMem, BOOL fClearDirty, ULONG cbSize) PURE; \ - STDMETHOD(GetSizeMax)(THIS_ ULONG *pCbSize) PURE; \ - STDMETHOD(InitNew)(THIS) PURE; -ICOM_DEFINE(IPersistMemory,IPersist) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IPersistMemory_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IPersistMemory_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IPersistMemory_Release(p) (p)->lpVtbl->Release(p) -/*** IPersist methods ***/ -#define IPersistMemory_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a) -/*** IPersistMemory methods ***/ -#define IPersistMemory_IsDirty(p) (p)->lpVtbl->IsDirty(p) -#define IPersistMemory_Load(p,a,b) (p)->lpVtbl->Load(p,a,b) -#define IPersistMemory_Save(p,a,b,c) (p)->lpVtbl->Save(p,a,b,c) -#define IPersistMemory_GetSizeMax(p,a) (p)->lpVtbl->GetSizeMax(p,a) -#define IPersistMemory_InitNew(p) (p)->lpVtbl->InitNew(p) -#endif - - -/***************************************************************************** - * IPersistPropertyBag interface - */ -#define INTERFACE IPersistPropertyBag -#define IPersistPropertyBag_METHODS \ - IPersist_METHODS \ - STDMETHOD(InitNew)(THIS) PURE; \ - STDMETHOD(Load)(THIS_ IPropertyBag *pPropBag, IErrorLog *pErrorLog) PURE; \ - STDMETHOD(Save)(THIS_ IPropertyBag *pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties) PURE; -ICOM_DEFINE(IPersistPropertyBag,IPersist) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IPersistPropertyBag_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IPersistPropertyBag_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IPersistPropertyBag_Release(p) (p)->lpVtbl->Release(p) -/*** IPersist methods ***/ -#define IPersistPropertyBag_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a) -/*** IPersistPropertyBag methods ***/ -#define IPersistPropertyBag_InitNew(p) (p)->lpVtbl->InitNew(p) -#define IPersistPropertyBag_Load(p,a,b) (p)->lpVtbl->Load(p,a,b) -#define IPersistPropertyBag_Save(p,a,b,c) (p)->lpVtbl->Save(p,a,b,c) -#endif - - -/***************************************************************************** - * IPersistPropertyBag2 interface - */ -#define INTERFACE IPersistPropertyBag2 -#define IPersistPropertyBag2_METHODS \ - IPersist_METHODS \ - STDMETHOD(InitNew)(THIS) PURE; \ - STDMETHOD(Load)(THIS_ IPropertyBag2 *pPropBag, IErrorLog *pErrorLog) PURE; \ - STDMETHOD(Save)(THIS_ IPropertyBag2 *pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties) PURE; \ - STDMETHOD(IsDirty)(THIS) PURE; -ICOM_DEFINE(IPersistPropertyBag2,IPersist) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IPersistPropertyBag2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IPersistPropertyBag2_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IPersistPropertyBag2_Release(p) (p)->lpVtbl->Release(p) -/*** IPersist methods ***/ -#define IPersistPropertyBag2_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a) -/*** IPersistPropertyBag methods ***/ -#define IPersistPropertyBag2_InitNew(p) (p)->lpVtbl->InitNew(p) -#define IPersistPropertyBag2_Load(p,a,b) (p)->lpVtbl->Load(p,a,b) -#define IPersistPropertyBag2_Save(p,a,b,c) (p)->lpVtbl->Save(p,a,b,c) -#define IPersistPropertyBag2_IsDirty(p) (p)->lpVtbl->IsDirty(p) -#endif - - -/***************************************************************************** - * IErrorLog interface - */ -#define INTERFACE IErrorLog -#define IErrorLog_METHODS \ - IUnknown_METHODS \ - STDMETHOD(AddError)(THIS_ LPCOLESTR pszPropName, EXCEPINFO *pExcepInfo) PURE; -ICOM_DEFINE(IErrorLog,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IErrorLog_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IErrorLog_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IErrorLog_Release(p) (p)->lpVtbl->Release(p) -/*** IErrorLog methods ***/ -#define IErrorLog_AddError(p,a,b) (p)->lpVtbl->GetClassID(p,a,b) -#endif - - -/***************************************************************************** - * IPropertyBag interface - */ -#define INTERFACE IPropertyBag -#define IPropertyBag_METHODS \ - IUnknown_METHODS \ - STDMETHOD(Read)(THIS_ LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog) PURE; \ - STDMETHOD(Write)(THIS_ LPCOLESTR pszPropName, VARIANT *pVar) PURE; -ICOM_DEFINE(IPropertyBag,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IPropertyBag_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IPropertyBag_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IPropertyBag_Release(p) (p)->lpVtbl->Release(p) -/*** IPropertyBag methods ***/ -#define IPropertyBag_Read(p,a,b,c) (p)->lpVtbl->Read(p,a,b,c) -#define IPropertyBag_Write(p,a,b) (p)->lpVtbl->Write(p,a,b) -#endif - - -/***************************************************************************** - * IPropertyBag2 interface - */ -#define INTERFACE IPropertyBag2 -#define IPropertyBag2_METHODS \ - IUnknown_METHODS \ - STDMETHOD(Read)(THIS_ ULONG cProperties, PROPBAG2 *pPropBag, IErrorLog *pErrLog, VARIANT *pvarValue, HRESULT *phrError) PURE; \ - STDMETHOD(Write)(THIS_ ULONG cProperties, PROPBAG2 *pPropBag, VARIANT *pvarValue) PURE; \ - STDMETHOD(CountProperties)(THIS_ ULONG *pcProperties) PURE; \ - STDMETHOD(GetPropertyInfo)(THIS_ ULONG iProperty, ULONG cProperties, PROPBAG2 *pPropBag, ULONG *pcProperties) PURE; \ - STDMETHOD(LoadObject)(THIS_ LPCOLESTR pstrName, DWORD dwHint, IUnknown *pUnkObject, IErrorLog *pErrLog) PURE; -ICOM_DEFINE(IPropertyBag2,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IPropertyBag2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IPropertyBag2_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IPropertyBag2_Release(p) (p)->lpVtbl->Release(p) -/*** IPropertyBag methods ***/ -#define IPropertyBag2_Read(p,a,b,c,d,e) (p)->lpVtbl->Read(p,a,b,c,d,e) -#define IPropertyBag2_Write(p,a,b,c) (p)->lpVtbl->Write(p,a,b,c) -#define IPropertyBag2_CountProperties(p,a) (p)->lpVtbl->CountProperties(p,a) -#define IPropertyBag2_GetPropertyInfo(p,a,b,c,d) (p)->lpVtbl->GetPropertyInfo(p,a,b,c,d) -#define IPropertyBag2_LoadObject(p,a,b,c,d) (p)->lpVtbl->LoadObject(p,a,b,c,d) -#endif - - -/***************************************************************************** - * ISpecifyPropertyPages interface - */ -#define INTERFACE ISpecifyPropertyPages -#define ISpecifyPropertyPages_METHODS \ - IUnknown_METHODS \ - STDMETHOD(GetPages)(THIS_ CAUUID *pPages) PURE; -ICOM_DEFINE(ISpecifyPropertyPages,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define ISpecifyPropertyPages_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define ISpecifyPropertyPages_AddRef(p) (p)->lpVtbl->AddRef(p) -#define ISpecifyPropertyPages_Release(p) (p)->lpVtbl->Release(p) -/*** ISpecifyPropertyPages methods ***/ -#define ISpecifyPropertyPages_GetPages(p,a) (p)->lpVtbl->GetPages(p,a) -#endif - - -/***************************************************************************** - * IPerPropertyBrowsing interface - */ -#define INTERFACE IPerPropertyBrowsing -#define IPerPropertyBrowsing_METHODS \ - IUnknown_METHODS \ - STDMETHOD(GetDisplayString)(THIS_ DISPID dispID, BSTR *pBstr) PURE; \ - STDMETHOD(MapPropertyToPage)(THIS_ DISPID dispID, CLSID *pClsid) PURE; \ - STDMETHOD(GetPredefinedStrings)(THIS_ DISPID dispID, CALPOLESTR *pCaStringsOut, CADWORD *pCaCookiesOut) PURE; \ - STDMETHOD(GetPredefinedValue)(THIS_ DISPID dispID, DWORD dwCookie, VARIANT *pVarOut) PURE; -ICOM_DEFINE(IPerPropertyBrowsing,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IPerPropertyBrowsing_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IPerPropertyBrowsing_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IPerPropertyBrowsing_Release(p) (p)->lpVtbl->Release(p) -/*** IPerPropertyBrowsing methods ***/ -#define IPerPropertyBrowsing_GetDisplayString(p,a,b) (p)->lpVtbl->GetDisplayString(p,a,b) -#define IPerPropertyBrowsing_MapPropertyToPage(p,a,b) (p)->lpVtbl->MapPropertyToPage(p,a,b) -#define IPerPropertyBrowsing_GetPredefinedStrings(p,a,b,c) (p)->lpVtbl->GetPredefinedStrings(p,a,b,c) -#define IPerPropertyBrowsing_GetPredefinedValue(p,a,b,c) (p)->lpVtbl->GetPredefinedValue(p,a,b,c) -#endif - -#ifdef __cplusplus -} /* extern "C" */ -#endif /* defined(__cplusplus) */ - -#endif /* __WINE_WINE_OBJ_PROPERTY_H */