/*** Autogenerated by WIDL 0.1 from oleidl.idl - Do not edit ***/
#include <rpc.h>
#include <rpcndr.h>

#ifndef __WIDL_OLEIDL_H
#define __WIDL_OLEIDL_H
#ifdef __cplusplus
extern "C" {
#endif
#include <objidl.h>
typedef enum tagOLERENDER {
    OLERENDER_NONE = 0,
    OLERENDER_DRAW = 1,
    OLERENDER_FORMAT = 2,
    OLERENDER_ASIS = 3
} OLERENDER, *LPOLERENDER;

typedef struct tagOBJECTDESCRIPTOR {
    ULONG cbSize;
    CLSID clsid;
    DWORD dwDrawAspect;
    SIZEL sizel;
    POINTL pointl;
    DWORD dwStatus;
    DWORD dwFullUserTypeName;
    DWORD dwSrcOfCopy;
} OBJECTDESCRIPTOR, *POBJECTDESCRIPTOR, *LPOBJECTDESCRIPTOR, LINKSRCDESCRIPTOR, *PLINKSRCDESCRIPTOR, *LPLINKSRCDESCRIPTOR;

#ifndef __IOleWindow_FWD_DEFINED__
#define __IOleWindow_FWD_DEFINED__
typedef struct IOleWindow IOleWindow;
#endif

typedef IOleWindow *LPOLEWINDOW;

/*****************************************************************************
 * IOleWindow interface
 */
#ifndef __IOleWindow_INTERFACE_DEFINED__
#define __IOleWindow_INTERFACE_DEFINED__

DEFINE_GUID(IID_IOleWindow, 0x00000114, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IOleWindow : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetWindow(
        HWND* phwnd) = 0;

    virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(
        BOOL fEnterMode) = 0;

};
#else
typedef struct IOleWindowVtbl IOleWindowVtbl;
struct IOleWindow {
    const IOleWindowVtbl* lpVtbl;
};
struct IOleWindowVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IOleWindow* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IOleWindow* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IOleWindow* This);

    /*** IOleWindow methods ***/
    HRESULT (STDMETHODCALLTYPE *GetWindow)(
        IOleWindow* This,
        HWND* phwnd);

    HRESULT (STDMETHODCALLTYPE *ContextSensitiveHelp)(
        IOleWindow* This,
        BOOL fEnterMode);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IOleWindow_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IOleWindow_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IOleWindow_Release(p) (p)->lpVtbl->Release(p)
/*** IOleWindow methods ***/
#define IOleWindow_GetWindow(p,a) (p)->lpVtbl->GetWindow(p,a)
#define IOleWindow_ContextSensitiveHelp(p,a) (p)->lpVtbl->ContextSensitiveHelp(p,a)
#endif

#endif

#define IOleWindow_METHODS \
    /*** 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;

HRESULT CALLBACK IOleWindow_GetWindow_Proxy(
    IOleWindow* This,
    HWND* phwnd);
void __RPC_STUB IOleWindow_GetWindow_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleWindow_ContextSensitiveHelp_Proxy(
    IOleWindow* This,
    BOOL fEnterMode);
void __RPC_STUB IOleWindow_ContextSensitiveHelp_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IOleWindow_INTERFACE_DEFINED__ */

#ifndef __IOleInPlaceObject_FWD_DEFINED__
#define __IOleInPlaceObject_FWD_DEFINED__
typedef struct IOleInPlaceObject IOleInPlaceObject;
#endif

typedef IOleInPlaceObject *LPOLEINPLACEOBJECT;

/*****************************************************************************
 * IOleInPlaceObject interface
 */
#ifndef __IOleInPlaceObject_INTERFACE_DEFINED__
#define __IOleInPlaceObject_INTERFACE_DEFINED__

DEFINE_GUID(IID_IOleInPlaceObject, 0x00000113, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IOleInPlaceObject : public IOleWindow
{
    virtual HRESULT STDMETHODCALLTYPE InPlaceDeactivate(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE UIDeactivate(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetObjectRects(
        LPCRECT lprcPosRect,
        LPCRECT lprcClipRect) = 0;

    virtual HRESULT STDMETHODCALLTYPE ReactivateAndUndo(
        ) = 0;

};
#else
typedef struct IOleInPlaceObjectVtbl IOleInPlaceObjectVtbl;
struct IOleInPlaceObject {
    const IOleInPlaceObjectVtbl* lpVtbl;
};
struct IOleInPlaceObjectVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IOleInPlaceObject* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IOleInPlaceObject* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IOleInPlaceObject* This);

    /*** IOleWindow methods ***/
    HRESULT (STDMETHODCALLTYPE *GetWindow)(
        IOleInPlaceObject* This,
        HWND* phwnd);

    HRESULT (STDMETHODCALLTYPE *ContextSensitiveHelp)(
        IOleInPlaceObject* This,
        BOOL fEnterMode);

    /*** IOleInPlaceObject methods ***/
    HRESULT (STDMETHODCALLTYPE *InPlaceDeactivate)(
        IOleInPlaceObject* This);

    HRESULT (STDMETHODCALLTYPE *UIDeactivate)(
        IOleInPlaceObject* This);

    HRESULT (STDMETHODCALLTYPE *SetObjectRects)(
        IOleInPlaceObject* This,
        LPCRECT lprcPosRect,
        LPCRECT lprcClipRect);

    HRESULT (STDMETHODCALLTYPE *ReactivateAndUndo)(
        IOleInPlaceObject* This);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IOleInPlaceObject_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IOleInPlaceObject_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IOleInPlaceObject_Release(p) (p)->lpVtbl->Release(p)
/*** IOleWindow methods ***/
#define IOleInPlaceObject_GetWindow(p,a) (p)->lpVtbl->GetWindow(p,a)
#define IOleInPlaceObject_ContextSensitiveHelp(p,a) (p)->lpVtbl->ContextSensitiveHelp(p,a)
/*** IOleInPlaceObject methods ***/
#define IOleInPlaceObject_InPlaceDeactivate(p) (p)->lpVtbl->InPlaceDeactivate(p)
#define IOleInPlaceObject_UIDeactivate(p) (p)->lpVtbl->UIDeactivate(p)
#define IOleInPlaceObject_SetObjectRects(p,a,b) (p)->lpVtbl->SetObjectRects(p,a,b)
#define IOleInPlaceObject_ReactivateAndUndo(p) (p)->lpVtbl->ReactivateAndUndo(p)
#endif

#endif

#define IOleInPlaceObject_METHODS \
    /*** 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;

HRESULT CALLBACK IOleInPlaceObject_InPlaceDeactivate_Proxy(
    IOleInPlaceObject* This);
void __RPC_STUB IOleInPlaceObject_InPlaceDeactivate_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceObject_UIDeactivate_Proxy(
    IOleInPlaceObject* This);
void __RPC_STUB IOleInPlaceObject_UIDeactivate_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceObject_SetObjectRects_Proxy(
    IOleInPlaceObject* This,
    LPCRECT lprcPosRect,
    LPCRECT lprcClipRect);
void __RPC_STUB IOleInPlaceObject_SetObjectRects_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceObject_ReactivateAndUndo_Proxy(
    IOleInPlaceObject* This);
void __RPC_STUB IOleInPlaceObject_ReactivateAndUndo_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IOleInPlaceObject_INTERFACE_DEFINED__ */

#ifdef __WINESRC__
#undef TranslateAccelerator
#endif
#ifndef __IOleInPlaceUIWindow_FWD_DEFINED__
#define __IOleInPlaceUIWindow_FWD_DEFINED__
typedef struct IOleInPlaceUIWindow IOleInPlaceUIWindow;
#endif

#ifndef __IOleInPlaceActiveObject_FWD_DEFINED__
#define __IOleInPlaceActiveObject_FWD_DEFINED__
typedef struct IOleInPlaceActiveObject IOleInPlaceActiveObject;
#endif

typedef IOleInPlaceActiveObject *LPOLEINPLACEACTIVEOBJECT;

/*****************************************************************************
 * IOleInPlaceActiveObject interface
 */
#ifndef __IOleInPlaceActiveObject_INTERFACE_DEFINED__
#define __IOleInPlaceActiveObject_INTERFACE_DEFINED__

DEFINE_GUID(IID_IOleInPlaceActiveObject, 0x00000117, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IOleInPlaceActiveObject : public IOleWindow
{
    virtual HRESULT STDMETHODCALLTYPE TranslateAccelerator(
        LPMSG lpmsg) = 0;

    virtual HRESULT STDMETHODCALLTYPE OnFrameWindowActivate(
        BOOL fActivate) = 0;

    virtual HRESULT STDMETHODCALLTYPE OnDocWindowActivate(
        BOOL fActivate) = 0;

    virtual HRESULT STDMETHODCALLTYPE ResizeBorder(
        LPCRECT prcBorder,
        IOleInPlaceUIWindow* pUIWindow,
        BOOL fFrameWindow) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnableModeless(
        BOOL fEnable) = 0;

};
#else
typedef struct IOleInPlaceActiveObjectVtbl IOleInPlaceActiveObjectVtbl;
struct IOleInPlaceActiveObject {
    const IOleInPlaceActiveObjectVtbl* lpVtbl;
};
struct IOleInPlaceActiveObjectVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IOleInPlaceActiveObject* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IOleInPlaceActiveObject* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IOleInPlaceActiveObject* This);

    /*** IOleWindow methods ***/
    HRESULT (STDMETHODCALLTYPE *GetWindow)(
        IOleInPlaceActiveObject* This,
        HWND* phwnd);

    HRESULT (STDMETHODCALLTYPE *ContextSensitiveHelp)(
        IOleInPlaceActiveObject* This,
        BOOL fEnterMode);

    /*** IOleInPlaceActiveObject methods ***/
    HRESULT (STDMETHODCALLTYPE *TranslateAccelerator)(
        IOleInPlaceActiveObject* This,
        LPMSG lpmsg);

    HRESULT (STDMETHODCALLTYPE *OnFrameWindowActivate)(
        IOleInPlaceActiveObject* This,
        BOOL fActivate);

    HRESULT (STDMETHODCALLTYPE *OnDocWindowActivate)(
        IOleInPlaceActiveObject* This,
        BOOL fActivate);

    HRESULT (STDMETHODCALLTYPE *ResizeBorder)(
        IOleInPlaceActiveObject* This,
        LPCRECT prcBorder,
        IOleInPlaceUIWindow* pUIWindow,
        BOOL fFrameWindow);

    HRESULT (STDMETHODCALLTYPE *EnableModeless)(
        IOleInPlaceActiveObject* This,
        BOOL fEnable);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IOleInPlaceActiveObject_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IOleInPlaceActiveObject_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IOleInPlaceActiveObject_Release(p) (p)->lpVtbl->Release(p)
/*** IOleWindow methods ***/
#define IOleInPlaceActiveObject_GetWindow(p,a) (p)->lpVtbl->GetWindow(p,a)
#define IOleInPlaceActiveObject_ContextSensitiveHelp(p,a) (p)->lpVtbl->ContextSensitiveHelp(p,a)
/*** IOleInPlaceActiveObject methods ***/
#define IOleInPlaceActiveObject_TranslateAccelerator(p,a) (p)->lpVtbl->TranslateAccelerator(p,a)
#define IOleInPlaceActiveObject_OnFrameWindowActivate(p,a) (p)->lpVtbl->OnFrameWindowActivate(p,a)
#define IOleInPlaceActiveObject_OnDocWindowActivate(p,a) (p)->lpVtbl->OnDocWindowActivate(p,a)
#define IOleInPlaceActiveObject_ResizeBorder(p,a,b,c) (p)->lpVtbl->ResizeBorder(p,a,b,c)
#define IOleInPlaceActiveObject_EnableModeless(p,a) (p)->lpVtbl->EnableModeless(p,a)
#endif

#endif

#define IOleInPlaceActiveObject_METHODS \
    /*** 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; \
    /*** IOleInPlaceActiveObject methods ***/ \
    STDMETHOD_(HRESULT,TranslateAccelerator)(THIS_ LPMSG lpmsg) PURE; \
    STDMETHOD_(HRESULT,OnFrameWindowActivate)(THIS_ BOOL fActivate) PURE; \
    STDMETHOD_(HRESULT,OnDocWindowActivate)(THIS_ BOOL fActivate) PURE; \
    STDMETHOD_(HRESULT,ResizeBorder)(THIS_ LPCRECT prcBorder, IOleInPlaceUIWindow* pUIWindow, BOOL fFrameWindow) PURE; \
    STDMETHOD_(HRESULT,EnableModeless)(THIS_ BOOL fEnable) PURE;

HRESULT CALLBACK IOleInPlaceActiveObject_RemoteTranslateAccelerator_Proxy(
    IOleInPlaceActiveObject* This);
void __RPC_STUB IOleInPlaceActiveObject_RemoteTranslateAccelerator_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceActiveObject_TranslateAccelerator_Proxy(
    IOleInPlaceActiveObject* This,
    LPMSG lpmsg);
HRESULT __RPC_STUB IOleInPlaceActiveObject_TranslateAccelerator_Stub(
    IOleInPlaceActiveObject* This);
HRESULT CALLBACK IOleInPlaceActiveObject_OnFrameWindowActivate_Proxy(
    IOleInPlaceActiveObject* This,
    BOOL fActivate);
void __RPC_STUB IOleInPlaceActiveObject_OnFrameWindowActivate_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceActiveObject_OnDocWindowActivate_Proxy(
    IOleInPlaceActiveObject* This,
    BOOL fActivate);
void __RPC_STUB IOleInPlaceActiveObject_OnDocWindowActivate_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceActiveObject_RemoteResizeBorder_Proxy(
    IOleInPlaceActiveObject* This,
    LPCRECT prcBorder,
    REFIID riid,
    IOleInPlaceUIWindow* pUIWindow,
    BOOL fFrameWindow);
void __RPC_STUB IOleInPlaceActiveObject_RemoteResizeBorder_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceActiveObject_ResizeBorder_Proxy(
    IOleInPlaceActiveObject* This,
    LPCRECT prcBorder,
    IOleInPlaceUIWindow* pUIWindow,
    BOOL fFrameWindow);
HRESULT __RPC_STUB IOleInPlaceActiveObject_ResizeBorder_Stub(
    IOleInPlaceActiveObject* This,
    LPCRECT prcBorder,
    REFIID riid,
    IOleInPlaceUIWindow* pUIWindow,
    BOOL fFrameWindow);
HRESULT CALLBACK IOleInPlaceActiveObject_EnableModeless_Proxy(
    IOleInPlaceActiveObject* This,
    BOOL fEnable);
void __RPC_STUB IOleInPlaceActiveObject_EnableModeless_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IOleInPlaceActiveObject_INTERFACE_DEFINED__ */

typedef IOleInPlaceUIWindow *LPOLEINPLACEUIWINDOW;

typedef RECT BORDERWIDTHS;

typedef LPRECT LPBORDERWIDTHS;

typedef LPCRECT LPCBORDERWIDTHS;

/*****************************************************************************
 * IOleInPlaceUIWindow interface
 */
#ifndef __IOleInPlaceUIWindow_INTERFACE_DEFINED__
#define __IOleInPlaceUIWindow_INTERFACE_DEFINED__

DEFINE_GUID(IID_IOleInPlaceUIWindow, 0x00000115, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IOleInPlaceUIWindow : public IOleWindow
{
    virtual HRESULT STDMETHODCALLTYPE GetBorder(
        LPRECT lprectBorder) = 0;

    virtual HRESULT STDMETHODCALLTYPE RequestBorderSpace(
        LPCBORDERWIDTHS pborderwidths) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetBorderSpace(
        LPCBORDERWIDTHS pborderwidths) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetActiveObject(
        IOleInPlaceActiveObject* pActiveObject,
        LPCOLESTR pszObjName) = 0;

};
#else
typedef struct IOleInPlaceUIWindowVtbl IOleInPlaceUIWindowVtbl;
struct IOleInPlaceUIWindow {
    const IOleInPlaceUIWindowVtbl* lpVtbl;
};
struct IOleInPlaceUIWindowVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IOleInPlaceUIWindow* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IOleInPlaceUIWindow* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IOleInPlaceUIWindow* This);

    /*** IOleWindow methods ***/
    HRESULT (STDMETHODCALLTYPE *GetWindow)(
        IOleInPlaceUIWindow* This,
        HWND* phwnd);

    HRESULT (STDMETHODCALLTYPE *ContextSensitiveHelp)(
        IOleInPlaceUIWindow* This,
        BOOL fEnterMode);

    /*** IOleInPlaceUIWindow methods ***/
    HRESULT (STDMETHODCALLTYPE *GetBorder)(
        IOleInPlaceUIWindow* This,
        LPRECT lprectBorder);

    HRESULT (STDMETHODCALLTYPE *RequestBorderSpace)(
        IOleInPlaceUIWindow* This,
        LPCBORDERWIDTHS pborderwidths);

    HRESULT (STDMETHODCALLTYPE *SetBorderSpace)(
        IOleInPlaceUIWindow* This,
        LPCBORDERWIDTHS pborderwidths);

    HRESULT (STDMETHODCALLTYPE *SetActiveObject)(
        IOleInPlaceUIWindow* This,
        IOleInPlaceActiveObject* pActiveObject,
        LPCOLESTR pszObjName);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IOleInPlaceUIWindow_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IOleInPlaceUIWindow_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IOleInPlaceUIWindow_Release(p) (p)->lpVtbl->Release(p)
/*** IOleWindow methods ***/
#define IOleInPlaceUIWindow_GetWindow(p,a) (p)->lpVtbl->GetWindow(p,a)
#define IOleInPlaceUIWindow_ContextSensitiveHelp(p,a) (p)->lpVtbl->ContextSensitiveHelp(p,a)
/*** IOleInPlaceUIWindow methods ***/
#define IOleInPlaceUIWindow_GetBorder(p,a) (p)->lpVtbl->GetBorder(p,a)
#define IOleInPlaceUIWindow_RequestBorderSpace(p,a) (p)->lpVtbl->RequestBorderSpace(p,a)
#define IOleInPlaceUIWindow_SetBorderSpace(p,a) (p)->lpVtbl->SetBorderSpace(p,a)
#define IOleInPlaceUIWindow_SetActiveObject(p,a,b) (p)->lpVtbl->SetActiveObject(p,a,b)
#endif

#endif

#define IOleInPlaceUIWindow_METHODS \
    /*** 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; \
    /*** IOleInPlaceUIWindow methods ***/ \
    STDMETHOD_(HRESULT,GetBorder)(THIS_ LPRECT lprectBorder) PURE; \
    STDMETHOD_(HRESULT,RequestBorderSpace)(THIS_ LPCBORDERWIDTHS pborderwidths) PURE; \
    STDMETHOD_(HRESULT,SetBorderSpace)(THIS_ LPCBORDERWIDTHS pborderwidths) PURE; \
    STDMETHOD_(HRESULT,SetActiveObject)(THIS_ IOleInPlaceActiveObject* pActiveObject, LPCOLESTR pszObjName) PURE;

HRESULT CALLBACK IOleInPlaceUIWindow_GetBorder_Proxy(
    IOleInPlaceUIWindow* This,
    LPRECT lprectBorder);
void __RPC_STUB IOleInPlaceUIWindow_GetBorder_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceUIWindow_RequestBorderSpace_Proxy(
    IOleInPlaceUIWindow* This,
    LPCBORDERWIDTHS pborderwidths);
void __RPC_STUB IOleInPlaceUIWindow_RequestBorderSpace_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceUIWindow_SetBorderSpace_Proxy(
    IOleInPlaceUIWindow* This,
    LPCBORDERWIDTHS pborderwidths);
void __RPC_STUB IOleInPlaceUIWindow_SetBorderSpace_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceUIWindow_SetActiveObject_Proxy(
    IOleInPlaceUIWindow* This,
    IOleInPlaceActiveObject* pActiveObject,
    LPCOLESTR pszObjName);
void __RPC_STUB IOleInPlaceUIWindow_SetActiveObject_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IOleInPlaceUIWindow_INTERFACE_DEFINED__ */

#ifndef __IOleInPlaceFrame_FWD_DEFINED__
#define __IOleInPlaceFrame_FWD_DEFINED__
typedef struct IOleInPlaceFrame IOleInPlaceFrame;
#endif

typedef IOleInPlaceFrame *LPOLEINPLACEFRAME;

typedef struct tagOleInPlaceFrameInfo {
    UINT cb;
    BOOL fMDIApp;
    HWND hwndFrame;
    HACCEL haccel;
    UINT cAccelEntries;
} OLEINPLACEFRAMEINFO, *LPOLEINPLACEFRAMEINFO;

typedef struct tagOleMenuGroupWidths {
    LONG width[6];
} OLEMENUGROUPWIDTHS, *LPOLEMENUGROUPWIDTHS;

typedef HGLOBAL HOLEMENU;

/*****************************************************************************
 * IOleInPlaceFrame interface
 */
#ifndef __IOleInPlaceFrame_INTERFACE_DEFINED__
#define __IOleInPlaceFrame_INTERFACE_DEFINED__

DEFINE_GUID(IID_IOleInPlaceFrame, 0x00000116, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IOleInPlaceFrame : public IOleInPlaceUIWindow
{
    virtual HRESULT STDMETHODCALLTYPE InsertMenus(
        HMENU hmenuShared,
        LPOLEMENUGROUPWIDTHS lpMenuWidths) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetMenu(
        HMENU hmenuShared,
        HOLEMENU holemenu,
        HWND hwndActiveObject) = 0;

    virtual HRESULT STDMETHODCALLTYPE RemoveMenus(
        HMENU hmenuShared) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetStatusText(
        LPCOLESTR pszStatusText) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnableModeless(
        BOOL fEnable) = 0;

    virtual HRESULT STDMETHODCALLTYPE TranslateAccelerator(
        LPMSG lpmsg,
        WORD wID) = 0;

};
#else
typedef struct IOleInPlaceFrameVtbl IOleInPlaceFrameVtbl;
struct IOleInPlaceFrame {
    const IOleInPlaceFrameVtbl* lpVtbl;
};
struct IOleInPlaceFrameVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IOleInPlaceFrame* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IOleInPlaceFrame* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IOleInPlaceFrame* This);

    /*** IOleWindow methods ***/
    HRESULT (STDMETHODCALLTYPE *GetWindow)(
        IOleInPlaceFrame* This,
        HWND* phwnd);

    HRESULT (STDMETHODCALLTYPE *ContextSensitiveHelp)(
        IOleInPlaceFrame* This,
        BOOL fEnterMode);

    /*** IOleInPlaceUIWindow methods ***/
    HRESULT (STDMETHODCALLTYPE *GetBorder)(
        IOleInPlaceFrame* This,
        LPRECT lprectBorder);

    HRESULT (STDMETHODCALLTYPE *RequestBorderSpace)(
        IOleInPlaceFrame* This,
        LPCBORDERWIDTHS pborderwidths);

    HRESULT (STDMETHODCALLTYPE *SetBorderSpace)(
        IOleInPlaceFrame* This,
        LPCBORDERWIDTHS pborderwidths);

    HRESULT (STDMETHODCALLTYPE *SetActiveObject)(
        IOleInPlaceFrame* This,
        IOleInPlaceActiveObject* pActiveObject,
        LPCOLESTR pszObjName);

    /*** IOleInPlaceFrame methods ***/
    HRESULT (STDMETHODCALLTYPE *InsertMenus)(
        IOleInPlaceFrame* This,
        HMENU hmenuShared,
        LPOLEMENUGROUPWIDTHS lpMenuWidths);

    HRESULT (STDMETHODCALLTYPE *SetMenu)(
        IOleInPlaceFrame* This,
        HMENU hmenuShared,
        HOLEMENU holemenu,
        HWND hwndActiveObject);

    HRESULT (STDMETHODCALLTYPE *RemoveMenus)(
        IOleInPlaceFrame* This,
        HMENU hmenuShared);

    HRESULT (STDMETHODCALLTYPE *SetStatusText)(
        IOleInPlaceFrame* This,
        LPCOLESTR pszStatusText);

    HRESULT (STDMETHODCALLTYPE *EnableModeless)(
        IOleInPlaceFrame* This,
        BOOL fEnable);

    HRESULT (STDMETHODCALLTYPE *TranslateAccelerator)(
        IOleInPlaceFrame* This,
        LPMSG lpmsg,
        WORD wID);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IOleInPlaceFrame_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IOleInPlaceFrame_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IOleInPlaceFrame_Release(p) (p)->lpVtbl->Release(p)
/*** IOleWindow methods ***/
#define IOleInPlaceFrame_GetWindow(p,a) (p)->lpVtbl->GetWindow(p,a)
#define IOleInPlaceFrame_ContextSensitiveHelp(p,a) (p)->lpVtbl->ContextSensitiveHelp(p,a)
/*** IOleInPlaceUIWindow methods ***/
#define IOleInPlaceFrame_GetBorder(p,a) (p)->lpVtbl->GetBorder(p,a)
#define IOleInPlaceFrame_RequestBorderSpace(p,a) (p)->lpVtbl->RequestBorderSpace(p,a)
#define IOleInPlaceFrame_SetBorderSpace(p,a) (p)->lpVtbl->SetBorderSpace(p,a)
#define IOleInPlaceFrame_SetActiveObject(p,a,b) (p)->lpVtbl->SetActiveObject(p,a,b)
/*** IOleInPlaceFrame methods ***/
#define IOleInPlaceFrame_InsertMenus(p,a,b) (p)->lpVtbl->InsertMenus(p,a,b)
#define IOleInPlaceFrame_SetMenu(p,a,b,c) (p)->lpVtbl->SetMenu(p,a,b,c)
#define IOleInPlaceFrame_RemoveMenus(p,a) (p)->lpVtbl->RemoveMenus(p,a)
#define IOleInPlaceFrame_SetStatusText(p,a) (p)->lpVtbl->SetStatusText(p,a)
#define IOleInPlaceFrame_EnableModeless(p,a) (p)->lpVtbl->EnableModeless(p,a)
#define IOleInPlaceFrame_TranslateAccelerator(p,a,b) (p)->lpVtbl->TranslateAccelerator(p,a,b)
#endif

#endif

#define IOleInPlaceFrame_METHODS \
    /*** 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; \
    /*** IOleInPlaceUIWindow methods ***/ \
    STDMETHOD_(HRESULT,GetBorder)(THIS_ LPRECT lprectBorder) PURE; \
    STDMETHOD_(HRESULT,RequestBorderSpace)(THIS_ LPCBORDERWIDTHS pborderwidths) PURE; \
    STDMETHOD_(HRESULT,SetBorderSpace)(THIS_ LPCBORDERWIDTHS pborderwidths) PURE; \
    STDMETHOD_(HRESULT,SetActiveObject)(THIS_ IOleInPlaceActiveObject* pActiveObject, LPCOLESTR pszObjName) PURE; \
    /*** IOleInPlaceFrame methods ***/ \
    STDMETHOD_(HRESULT,InsertMenus)(THIS_ HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths) PURE; \
    STDMETHOD_(HRESULT,SetMenu)(THIS_ HMENU hmenuShared, HOLEMENU holemenu, HWND hwndActiveObject) PURE; \
    STDMETHOD_(HRESULT,RemoveMenus)(THIS_ HMENU hmenuShared) PURE; \
    STDMETHOD_(HRESULT,SetStatusText)(THIS_ LPCOLESTR pszStatusText) PURE; \
    STDMETHOD_(HRESULT,EnableModeless)(THIS_ BOOL fEnable) PURE; \
    STDMETHOD_(HRESULT,TranslateAccelerator)(THIS_ LPMSG lpmsg, WORD wID) PURE;

HRESULT CALLBACK IOleInPlaceFrame_InsertMenus_Proxy(
    IOleInPlaceFrame* This,
    HMENU hmenuShared,
    LPOLEMENUGROUPWIDTHS lpMenuWidths);
void __RPC_STUB IOleInPlaceFrame_InsertMenus_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceFrame_SetMenu_Proxy(
    IOleInPlaceFrame* This,
    HMENU hmenuShared,
    HOLEMENU holemenu,
    HWND hwndActiveObject);
void __RPC_STUB IOleInPlaceFrame_SetMenu_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceFrame_RemoveMenus_Proxy(
    IOleInPlaceFrame* This,
    HMENU hmenuShared);
void __RPC_STUB IOleInPlaceFrame_RemoveMenus_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceFrame_SetStatusText_Proxy(
    IOleInPlaceFrame* This,
    LPCOLESTR pszStatusText);
void __RPC_STUB IOleInPlaceFrame_SetStatusText_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceFrame_EnableModeless_Proxy(
    IOleInPlaceFrame* This,
    BOOL fEnable);
void __RPC_STUB IOleInPlaceFrame_EnableModeless_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceFrame_TranslateAccelerator_Proxy(
    IOleInPlaceFrame* This,
    LPMSG lpmsg,
    WORD wID);
void __RPC_STUB IOleInPlaceFrame_TranslateAccelerator_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IOleInPlaceFrame_INTERFACE_DEFINED__ */

#ifndef __IOleInPlaceSite_FWD_DEFINED__
#define __IOleInPlaceSite_FWD_DEFINED__
typedef struct IOleInPlaceSite IOleInPlaceSite;
#endif

typedef IOleInPlaceSite *LPOLEINPLACESITE;

/*****************************************************************************
 * IOleInPlaceSite interface
 */
#ifndef __IOleInPlaceSite_INTERFACE_DEFINED__
#define __IOleInPlaceSite_INTERFACE_DEFINED__

DEFINE_GUID(IID_IOleInPlaceSite, 0x00000119, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IOleInPlaceSite : public IOleWindow
{
    virtual HRESULT STDMETHODCALLTYPE CanInPlaceActivate(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE OnInPlaceActivate(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE OnUIActivate(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetWindowContext(
        IOleInPlaceFrame** ppFrame,
        IOleInPlaceUIWindow** ppDoc,
        LPRECT lprcPosRect,
        LPRECT lprcClipRect,
        LPOLEINPLACEFRAMEINFO lpFrameInfo) = 0;

    virtual HRESULT STDMETHODCALLTYPE Scroll(
        SIZE scrollExtant) = 0;

    virtual HRESULT STDMETHODCALLTYPE OnUIDeactivate(
        BOOL fUndoable) = 0;

    virtual HRESULT STDMETHODCALLTYPE OnInPlaceDeactivate(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE DiscardUndoState(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE DeactivateAndUndo(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE OnPosRectChange(
        LPCRECT lprcPosRect) = 0;

};
#else
typedef struct IOleInPlaceSiteVtbl IOleInPlaceSiteVtbl;
struct IOleInPlaceSite {
    const IOleInPlaceSiteVtbl* lpVtbl;
};
struct IOleInPlaceSiteVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IOleInPlaceSite* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IOleInPlaceSite* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IOleInPlaceSite* This);

    /*** IOleWindow methods ***/
    HRESULT (STDMETHODCALLTYPE *GetWindow)(
        IOleInPlaceSite* This,
        HWND* phwnd);

    HRESULT (STDMETHODCALLTYPE *ContextSensitiveHelp)(
        IOleInPlaceSite* This,
        BOOL fEnterMode);

    /*** IOleInPlaceSite methods ***/
    HRESULT (STDMETHODCALLTYPE *CanInPlaceActivate)(
        IOleInPlaceSite* This);

    HRESULT (STDMETHODCALLTYPE *OnInPlaceActivate)(
        IOleInPlaceSite* This);

    HRESULT (STDMETHODCALLTYPE *OnUIActivate)(
        IOleInPlaceSite* This);

    HRESULT (STDMETHODCALLTYPE *GetWindowContext)(
        IOleInPlaceSite* This,
        IOleInPlaceFrame** ppFrame,
        IOleInPlaceUIWindow** ppDoc,
        LPRECT lprcPosRect,
        LPRECT lprcClipRect,
        LPOLEINPLACEFRAMEINFO lpFrameInfo);

    HRESULT (STDMETHODCALLTYPE *Scroll)(
        IOleInPlaceSite* This,
        SIZE scrollExtant);

    HRESULT (STDMETHODCALLTYPE *OnUIDeactivate)(
        IOleInPlaceSite* This,
        BOOL fUndoable);

    HRESULT (STDMETHODCALLTYPE *OnInPlaceDeactivate)(
        IOleInPlaceSite* This);

    HRESULT (STDMETHODCALLTYPE *DiscardUndoState)(
        IOleInPlaceSite* This);

    HRESULT (STDMETHODCALLTYPE *DeactivateAndUndo)(
        IOleInPlaceSite* This);

    HRESULT (STDMETHODCALLTYPE *OnPosRectChange)(
        IOleInPlaceSite* This,
        LPCRECT lprcPosRect);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IOleInPlaceSite_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IOleInPlaceSite_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IOleInPlaceSite_Release(p) (p)->lpVtbl->Release(p)
/*** IOleWindow methods ***/
#define IOleInPlaceSite_GetWindow(p,a) (p)->lpVtbl->GetWindow(p,a)
#define IOleInPlaceSite_ContextSensitiveHelp(p,a) (p)->lpVtbl->ContextSensitiveHelp(p,a)
/*** IOleInPlaceSite methods ***/
#define IOleInPlaceSite_CanInPlaceActivate(p) (p)->lpVtbl->CanInPlaceActivate(p)
#define IOleInPlaceSite_OnInPlaceActivate(p) (p)->lpVtbl->OnInPlaceActivate(p)
#define IOleInPlaceSite_OnUIActivate(p) (p)->lpVtbl->OnUIActivate(p)
#define IOleInPlaceSite_GetWindowContext(p,a,b,c,d,e) (p)->lpVtbl->GetWindowContext(p,a,b,c,d,e)
#define IOleInPlaceSite_Scroll(p,a) (p)->lpVtbl->Scroll(p,a)
#define IOleInPlaceSite_OnUIDeactivate(p,a) (p)->lpVtbl->OnUIDeactivate(p,a)
#define IOleInPlaceSite_OnInPlaceDeactivate(p) (p)->lpVtbl->OnInPlaceDeactivate(p)
#define IOleInPlaceSite_DiscardUndoState(p) (p)->lpVtbl->DiscardUndoState(p)
#define IOleInPlaceSite_DeactivateAndUndo(p) (p)->lpVtbl->DeactivateAndUndo(p)
#define IOleInPlaceSite_OnPosRectChange(p,a) (p)->lpVtbl->OnPosRectChange(p,a)
#endif

#endif

#define IOleInPlaceSite_METHODS \
    /*** 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;

HRESULT CALLBACK IOleInPlaceSite_CanInPlaceActivate_Proxy(
    IOleInPlaceSite* This);
void __RPC_STUB IOleInPlaceSite_CanInPlaceActivate_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceSite_OnInPlaceActivate_Proxy(
    IOleInPlaceSite* This);
void __RPC_STUB IOleInPlaceSite_OnInPlaceActivate_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceSite_OnUIActivate_Proxy(
    IOleInPlaceSite* This);
void __RPC_STUB IOleInPlaceSite_OnUIActivate_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceSite_GetWindowContext_Proxy(
    IOleInPlaceSite* This,
    IOleInPlaceFrame** ppFrame,
    IOleInPlaceUIWindow** ppDoc,
    LPRECT lprcPosRect,
    LPRECT lprcClipRect,
    LPOLEINPLACEFRAMEINFO lpFrameInfo);
void __RPC_STUB IOleInPlaceSite_GetWindowContext_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceSite_Scroll_Proxy(
    IOleInPlaceSite* This,
    SIZE scrollExtant);
void __RPC_STUB IOleInPlaceSite_Scroll_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceSite_OnUIDeactivate_Proxy(
    IOleInPlaceSite* This,
    BOOL fUndoable);
void __RPC_STUB IOleInPlaceSite_OnUIDeactivate_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceSite_OnInPlaceDeactivate_Proxy(
    IOleInPlaceSite* This);
void __RPC_STUB IOleInPlaceSite_OnInPlaceDeactivate_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceSite_DiscardUndoState_Proxy(
    IOleInPlaceSite* This);
void __RPC_STUB IOleInPlaceSite_DiscardUndoState_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceSite_DeactivateAndUndo_Proxy(
    IOleInPlaceSite* This);
void __RPC_STUB IOleInPlaceSite_DeactivateAndUndo_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleInPlaceSite_OnPosRectChange_Proxy(
    IOleInPlaceSite* This,
    LPCRECT lprcPosRect);
void __RPC_STUB IOleInPlaceSite_OnPosRectChange_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IOleInPlaceSite_INTERFACE_DEFINED__ */

#ifndef __IParseDisplayName_FWD_DEFINED__
#define __IParseDisplayName_FWD_DEFINED__
typedef struct IParseDisplayName IParseDisplayName;
#endif

typedef IParseDisplayName *LPPARSEDISPLAYNAME;

/*****************************************************************************
 * IParseDisplayName interface
 */
#ifndef __IParseDisplayName_INTERFACE_DEFINED__
#define __IParseDisplayName_INTERFACE_DEFINED__

DEFINE_GUID(IID_IParseDisplayName, 0x0000011a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IParseDisplayName : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE ParseDisplayName(
        IBindCtx* pbc,
        LPOLESTR pszDisplayName,
        ULONG* pchEaten,
        IMoniker** ppmkOut) = 0;

};
#else
typedef struct IParseDisplayNameVtbl IParseDisplayNameVtbl;
struct IParseDisplayName {
    const IParseDisplayNameVtbl* lpVtbl;
};
struct IParseDisplayNameVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IParseDisplayName* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IParseDisplayName* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IParseDisplayName* This);

    /*** IParseDisplayName methods ***/
    HRESULT (STDMETHODCALLTYPE *ParseDisplayName)(
        IParseDisplayName* This,
        IBindCtx* pbc,
        LPOLESTR pszDisplayName,
        ULONG* pchEaten,
        IMoniker** ppmkOut);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IParseDisplayName_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IParseDisplayName_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IParseDisplayName_Release(p) (p)->lpVtbl->Release(p)
/*** IParseDisplayName methods ***/
#define IParseDisplayName_ParseDisplayName(p,a,b,c,d) (p)->lpVtbl->ParseDisplayName(p,a,b,c,d)
#endif

#endif

#define IParseDisplayName_METHODS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IParseDisplayName methods ***/ \
    STDMETHOD_(HRESULT,ParseDisplayName)(THIS_ IBindCtx* pbc, LPOLESTR pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut) PURE;

HRESULT CALLBACK IParseDisplayName_ParseDisplayName_Proxy(
    IParseDisplayName* This,
    IBindCtx* pbc,
    LPOLESTR pszDisplayName,
    ULONG* pchEaten,
    IMoniker** ppmkOut);
void __RPC_STUB IParseDisplayName_ParseDisplayName_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IParseDisplayName_INTERFACE_DEFINED__ */

#ifndef __IOleContainer_FWD_DEFINED__
#define __IOleContainer_FWD_DEFINED__
typedef struct IOleContainer IOleContainer;
#endif

typedef IOleContainer *LPOLECONTAINER;

/*****************************************************************************
 * IOleContainer interface
 */
#ifndef __IOleContainer_INTERFACE_DEFINED__
#define __IOleContainer_INTERFACE_DEFINED__

DEFINE_GUID(IID_IOleContainer, 0x0000011b, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IOleContainer : public IParseDisplayName
{
    virtual HRESULT STDMETHODCALLTYPE EnumObjects(
        DWORD grfFlags,
        IEnumUnknown** ppenum) = 0;

    virtual HRESULT STDMETHODCALLTYPE LockContainer(
        BOOL fLock) = 0;

};
#else
typedef struct IOleContainerVtbl IOleContainerVtbl;
struct IOleContainer {
    const IOleContainerVtbl* lpVtbl;
};
struct IOleContainerVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IOleContainer* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IOleContainer* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IOleContainer* This);

    /*** IParseDisplayName methods ***/
    HRESULT (STDMETHODCALLTYPE *ParseDisplayName)(
        IOleContainer* This,
        IBindCtx* pbc,
        LPOLESTR pszDisplayName,
        ULONG* pchEaten,
        IMoniker** ppmkOut);

    /*** IOleContainer methods ***/
    HRESULT (STDMETHODCALLTYPE *EnumObjects)(
        IOleContainer* This,
        DWORD grfFlags,
        IEnumUnknown** ppenum);

    HRESULT (STDMETHODCALLTYPE *LockContainer)(
        IOleContainer* This,
        BOOL fLock);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IOleContainer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IOleContainer_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IOleContainer_Release(p) (p)->lpVtbl->Release(p)
/*** IParseDisplayName methods ***/
#define IOleContainer_ParseDisplayName(p,a,b,c,d) (p)->lpVtbl->ParseDisplayName(p,a,b,c,d)
/*** IOleContainer methods ***/
#define IOleContainer_EnumObjects(p,a,b) (p)->lpVtbl->EnumObjects(p,a,b)
#define IOleContainer_LockContainer(p,a) (p)->lpVtbl->LockContainer(p,a)
#endif

#endif

#define IOleContainer_METHODS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IParseDisplayName methods ***/ \
    STDMETHOD_(HRESULT,ParseDisplayName)(THIS_ IBindCtx* pbc, LPOLESTR pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut) PURE; \
    /*** IOleContainer methods ***/ \
    STDMETHOD_(HRESULT,EnumObjects)(THIS_ DWORD grfFlags, IEnumUnknown** ppenum) PURE; \
    STDMETHOD_(HRESULT,LockContainer)(THIS_ BOOL fLock) PURE;

HRESULT CALLBACK IOleContainer_EnumObjects_Proxy(
    IOleContainer* This,
    DWORD grfFlags,
    IEnumUnknown** ppenum);
void __RPC_STUB IOleContainer_EnumObjects_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleContainer_LockContainer_Proxy(
    IOleContainer* This,
    BOOL fLock);
void __RPC_STUB IOleContainer_LockContainer_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IOleContainer_INTERFACE_DEFINED__ */

#ifndef __IOleItemContainer_FWD_DEFINED__
#define __IOleItemContainer_FWD_DEFINED__
typedef struct IOleItemContainer IOleItemContainer;
#endif

typedef IOleItemContainer *LPOLEITEMCONTAINER;

typedef enum tagBINDSPEED {
    BINDSPEED_INDEFINITE = 1,
    BINDSPEED_MODERATE = 2,
    BINDSPEED_IMMEDIATE = 3
} BINDSPEED;

typedef enum tagOLECONTF {
    OLECONTF_EMBEDDINGS = 1,
    OLECONTF_LINKS = 2,
    OLECONTF_OTHERS = 4,
    OLECONTF_OLNYUSER = 8,
    OLECONTF_ONLYIFRUNNING = 16
} OLECONTF;

#ifdef __WINESRC__
#undef GetObject
#endif
/*****************************************************************************
 * IOleItemContainer interface
 */
#ifndef __IOleItemContainer_INTERFACE_DEFINED__
#define __IOleItemContainer_INTERFACE_DEFINED__

DEFINE_GUID(IID_IOleItemContainer, 0x0000011c, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IOleItemContainer : public IOleContainer
{
    virtual HRESULT STDMETHODCALLTYPE GetObject(
        LPOLESTR pszItem,
        DWORD dwSpeedNeeded,
        IBindCtx* pbc,
        REFIID riid,
        void** ppvObject) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetObjectStorage(
        LPOLESTR pszItem,
        IBindCtx* pbc,
        REFIID riid,
        void** ppvStorage) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsRunning(
        LPOLESTR pszItem) = 0;

};
#else
typedef struct IOleItemContainerVtbl IOleItemContainerVtbl;
struct IOleItemContainer {
    const IOleItemContainerVtbl* lpVtbl;
};
struct IOleItemContainerVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IOleItemContainer* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IOleItemContainer* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IOleItemContainer* This);

    /*** IParseDisplayName methods ***/
    HRESULT (STDMETHODCALLTYPE *ParseDisplayName)(
        IOleItemContainer* This,
        IBindCtx* pbc,
        LPOLESTR pszDisplayName,
        ULONG* pchEaten,
        IMoniker** ppmkOut);

    /*** IOleContainer methods ***/
    HRESULT (STDMETHODCALLTYPE *EnumObjects)(
        IOleItemContainer* This,
        DWORD grfFlags,
        IEnumUnknown** ppenum);

    HRESULT (STDMETHODCALLTYPE *LockContainer)(
        IOleItemContainer* This,
        BOOL fLock);

    /*** IOleItemContainer methods ***/
    HRESULT (STDMETHODCALLTYPE *GetObject)(
        IOleItemContainer* This,
        LPOLESTR pszItem,
        DWORD dwSpeedNeeded,
        IBindCtx* pbc,
        REFIID riid,
        void** ppvObject);

    HRESULT (STDMETHODCALLTYPE *GetObjectStorage)(
        IOleItemContainer* This,
        LPOLESTR pszItem,
        IBindCtx* pbc,
        REFIID riid,
        void** ppvStorage);

    HRESULT (STDMETHODCALLTYPE *IsRunning)(
        IOleItemContainer* This,
        LPOLESTR pszItem);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IOleItemContainer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IOleItemContainer_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IOleItemContainer_Release(p) (p)->lpVtbl->Release(p)
/*** IParseDisplayName methods ***/
#define IOleItemContainer_ParseDisplayName(p,a,b,c,d) (p)->lpVtbl->ParseDisplayName(p,a,b,c,d)
/*** IOleContainer methods ***/
#define IOleItemContainer_EnumObjects(p,a,b) (p)->lpVtbl->EnumObjects(p,a,b)
#define IOleItemContainer_LockContainer(p,a) (p)->lpVtbl->LockContainer(p,a)
/*** IOleItemContainer methods ***/
#define IOleItemContainer_GetObject(p,a,b,c,d,e) (p)->lpVtbl->GetObject(p,a,b,c,d,e)
#define IOleItemContainer_GetObjectStorage(p,a,b,c,d) (p)->lpVtbl->GetObjectStorage(p,a,b,c,d)
#define IOleItemContainer_IsRunning(p,a) (p)->lpVtbl->IsRunning(p,a)
#endif

#endif

#define IOleItemContainer_METHODS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IParseDisplayName methods ***/ \
    STDMETHOD_(HRESULT,ParseDisplayName)(THIS_ IBindCtx* pbc, LPOLESTR pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut) PURE; \
    /*** IOleContainer methods ***/ \
    STDMETHOD_(HRESULT,EnumObjects)(THIS_ DWORD grfFlags, IEnumUnknown** ppenum) PURE; \
    STDMETHOD_(HRESULT,LockContainer)(THIS_ BOOL fLock) PURE; \
    /*** IOleItemContainer methods ***/ \
    STDMETHOD_(HRESULT,GetObject)(THIS_ LPOLESTR pszItem, DWORD dwSpeedNeeded, IBindCtx* pbc, REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(HRESULT,GetObjectStorage)(THIS_ LPOLESTR pszItem, IBindCtx* pbc, REFIID riid, void** ppvStorage) PURE; \
    STDMETHOD_(HRESULT,IsRunning)(THIS_ LPOLESTR pszItem) PURE;

HRESULT CALLBACK IOleItemContainer_GetObject_Proxy(
    IOleItemContainer* This,
    LPOLESTR pszItem,
    DWORD dwSpeedNeeded,
    IBindCtx* pbc,
    REFIID riid,
    void** ppvObject);
void __RPC_STUB IOleItemContainer_GetObject_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleItemContainer_GetObjectStorage_Proxy(
    IOleItemContainer* This,
    LPOLESTR pszItem,
    IBindCtx* pbc,
    REFIID riid,
    void** ppvStorage);
void __RPC_STUB IOleItemContainer_GetObjectStorage_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleItemContainer_IsRunning_Proxy(
    IOleItemContainer* This,
    LPOLESTR pszItem);
void __RPC_STUB IOleItemContainer_IsRunning_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IOleItemContainer_INTERFACE_DEFINED__ */

#ifndef __IOleLink_FWD_DEFINED__
#define __IOleLink_FWD_DEFINED__
typedef struct IOleLink IOleLink;
#endif

typedef IOleLink *LPOLELINK;

typedef enum tagOLEUPDATE {
    OLEUPDATE_ALWAYS = 1,
    OLEUPDATE_ONCALL = 3
} OLEUPDATE, *POLEUPDATE, *LPOLEUPDATE;

typedef enum tagOLELINKBIND {
    OLELINKBIND_EVENIFCLASSDIFF = 1
} OLELINKBIND;

/*****************************************************************************
 * IOleLink interface
 */
#ifndef __IOleLink_INTERFACE_DEFINED__
#define __IOleLink_INTERFACE_DEFINED__

DEFINE_GUID(IID_IOleLink, 0x0000011d, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IOleLink : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE SetUpdateOptions(
        DWORD dwUpdateOpt) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetUpdateOptions(
        DWORD* pdwUpdateOpt) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetSourceMoniker(
        IMoniker* pmk,
        REFCLSID rclsid) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetSourceMoniker(
        IMoniker** ppmk) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetSourceDisplayName(
        LPCOLESTR pszStatusText) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetSourceDisplayName(
        LPOLESTR* ppszDisplayName) = 0;

    virtual HRESULT STDMETHODCALLTYPE BindToSource(
        DWORD bindflags,
        IBindCtx* pbc) = 0;

    virtual HRESULT STDMETHODCALLTYPE BindIfRunning(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetBoundSource(
        IUnknown** ppunk) = 0;

    virtual HRESULT STDMETHODCALLTYPE UnbindSource(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Update(
        IBindCtx* pbc) = 0;

};
#else
typedef struct IOleLinkVtbl IOleLinkVtbl;
struct IOleLink {
    const IOleLinkVtbl* lpVtbl;
};
struct IOleLinkVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IOleLink* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IOleLink* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IOleLink* This);

    /*** IOleLink methods ***/
    HRESULT (STDMETHODCALLTYPE *SetUpdateOptions)(
        IOleLink* This,
        DWORD dwUpdateOpt);

    HRESULT (STDMETHODCALLTYPE *GetUpdateOptions)(
        IOleLink* This,
        DWORD* pdwUpdateOpt);

    HRESULT (STDMETHODCALLTYPE *SetSourceMoniker)(
        IOleLink* This,
        IMoniker* pmk,
        REFCLSID rclsid);

    HRESULT (STDMETHODCALLTYPE *GetSourceMoniker)(
        IOleLink* This,
        IMoniker** ppmk);

    HRESULT (STDMETHODCALLTYPE *SetSourceDisplayName)(
        IOleLink* This,
        LPCOLESTR pszStatusText);

    HRESULT (STDMETHODCALLTYPE *GetSourceDisplayName)(
        IOleLink* This,
        LPOLESTR* ppszDisplayName);

    HRESULT (STDMETHODCALLTYPE *BindToSource)(
        IOleLink* This,
        DWORD bindflags,
        IBindCtx* pbc);

    HRESULT (STDMETHODCALLTYPE *BindIfRunning)(
        IOleLink* This);

    HRESULT (STDMETHODCALLTYPE *GetBoundSource)(
        IOleLink* This,
        IUnknown** ppunk);

    HRESULT (STDMETHODCALLTYPE *UnbindSource)(
        IOleLink* This);

    HRESULT (STDMETHODCALLTYPE *Update)(
        IOleLink* This,
        IBindCtx* pbc);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IOleLink_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IOleLink_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IOleLink_Release(p) (p)->lpVtbl->Release(p)
/*** IOleLink methods ***/
#define IOleLink_SetUpdateOptions(p,a) (p)->lpVtbl->SetUpdateOptions(p,a)
#define IOleLink_GetUpdateOptions(p,a) (p)->lpVtbl->GetUpdateOptions(p,a)
#define IOleLink_SetSourceMoniker(p,a,b) (p)->lpVtbl->SetSourceMoniker(p,a,b)
#define IOleLink_GetSourceMoniker(p,a) (p)->lpVtbl->GetSourceMoniker(p,a)
#define IOleLink_SetSourceDisplayName(p,a) (p)->lpVtbl->SetSourceDisplayName(p,a)
#define IOleLink_GetSourceDisplayName(p,a) (p)->lpVtbl->GetSourceDisplayName(p,a)
#define IOleLink_BindToSource(p,a,b) (p)->lpVtbl->BindToSource(p,a,b)
#define IOleLink_BindIfRunning(p) (p)->lpVtbl->BindIfRunning(p)
#define IOleLink_GetBoundSource(p,a) (p)->lpVtbl->GetBoundSource(p,a)
#define IOleLink_UnbindSource(p) (p)->lpVtbl->UnbindSource(p)
#define IOleLink_Update(p,a) (p)->lpVtbl->Update(p,a)
#endif

#endif

#define IOleLink_METHODS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IOleLink methods ***/ \
    STDMETHOD_(HRESULT,SetUpdateOptions)(THIS_ DWORD dwUpdateOpt) PURE; \
    STDMETHOD_(HRESULT,GetUpdateOptions)(THIS_ DWORD* pdwUpdateOpt) PURE; \
    STDMETHOD_(HRESULT,SetSourceMoniker)(THIS_ IMoniker* pmk, REFCLSID rclsid) PURE; \
    STDMETHOD_(HRESULT,GetSourceMoniker)(THIS_ IMoniker** ppmk) PURE; \
    STDMETHOD_(HRESULT,SetSourceDisplayName)(THIS_ LPCOLESTR pszStatusText) PURE; \
    STDMETHOD_(HRESULT,GetSourceDisplayName)(THIS_ LPOLESTR* ppszDisplayName) PURE; \
    STDMETHOD_(HRESULT,BindToSource)(THIS_ DWORD bindflags, IBindCtx* pbc) PURE; \
    STDMETHOD_(HRESULT,BindIfRunning)(THIS) PURE; \
    STDMETHOD_(HRESULT,GetBoundSource)(THIS_ IUnknown** ppunk) PURE; \
    STDMETHOD_(HRESULT,UnbindSource)(THIS) PURE; \
    STDMETHOD_(HRESULT,Update)(THIS_ IBindCtx* pbc) PURE;

HRESULT CALLBACK IOleLink_SetUpdateOptions_Proxy(
    IOleLink* This,
    DWORD dwUpdateOpt);
void __RPC_STUB IOleLink_SetUpdateOptions_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleLink_GetUpdateOptions_Proxy(
    IOleLink* This,
    DWORD* pdwUpdateOpt);
void __RPC_STUB IOleLink_GetUpdateOptions_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleLink_SetSourceMoniker_Proxy(
    IOleLink* This,
    IMoniker* pmk,
    REFCLSID rclsid);
void __RPC_STUB IOleLink_SetSourceMoniker_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleLink_GetSourceMoniker_Proxy(
    IOleLink* This,
    IMoniker** ppmk);
void __RPC_STUB IOleLink_GetSourceMoniker_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleLink_SetSourceDisplayName_Proxy(
    IOleLink* This,
    LPCOLESTR pszStatusText);
void __RPC_STUB IOleLink_SetSourceDisplayName_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleLink_GetSourceDisplayName_Proxy(
    IOleLink* This,
    LPOLESTR* ppszDisplayName);
void __RPC_STUB IOleLink_GetSourceDisplayName_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleLink_BindToSource_Proxy(
    IOleLink* This,
    DWORD bindflags,
    IBindCtx* pbc);
void __RPC_STUB IOleLink_BindToSource_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleLink_BindIfRunning_Proxy(
    IOleLink* This);
void __RPC_STUB IOleLink_BindIfRunning_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleLink_GetBoundSource_Proxy(
    IOleLink* This,
    IUnknown** ppunk);
void __RPC_STUB IOleLink_GetBoundSource_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleLink_UnbindSource_Proxy(
    IOleLink* This);
void __RPC_STUB IOleLink_UnbindSource_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleLink_Update_Proxy(
    IOleLink* This,
    IBindCtx* pbc);
void __RPC_STUB IOleLink_Update_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IOleLink_INTERFACE_DEFINED__ */

#ifndef __IOleClientSite_FWD_DEFINED__
#define __IOleClientSite_FWD_DEFINED__
typedef struct IOleClientSite IOleClientSite;
#endif

typedef IOleClientSite *LPOLECLIENTSITE;

/*****************************************************************************
 * IOleClientSite interface
 */
#ifndef __IOleClientSite_INTERFACE_DEFINED__
#define __IOleClientSite_INTERFACE_DEFINED__

DEFINE_GUID(IID_IOleClientSite, 0x00000118, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IOleClientSite : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE SaveObject(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMoniker(
        DWORD dwAssign,
        DWORD dwWhichMoniker,
        IMoniker** ppmk) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetContainer(
        IOleContainer** ppContainer) = 0;

    virtual HRESULT STDMETHODCALLTYPE ShowObject(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE OnShowWindow(
        BOOL fShow) = 0;

    virtual HRESULT STDMETHODCALLTYPE RequestNewObjectLayout(
        ) = 0;

};
#else
typedef struct IOleClientSiteVtbl IOleClientSiteVtbl;
struct IOleClientSite {
    const IOleClientSiteVtbl* lpVtbl;
};
struct IOleClientSiteVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IOleClientSite* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IOleClientSite* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IOleClientSite* This);

    /*** IOleClientSite methods ***/
    HRESULT (STDMETHODCALLTYPE *SaveObject)(
        IOleClientSite* This);

    HRESULT (STDMETHODCALLTYPE *GetMoniker)(
        IOleClientSite* This,
        DWORD dwAssign,
        DWORD dwWhichMoniker,
        IMoniker** ppmk);

    HRESULT (STDMETHODCALLTYPE *GetContainer)(
        IOleClientSite* This,
        IOleContainer** ppContainer);

    HRESULT (STDMETHODCALLTYPE *ShowObject)(
        IOleClientSite* This);

    HRESULT (STDMETHODCALLTYPE *OnShowWindow)(
        IOleClientSite* This,
        BOOL fShow);

    HRESULT (STDMETHODCALLTYPE *RequestNewObjectLayout)(
        IOleClientSite* This);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IOleClientSite_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IOleClientSite_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IOleClientSite_Release(p) (p)->lpVtbl->Release(p)
/*** IOleClientSite methods ***/
#define IOleClientSite_SaveObject(p) (p)->lpVtbl->SaveObject(p)
#define IOleClientSite_GetMoniker(p,a,b,c) (p)->lpVtbl->GetMoniker(p,a,b,c)
#define IOleClientSite_GetContainer(p,a) (p)->lpVtbl->GetContainer(p,a)
#define IOleClientSite_ShowObject(p) (p)->lpVtbl->ShowObject(p)
#define IOleClientSite_OnShowWindow(p,a) (p)->lpVtbl->OnShowWindow(p,a)
#define IOleClientSite_RequestNewObjectLayout(p) (p)->lpVtbl->RequestNewObjectLayout(p)
#endif

#endif

#define IOleClientSite_METHODS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IOleClientSite methods ***/ \
    STDMETHOD_(HRESULT,SaveObject)(THIS) PURE; \
    STDMETHOD_(HRESULT,GetMoniker)(THIS_ DWORD dwAssign, DWORD dwWhichMoniker, IMoniker** ppmk) PURE; \
    STDMETHOD_(HRESULT,GetContainer)(THIS_ IOleContainer** ppContainer) PURE; \
    STDMETHOD_(HRESULT,ShowObject)(THIS) PURE; \
    STDMETHOD_(HRESULT,OnShowWindow)(THIS_ BOOL fShow) PURE; \
    STDMETHOD_(HRESULT,RequestNewObjectLayout)(THIS) PURE;

HRESULT CALLBACK IOleClientSite_SaveObject_Proxy(
    IOleClientSite* This);
void __RPC_STUB IOleClientSite_SaveObject_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleClientSite_GetMoniker_Proxy(
    IOleClientSite* This,
    DWORD dwAssign,
    DWORD dwWhichMoniker,
    IMoniker** ppmk);
void __RPC_STUB IOleClientSite_GetMoniker_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleClientSite_GetContainer_Proxy(
    IOleClientSite* This,
    IOleContainer** ppContainer);
void __RPC_STUB IOleClientSite_GetContainer_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleClientSite_ShowObject_Proxy(
    IOleClientSite* This);
void __RPC_STUB IOleClientSite_ShowObject_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleClientSite_OnShowWindow_Proxy(
    IOleClientSite* This,
    BOOL fShow);
void __RPC_STUB IOleClientSite_OnShowWindow_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleClientSite_RequestNewObjectLayout_Proxy(
    IOleClientSite* This);
void __RPC_STUB IOleClientSite_RequestNewObjectLayout_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IOleClientSite_INTERFACE_DEFINED__ */

#ifndef __IOleCache_FWD_DEFINED__
#define __IOleCache_FWD_DEFINED__
typedef struct IOleCache IOleCache;
#endif

typedef IOleCache *LPOLECACHE;

/*****************************************************************************
 * IOleCache interface
 */
#ifndef __IOleCache_INTERFACE_DEFINED__
#define __IOleCache_INTERFACE_DEFINED__

DEFINE_GUID(IID_IOleCache, 0x0000011e, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IOleCache : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Cache(
        FORMATETC* pformatetc,
        DWORD advf,
        DWORD* pdwConnection) = 0;

    virtual HRESULT STDMETHODCALLTYPE Uncache(
        DWORD dwConnection) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnumCache(
        IEnumSTATDATA** ppenumSTATDATA) = 0;

    virtual HRESULT STDMETHODCALLTYPE InitCache(
        IDataObject* pDataObject) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetData(
        FORMATETC* pformatetc,
        STGMEDIUM* pmedium,
        BOOL fRelease) = 0;

};
#else
typedef struct IOleCacheVtbl IOleCacheVtbl;
struct IOleCache {
    const IOleCacheVtbl* lpVtbl;
};
struct IOleCacheVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IOleCache* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IOleCache* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IOleCache* This);

    /*** IOleCache methods ***/
    HRESULT (STDMETHODCALLTYPE *Cache)(
        IOleCache* This,
        FORMATETC* pformatetc,
        DWORD advf,
        DWORD* pdwConnection);

    HRESULT (STDMETHODCALLTYPE *Uncache)(
        IOleCache* This,
        DWORD dwConnection);

    HRESULT (STDMETHODCALLTYPE *EnumCache)(
        IOleCache* This,
        IEnumSTATDATA** ppenumSTATDATA);

    HRESULT (STDMETHODCALLTYPE *InitCache)(
        IOleCache* This,
        IDataObject* pDataObject);

    HRESULT (STDMETHODCALLTYPE *SetData)(
        IOleCache* This,
        FORMATETC* pformatetc,
        STGMEDIUM* pmedium,
        BOOL fRelease);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IOleCache_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IOleCache_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IOleCache_Release(p) (p)->lpVtbl->Release(p)
/*** IOleCache methods ***/
#define IOleCache_Cache(p,a,b,c) (p)->lpVtbl->Cache(p,a,b,c)
#define IOleCache_Uncache(p,a) (p)->lpVtbl->Uncache(p,a)
#define IOleCache_EnumCache(p,a) (p)->lpVtbl->EnumCache(p,a)
#define IOleCache_InitCache(p,a) (p)->lpVtbl->InitCache(p,a)
#define IOleCache_SetData(p,a,b,c) (p)->lpVtbl->SetData(p,a,b,c)
#endif

#endif

#define IOleCache_METHODS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IOleCache methods ***/ \
    STDMETHOD_(HRESULT,Cache)(THIS_ FORMATETC* pformatetc, DWORD advf, DWORD* pdwConnection) PURE; \
    STDMETHOD_(HRESULT,Uncache)(THIS_ DWORD dwConnection) PURE; \
    STDMETHOD_(HRESULT,EnumCache)(THIS_ IEnumSTATDATA** ppenumSTATDATA) PURE; \
    STDMETHOD_(HRESULT,InitCache)(THIS_ IDataObject* pDataObject) PURE; \
    STDMETHOD_(HRESULT,SetData)(THIS_ FORMATETC* pformatetc, STGMEDIUM* pmedium, BOOL fRelease) PURE;

HRESULT CALLBACK IOleCache_Cache_Proxy(
    IOleCache* This,
    FORMATETC* pformatetc,
    DWORD advf,
    DWORD* pdwConnection);
void __RPC_STUB IOleCache_Cache_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleCache_Uncache_Proxy(
    IOleCache* This,
    DWORD dwConnection);
void __RPC_STUB IOleCache_Uncache_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleCache_EnumCache_Proxy(
    IOleCache* This,
    IEnumSTATDATA** ppenumSTATDATA);
void __RPC_STUB IOleCache_EnumCache_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleCache_InitCache_Proxy(
    IOleCache* This,
    IDataObject* pDataObject);
void __RPC_STUB IOleCache_InitCache_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleCache_SetData_Proxy(
    IOleCache* This,
    FORMATETC* pformatetc,
    STGMEDIUM* pmedium,
    BOOL fRelease);
void __RPC_STUB IOleCache_SetData_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IOleCache_INTERFACE_DEFINED__ */

#ifndef __IOleCache2_FWD_DEFINED__
#define __IOleCache2_FWD_DEFINED__
typedef struct IOleCache2 IOleCache2;
#endif

typedef IOleCache2 *LPOLECACHE2;

#define UPDFCACHE_NODATACACHE (0x1)

#define UPDFCACHE_ONSAVECACHE (0x2)

#define UPDFCACHE_ONSTOPCACHE (0x4)

#define UPDFCACHE_NORMALCACHE (0x8)

#define UPDFCACHE_IFBLANK (0x10)

#define UPDFCACHE_ONLYIFBLANK (0x80000000)

#define UPDFCACHE_IFBLANKORONSAVECACHE (UPDFCACHE_IFBLANK | UPDFCACHE_ONSAVECACHE)

#define UPDFCACHE_ALL ((DWORD)~UPDFCACHE_ONLYIFBLANK)

#define UPDFCACHE_ALLBUTNODATACACHE (UPDFCACHE_ALL & (DWORD)~UPDFCACHE_NODATACACHE)

typedef enum tagDISCARDCACHE {
    DISCARDCACHE_SAVEIFDIRTY = 0,
    DISCARDCACHE_NOSAVE = 1
} DISCARDCACHE;

/*****************************************************************************
 * IOleCache2 interface
 */
#ifndef __IOleCache2_INTERFACE_DEFINED__
#define __IOleCache2_INTERFACE_DEFINED__

DEFINE_GUID(IID_IOleCache2, 0x00000128, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IOleCache2 : public IOleCache
{
    virtual HRESULT STDMETHODCALLTYPE UpdateCache(
        LPDATAOBJECT pDataObject,
        DWORD grfUpdf,
        LPVOID pReserved) = 0;

    virtual HRESULT STDMETHODCALLTYPE DiscardCache(
        DWORD dwDiscardOptions) = 0;

};
#else
typedef struct IOleCache2Vtbl IOleCache2Vtbl;
struct IOleCache2 {
    const IOleCache2Vtbl* lpVtbl;
};
struct IOleCache2Vtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IOleCache2* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IOleCache2* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IOleCache2* This);

    /*** IOleCache methods ***/
    HRESULT (STDMETHODCALLTYPE *Cache)(
        IOleCache2* This,
        FORMATETC* pformatetc,
        DWORD advf,
        DWORD* pdwConnection);

    HRESULT (STDMETHODCALLTYPE *Uncache)(
        IOleCache2* This,
        DWORD dwConnection);

    HRESULT (STDMETHODCALLTYPE *EnumCache)(
        IOleCache2* This,
        IEnumSTATDATA** ppenumSTATDATA);

    HRESULT (STDMETHODCALLTYPE *InitCache)(
        IOleCache2* This,
        IDataObject* pDataObject);

    HRESULT (STDMETHODCALLTYPE *SetData)(
        IOleCache2* This,
        FORMATETC* pformatetc,
        STGMEDIUM* pmedium,
        BOOL fRelease);

    /*** IOleCache2 methods ***/
    HRESULT (STDMETHODCALLTYPE *UpdateCache)(
        IOleCache2* This,
        LPDATAOBJECT pDataObject,
        DWORD grfUpdf,
        LPVOID pReserved);

    HRESULT (STDMETHODCALLTYPE *DiscardCache)(
        IOleCache2* This,
        DWORD dwDiscardOptions);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IOleCache2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IOleCache2_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IOleCache2_Release(p) (p)->lpVtbl->Release(p)
/*** IOleCache methods ***/
#define IOleCache2_Cache(p,a,b,c) (p)->lpVtbl->Cache(p,a,b,c)
#define IOleCache2_Uncache(p,a) (p)->lpVtbl->Uncache(p,a)
#define IOleCache2_EnumCache(p,a) (p)->lpVtbl->EnumCache(p,a)
#define IOleCache2_InitCache(p,a) (p)->lpVtbl->InitCache(p,a)
#define IOleCache2_SetData(p,a,b,c) (p)->lpVtbl->SetData(p,a,b,c)
/*** IOleCache2 methods ***/
#define IOleCache2_UpdateCache(p,a,b,c) (p)->lpVtbl->UpdateCache(p,a,b,c)
#define IOleCache2_DiscardCache(p,a) (p)->lpVtbl->DiscardCache(p,a)
#endif

#endif

#define IOleCache2_METHODS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IOleCache methods ***/ \
    STDMETHOD_(HRESULT,Cache)(THIS_ FORMATETC* pformatetc, DWORD advf, DWORD* pdwConnection) PURE; \
    STDMETHOD_(HRESULT,Uncache)(THIS_ DWORD dwConnection) PURE; \
    STDMETHOD_(HRESULT,EnumCache)(THIS_ IEnumSTATDATA** ppenumSTATDATA) PURE; \
    STDMETHOD_(HRESULT,InitCache)(THIS_ IDataObject* pDataObject) PURE; \
    STDMETHOD_(HRESULT,SetData)(THIS_ FORMATETC* pformatetc, STGMEDIUM* pmedium, BOOL fRelease) PURE; \
    /*** IOleCache2 methods ***/ \
    STDMETHOD_(HRESULT,UpdateCache)(THIS_ LPDATAOBJECT pDataObject, DWORD grfUpdf, LPVOID pReserved) PURE; \
    STDMETHOD_(HRESULT,DiscardCache)(THIS_ DWORD dwDiscardOptions) PURE;

HRESULT CALLBACK IOleCache2_RemoteUpdateCache_Proxy(
    IOleCache2* This,
    LPDATAOBJECT pDataObject,
    DWORD grfUpdf,
    LONG_PTR pReserved);
void __RPC_STUB IOleCache2_RemoteUpdateCache_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleCache2_UpdateCache_Proxy(
    IOleCache2* This,
    LPDATAOBJECT pDataObject,
    DWORD grfUpdf,
    LPVOID pReserved);
HRESULT __RPC_STUB IOleCache2_UpdateCache_Stub(
    IOleCache2* This,
    LPDATAOBJECT pDataObject,
    DWORD grfUpdf,
    LONG_PTR pReserved);
HRESULT CALLBACK IOleCache2_DiscardCache_Proxy(
    IOleCache2* This,
    DWORD dwDiscardOptions);
void __RPC_STUB IOleCache2_DiscardCache_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IOleCache2_INTERFACE_DEFINED__ */

#ifndef __IOleCacheControl_FWD_DEFINED__
#define __IOleCacheControl_FWD_DEFINED__
typedef struct IOleCacheControl IOleCacheControl;
#endif

typedef IOleCacheControl *LPOLECACHECONTROL;

/*****************************************************************************
 * IOleCacheControl interface
 */
#ifndef __IOleCacheControl_INTERFACE_DEFINED__
#define __IOleCacheControl_INTERFACE_DEFINED__

DEFINE_GUID(IID_IOleCacheControl, 0x00000129, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IOleCacheControl : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE OnRun(
        LPDATAOBJECT pDataObject) = 0;

    virtual HRESULT STDMETHODCALLTYPE OnStop(
        ) = 0;

};
#else
typedef struct IOleCacheControlVtbl IOleCacheControlVtbl;
struct IOleCacheControl {
    const IOleCacheControlVtbl* lpVtbl;
};
struct IOleCacheControlVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IOleCacheControl* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IOleCacheControl* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IOleCacheControl* This);

    /*** IOleCacheControl methods ***/
    HRESULT (STDMETHODCALLTYPE *OnRun)(
        IOleCacheControl* This,
        LPDATAOBJECT pDataObject);

    HRESULT (STDMETHODCALLTYPE *OnStop)(
        IOleCacheControl* This);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IOleCacheControl_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IOleCacheControl_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IOleCacheControl_Release(p) (p)->lpVtbl->Release(p)
/*** IOleCacheControl methods ***/
#define IOleCacheControl_OnRun(p,a) (p)->lpVtbl->OnRun(p,a)
#define IOleCacheControl_OnStop(p) (p)->lpVtbl->OnStop(p)
#endif

#endif

#define IOleCacheControl_METHODS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IOleCacheControl methods ***/ \
    STDMETHOD_(HRESULT,OnRun)(THIS_ LPDATAOBJECT pDataObject) PURE; \
    STDMETHOD_(HRESULT,OnStop)(THIS) PURE;

HRESULT CALLBACK IOleCacheControl_OnRun_Proxy(
    IOleCacheControl* This,
    LPDATAOBJECT pDataObject);
void __RPC_STUB IOleCacheControl_OnRun_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleCacheControl_OnStop_Proxy(
    IOleCacheControl* This);
void __RPC_STUB IOleCacheControl_OnStop_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IOleCacheControl_INTERFACE_DEFINED__ */

#ifndef __IEnumOLEVERB_FWD_DEFINED__
#define __IEnumOLEVERB_FWD_DEFINED__
typedef struct IEnumOLEVERB IEnumOLEVERB;
#endif

typedef IEnumOLEVERB *LPENUMOLEVERB;

typedef struct tagOLEVERB {
    LONG lVerb;
    LPOLESTR lpszVerbName;
    DWORD fuFlags;
    DWORD grfAttribs;
} OLEVERB, *LPOLEVERB;

typedef enum tagOLEVERBATTRIB {
    OLEVERBATTRIB_NEVERDIRTIES = 1,
    OLEVERBATTRIB_ONCONTAINERMENU = 2
} OLEVERBATTRIB;

/*****************************************************************************
 * IEnumOLEVERB interface
 */
#ifndef __IEnumOLEVERB_INTERFACE_DEFINED__
#define __IEnumOLEVERB_INTERFACE_DEFINED__

DEFINE_GUID(IID_IEnumOLEVERB, 0x00000104, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IEnumOLEVERB : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Next(
        ULONG celt,
        LPOLEVERB rgelt,
        ULONG* pceltFetched) = 0;

    virtual HRESULT STDMETHODCALLTYPE Skip(
        ULONG celt) = 0;

    virtual HRESULT STDMETHODCALLTYPE Reset(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Clone(
        IEnumOLEVERB** ppenum) = 0;

};
#else
typedef struct IEnumOLEVERBVtbl IEnumOLEVERBVtbl;
struct IEnumOLEVERB {
    const IEnumOLEVERBVtbl* lpVtbl;
};
struct IEnumOLEVERBVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IEnumOLEVERB* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IEnumOLEVERB* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IEnumOLEVERB* This);

    /*** IEnumOLEVERB methods ***/
    HRESULT (STDMETHODCALLTYPE *Next)(
        IEnumOLEVERB* This,
        ULONG celt,
        LPOLEVERB rgelt,
        ULONG* pceltFetched);

    HRESULT (STDMETHODCALLTYPE *Skip)(
        IEnumOLEVERB* This,
        ULONG celt);

    HRESULT (STDMETHODCALLTYPE *Reset)(
        IEnumOLEVERB* This);

    HRESULT (STDMETHODCALLTYPE *Clone)(
        IEnumOLEVERB* This,
        IEnumOLEVERB** ppenum);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IEnumOLEVERB_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IEnumOLEVERB_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IEnumOLEVERB_Release(p) (p)->lpVtbl->Release(p)
/*** IEnumOLEVERB methods ***/
#define IEnumOLEVERB_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
#define IEnumOLEVERB_Skip(p,a) (p)->lpVtbl->Skip(p,a)
#define IEnumOLEVERB_Reset(p) (p)->lpVtbl->Reset(p)
#define IEnumOLEVERB_Clone(p,a) (p)->lpVtbl->Clone(p,a)
#endif

#endif

#define IEnumOLEVERB_METHODS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IEnumOLEVERB methods ***/ \
    STDMETHOD_(HRESULT,Next)(THIS_ ULONG celt, LPOLEVERB rgelt, ULONG* pceltFetched) PURE; \
    STDMETHOD_(HRESULT,Skip)(THIS_ ULONG celt) PURE; \
    STDMETHOD_(HRESULT,Reset)(THIS) PURE; \
    STDMETHOD_(HRESULT,Clone)(THIS_ IEnumOLEVERB** ppenum) PURE;

HRESULT CALLBACK IEnumOLEVERB_RemoteNext_Proxy(
    IEnumOLEVERB* This,
    ULONG celt,
    LPOLEVERB rgelt,
    ULONG* pceltFetched);
void __RPC_STUB IEnumOLEVERB_RemoteNext_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumOLEVERB_Next_Proxy(
    IEnumOLEVERB* This,
    ULONG celt,
    LPOLEVERB rgelt,
    ULONG* pceltFetched);
HRESULT __RPC_STUB IEnumOLEVERB_Next_Stub(
    IEnumOLEVERB* This,
    ULONG celt,
    LPOLEVERB rgelt,
    ULONG* pceltFetched);
HRESULT CALLBACK IEnumOLEVERB_Skip_Proxy(
    IEnumOLEVERB* This,
    ULONG celt);
void __RPC_STUB IEnumOLEVERB_Skip_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumOLEVERB_Reset_Proxy(
    IEnumOLEVERB* This);
void __RPC_STUB IEnumOLEVERB_Reset_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumOLEVERB_Clone_Proxy(
    IEnumOLEVERB* This,
    IEnumOLEVERB** ppenum);
void __RPC_STUB IEnumOLEVERB_Clone_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IEnumOLEVERB_INTERFACE_DEFINED__ */

#ifndef __IOleObject_FWD_DEFINED__
#define __IOleObject_FWD_DEFINED__
typedef struct IOleObject IOleObject;
#endif

typedef IOleObject *LPOLEOBJECT;

typedef enum tagOLEGETMONIKER {
    OLEGETMONIKER_ONLYIFTHERE = 1,
    OLEGETMONIKER_FORCEASSIGN = 2,
    OLEGETMONIKER_UNASSIGN = 3,
    OLEGETMONIKER_TEMPFORUSER = 4
} OLEGETMONIKER;

typedef enum tagOLEWHICHMK {
    OLEWHICHMK_CONTAINER = 1,
    OLEWHICHMK_OBJREL = 2,
    OLEWHICHMK_OBJFULL = 3
} OLEWHICHMK;

typedef enum tagUSERCLASSTYPE {
    USERCLASSTYPE_FULL = 1,
    USERCLASSTYPE_SHORT = 2,
    USERCLASSTYPE_APPNAME = 3
} USERCLASSTYPE;

typedef enum tagOLEMISC {
    OLEMISC_RECOMPOSEONRESIZE = 0x1,
    OLEMISC_ONLYICONIC = 0x2,
    OLEMISC_INSERTNOTREPLACE = 0x4,
    OLEMISC_STATIC = 0x8,
    OLEMISC_CANTLINKINSIDE = 0x10,
    OLEMISC_CANLINKBYOLE1 = 0x20,
    OLEMISC_ISLINKOBJECT = 0x40,
    OLEMISC_INSIDEOUT = 0x80,
    OLEMISC_ACTIVATEWHENVISIBLE = 0x100,
    OLEMISC_RENDERINGISDEVICEINDEPENDENT = 0x200,
    OLEMISC_INVISIBLEATRUNTIME = 0x400,
    OLEMISC_ALWAYSRUN = 0x800,
    OLEMISC_ACTSLIKEBUTTON = 0x1000,
    OLEMISC_ACTSLIKELABEL = 0x2000,
    OLEMISC_NOUIACTIVATE = 0x4000,
    OLEMISC_ALIGNABLE = 0x8000,
    OLEMISC_SIMPLEFRAME = 0x10000,
    OLEMISC_SETCLIENTSITEFIRST = 0x20000,
    OLEMISC_IMEMODE = 0x40000,
    OLEMISC_IGNOREACTIVATEWHENVISIBLE = 0x80000,
    OLEMISC_WANTSTOMENUMERGE = 0x100000,
    OLEMISC_SUPPORTSMULTILEVELUNDO = 0x200000
} OLEMISC;

typedef enum tagOLECLOSE {
    OLECLOSE_SAVEIFDIRTY = 0,
    OLECLOSE_NOSAVE = 1,
    OLECLOSE_PROMPTSAVE = 2
} OLECLOSE;

/*****************************************************************************
 * IOleObject interface
 */
#ifndef __IOleObject_INTERFACE_DEFINED__
#define __IOleObject_INTERFACE_DEFINED__

DEFINE_GUID(IID_IOleObject, 0x00000112, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IOleObject : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE SetClientSite(
        IOleClientSite* pClientSite) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetClientSite(
        IOleClientSite** ppClientSite) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetHostNames(
        LPCOLESTR szContainerApp,
        LPCOLESTR szContainerObj) = 0;

    virtual HRESULT STDMETHODCALLTYPE Close(
        DWORD dwSaveOption) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetMoniker(
        DWORD dwWhichMoniker,
        IMoniker* pmk) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMoniker(
        DWORD dwAssign,
        DWORD dwWhichMoniker,
        IMoniker** ppmk) = 0;

    virtual HRESULT STDMETHODCALLTYPE InitFromData(
        IDataObject* pDataObject,
        BOOL fCreation,
        DWORD dwReserved) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetClipboardData(
        DWORD dwReserved,
        IDataObject** ppDataObject) = 0;

    virtual HRESULT STDMETHODCALLTYPE DoVerb(
        LONG iVerb,
        LPMSG lpmsg,
        IOleClientSite* pActiveSite,
        LONG lindex,
        HWND hwndParent,
        LPCRECT lprcPosRect) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnumVerbs(
        IEnumOLEVERB** ppEnumOleVerb) = 0;

    virtual HRESULT STDMETHODCALLTYPE Update(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsUpToDate(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetUserClassID(
        CLSID* pClsid) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetUserType(
        DWORD dwFormOfType,
        LPOLESTR* pszUserType) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetExtent(
        DWORD dwDrawAspect,
        SIZEL* psizel) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetExtent(
        DWORD dwDrawAspect,
        SIZEL* psizel) = 0;

    virtual HRESULT STDMETHODCALLTYPE Advise(
        IAdviseSink* pAdvSink,
        DWORD* pdwConnection) = 0;

    virtual HRESULT STDMETHODCALLTYPE Unadvise(
        DWORD dwConnection) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnumAdvise(
        IEnumSTATDATA** ppenumAdvise) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMiscStatus(
        DWORD dwAspect,
        DWORD* pdwStatus) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetColorScheme(
        LOGPALETTE* pLogpal) = 0;

};
#else
typedef struct IOleObjectVtbl IOleObjectVtbl;
struct IOleObject {
    const IOleObjectVtbl* lpVtbl;
};
struct IOleObjectVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IOleObject* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IOleObject* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IOleObject* This);

    /*** IOleObject methods ***/
    HRESULT (STDMETHODCALLTYPE *SetClientSite)(
        IOleObject* This,
        IOleClientSite* pClientSite);

    HRESULT (STDMETHODCALLTYPE *GetClientSite)(
        IOleObject* This,
        IOleClientSite** ppClientSite);

    HRESULT (STDMETHODCALLTYPE *SetHostNames)(
        IOleObject* This,
        LPCOLESTR szContainerApp,
        LPCOLESTR szContainerObj);

    HRESULT (STDMETHODCALLTYPE *Close)(
        IOleObject* This,
        DWORD dwSaveOption);

    HRESULT (STDMETHODCALLTYPE *SetMoniker)(
        IOleObject* This,
        DWORD dwWhichMoniker,
        IMoniker* pmk);

    HRESULT (STDMETHODCALLTYPE *GetMoniker)(
        IOleObject* This,
        DWORD dwAssign,
        DWORD dwWhichMoniker,
        IMoniker** ppmk);

    HRESULT (STDMETHODCALLTYPE *InitFromData)(
        IOleObject* This,
        IDataObject* pDataObject,
        BOOL fCreation,
        DWORD dwReserved);

    HRESULT (STDMETHODCALLTYPE *GetClipboardData)(
        IOleObject* This,
        DWORD dwReserved,
        IDataObject** ppDataObject);

    HRESULT (STDMETHODCALLTYPE *DoVerb)(
        IOleObject* This,
        LONG iVerb,
        LPMSG lpmsg,
        IOleClientSite* pActiveSite,
        LONG lindex,
        HWND hwndParent,
        LPCRECT lprcPosRect);

    HRESULT (STDMETHODCALLTYPE *EnumVerbs)(
        IOleObject* This,
        IEnumOLEVERB** ppEnumOleVerb);

    HRESULT (STDMETHODCALLTYPE *Update)(
        IOleObject* This);

    HRESULT (STDMETHODCALLTYPE *IsUpToDate)(
        IOleObject* This);

    HRESULT (STDMETHODCALLTYPE *GetUserClassID)(
        IOleObject* This,
        CLSID* pClsid);

    HRESULT (STDMETHODCALLTYPE *GetUserType)(
        IOleObject* This,
        DWORD dwFormOfType,
        LPOLESTR* pszUserType);

    HRESULT (STDMETHODCALLTYPE *SetExtent)(
        IOleObject* This,
        DWORD dwDrawAspect,
        SIZEL* psizel);

    HRESULT (STDMETHODCALLTYPE *GetExtent)(
        IOleObject* This,
        DWORD dwDrawAspect,
        SIZEL* psizel);

    HRESULT (STDMETHODCALLTYPE *Advise)(
        IOleObject* This,
        IAdviseSink* pAdvSink,
        DWORD* pdwConnection);

    HRESULT (STDMETHODCALLTYPE *Unadvise)(
        IOleObject* This,
        DWORD dwConnection);

    HRESULT (STDMETHODCALLTYPE *EnumAdvise)(
        IOleObject* This,
        IEnumSTATDATA** ppenumAdvise);

    HRESULT (STDMETHODCALLTYPE *GetMiscStatus)(
        IOleObject* This,
        DWORD dwAspect,
        DWORD* pdwStatus);

    HRESULT (STDMETHODCALLTYPE *SetColorScheme)(
        IOleObject* This,
        LOGPALETTE* pLogpal);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IOleObject_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IOleObject_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IOleObject_Release(p) (p)->lpVtbl->Release(p)
/*** IOleObject methods ***/
#define IOleObject_SetClientSite(p,a) (p)->lpVtbl->SetClientSite(p,a)
#define IOleObject_GetClientSite(p,a) (p)->lpVtbl->GetClientSite(p,a)
#define IOleObject_SetHostNames(p,a,b) (p)->lpVtbl->SetHostNames(p,a,b)
#define IOleObject_Close(p,a) (p)->lpVtbl->Close(p,a)
#define IOleObject_SetMoniker(p,a,b) (p)->lpVtbl->SetMoniker(p,a,b)
#define IOleObject_GetMoniker(p,a,b,c) (p)->lpVtbl->GetMoniker(p,a,b,c)
#define IOleObject_InitFromData(p,a,b,c) (p)->lpVtbl->InitFromData(p,a,b,c)
#define IOleObject_GetClipboardData(p,a,b) (p)->lpVtbl->GetClipboardData(p,a,b)
#define IOleObject_DoVerb(p,a,b,c,d,e,f) (p)->lpVtbl->DoVerb(p,a,b,c,d,e,f)
#define IOleObject_EnumVerbs(p,a) (p)->lpVtbl->EnumVerbs(p,a)
#define IOleObject_Update(p) (p)->lpVtbl->Update(p)
#define IOleObject_IsUpToDate(p) (p)->lpVtbl->IsUpToDate(p)
#define IOleObject_GetUserClassID(p,a) (p)->lpVtbl->GetUserClassID(p,a)
#define IOleObject_GetUserType(p,a,b) (p)->lpVtbl->GetUserType(p,a,b)
#define IOleObject_SetExtent(p,a,b) (p)->lpVtbl->SetExtent(p,a,b)
#define IOleObject_GetExtent(p,a,b) (p)->lpVtbl->GetExtent(p,a,b)
#define IOleObject_Advise(p,a,b) (p)->lpVtbl->Advise(p,a,b)
#define IOleObject_Unadvise(p,a) (p)->lpVtbl->Unadvise(p,a)
#define IOleObject_EnumAdvise(p,a) (p)->lpVtbl->EnumAdvise(p,a)
#define IOleObject_GetMiscStatus(p,a,b) (p)->lpVtbl->GetMiscStatus(p,a,b)
#define IOleObject_SetColorScheme(p,a) (p)->lpVtbl->SetColorScheme(p,a)
#endif

#endif

#define IOleObject_METHODS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IOleObject methods ***/ \
    STDMETHOD_(HRESULT,SetClientSite)(THIS_ IOleClientSite* pClientSite) PURE; \
    STDMETHOD_(HRESULT,GetClientSite)(THIS_ IOleClientSite** ppClientSite) PURE; \
    STDMETHOD_(HRESULT,SetHostNames)(THIS_ LPCOLESTR szContainerApp, LPCOLESTR szContainerObj) PURE; \
    STDMETHOD_(HRESULT,Close)(THIS_ DWORD dwSaveOption) PURE; \
    STDMETHOD_(HRESULT,SetMoniker)(THIS_ DWORD dwWhichMoniker, IMoniker* pmk) PURE; \
    STDMETHOD_(HRESULT,GetMoniker)(THIS_ DWORD dwAssign, DWORD dwWhichMoniker, IMoniker** ppmk) PURE; \
    STDMETHOD_(HRESULT,InitFromData)(THIS_ IDataObject* pDataObject, BOOL fCreation, DWORD dwReserved) PURE; \
    STDMETHOD_(HRESULT,GetClipboardData)(THIS_ DWORD dwReserved, IDataObject** ppDataObject) PURE; \
    STDMETHOD_(HRESULT,DoVerb)(THIS_ LONG iVerb, LPMSG lpmsg, IOleClientSite* pActiveSite, LONG lindex, HWND hwndParent, LPCRECT lprcPosRect) PURE; \
    STDMETHOD_(HRESULT,EnumVerbs)(THIS_ IEnumOLEVERB** ppEnumOleVerb) PURE; \
    STDMETHOD_(HRESULT,Update)(THIS) PURE; \
    STDMETHOD_(HRESULT,IsUpToDate)(THIS) PURE; \
    STDMETHOD_(HRESULT,GetUserClassID)(THIS_ CLSID* pClsid) PURE; \
    STDMETHOD_(HRESULT,GetUserType)(THIS_ DWORD dwFormOfType, LPOLESTR* pszUserType) PURE; \
    STDMETHOD_(HRESULT,SetExtent)(THIS_ DWORD dwDrawAspect, SIZEL* psizel) PURE; \
    STDMETHOD_(HRESULT,GetExtent)(THIS_ DWORD dwDrawAspect, SIZEL* psizel) PURE; \
    STDMETHOD_(HRESULT,Advise)(THIS_ IAdviseSink* pAdvSink, DWORD* pdwConnection) PURE; \
    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_ LOGPALETTE* pLogpal) PURE;

HRESULT CALLBACK IOleObject_SetClientSite_Proxy(
    IOleObject* This,
    IOleClientSite* pClientSite);
void __RPC_STUB IOleObject_SetClientSite_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_GetClientSite_Proxy(
    IOleObject* This,
    IOleClientSite** ppClientSite);
void __RPC_STUB IOleObject_GetClientSite_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_SetHostNames_Proxy(
    IOleObject* This,
    LPCOLESTR szContainerApp,
    LPCOLESTR szContainerObj);
void __RPC_STUB IOleObject_SetHostNames_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_Close_Proxy(
    IOleObject* This,
    DWORD dwSaveOption);
void __RPC_STUB IOleObject_Close_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_SetMoniker_Proxy(
    IOleObject* This,
    DWORD dwWhichMoniker,
    IMoniker* pmk);
void __RPC_STUB IOleObject_SetMoniker_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_GetMoniker_Proxy(
    IOleObject* This,
    DWORD dwAssign,
    DWORD dwWhichMoniker,
    IMoniker** ppmk);
void __RPC_STUB IOleObject_GetMoniker_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_InitFromData_Proxy(
    IOleObject* This,
    IDataObject* pDataObject,
    BOOL fCreation,
    DWORD dwReserved);
void __RPC_STUB IOleObject_InitFromData_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_GetClipboardData_Proxy(
    IOleObject* This,
    DWORD dwReserved,
    IDataObject** ppDataObject);
void __RPC_STUB IOleObject_GetClipboardData_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_DoVerb_Proxy(
    IOleObject* This,
    LONG iVerb,
    LPMSG lpmsg,
    IOleClientSite* pActiveSite,
    LONG lindex,
    HWND hwndParent,
    LPCRECT lprcPosRect);
void __RPC_STUB IOleObject_DoVerb_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_EnumVerbs_Proxy(
    IOleObject* This,
    IEnumOLEVERB** ppEnumOleVerb);
void __RPC_STUB IOleObject_EnumVerbs_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_Update_Proxy(
    IOleObject* This);
void __RPC_STUB IOleObject_Update_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_IsUpToDate_Proxy(
    IOleObject* This);
void __RPC_STUB IOleObject_IsUpToDate_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_GetUserClassID_Proxy(
    IOleObject* This,
    CLSID* pClsid);
void __RPC_STUB IOleObject_GetUserClassID_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_GetUserType_Proxy(
    IOleObject* This,
    DWORD dwFormOfType,
    LPOLESTR* pszUserType);
void __RPC_STUB IOleObject_GetUserType_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_SetExtent_Proxy(
    IOleObject* This,
    DWORD dwDrawAspect,
    SIZEL* psizel);
void __RPC_STUB IOleObject_SetExtent_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_GetExtent_Proxy(
    IOleObject* This,
    DWORD dwDrawAspect,
    SIZEL* psizel);
void __RPC_STUB IOleObject_GetExtent_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_Advise_Proxy(
    IOleObject* This,
    IAdviseSink* pAdvSink,
    DWORD* pdwConnection);
void __RPC_STUB IOleObject_Advise_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_Unadvise_Proxy(
    IOleObject* This,
    DWORD dwConnection);
void __RPC_STUB IOleObject_Unadvise_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_EnumAdvise_Proxy(
    IOleObject* This,
    IEnumSTATDATA** ppenumAdvise);
void __RPC_STUB IOleObject_EnumAdvise_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_GetMiscStatus_Proxy(
    IOleObject* This,
    DWORD dwAspect,
    DWORD* pdwStatus);
void __RPC_STUB IOleObject_GetMiscStatus_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleObject_SetColorScheme_Proxy(
    IOleObject* This,
    LOGPALETTE* pLogpal);
void __RPC_STUB IOleObject_SetColorScheme_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IOleObject_INTERFACE_DEFINED__ */

#ifndef __IOleAdviseHolder_FWD_DEFINED__
#define __IOleAdviseHolder_FWD_DEFINED__
typedef struct IOleAdviseHolder IOleAdviseHolder;
#endif

typedef IOleAdviseHolder *LPOLEADVISEHOLDER;

/*****************************************************************************
 * IOleAdviseHolder interface
 */
#ifndef __IOleAdviseHolder_INTERFACE_DEFINED__
#define __IOleAdviseHolder_INTERFACE_DEFINED__

DEFINE_GUID(IID_IOleAdviseHolder, 0x00000111, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IOleAdviseHolder : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Advise(
        IAdviseSink* pAdvise,
        DWORD* pdwConnection) = 0;

    virtual HRESULT STDMETHODCALLTYPE Unadvise(
        DWORD dwConnection) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnumAdvise(
        IEnumSTATDATA** ppenumAdvise) = 0;

    virtual HRESULT STDMETHODCALLTYPE SendOnRename(
        IMoniker* pmk) = 0;

    virtual HRESULT STDMETHODCALLTYPE SendOnSave(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE SendOnClose(
        ) = 0;

};
#else
typedef struct IOleAdviseHolderVtbl IOleAdviseHolderVtbl;
struct IOleAdviseHolder {
    const IOleAdviseHolderVtbl* lpVtbl;
};
struct IOleAdviseHolderVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IOleAdviseHolder* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IOleAdviseHolder* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IOleAdviseHolder* This);

    /*** IOleAdviseHolder methods ***/
    HRESULT (STDMETHODCALLTYPE *Advise)(
        IOleAdviseHolder* This,
        IAdviseSink* pAdvise,
        DWORD* pdwConnection);

    HRESULT (STDMETHODCALLTYPE *Unadvise)(
        IOleAdviseHolder* This,
        DWORD dwConnection);

    HRESULT (STDMETHODCALLTYPE *EnumAdvise)(
        IOleAdviseHolder* This,
        IEnumSTATDATA** ppenumAdvise);

    HRESULT (STDMETHODCALLTYPE *SendOnRename)(
        IOleAdviseHolder* This,
        IMoniker* pmk);

    HRESULT (STDMETHODCALLTYPE *SendOnSave)(
        IOleAdviseHolder* This);

    HRESULT (STDMETHODCALLTYPE *SendOnClose)(
        IOleAdviseHolder* This);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IOleAdviseHolder_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IOleAdviseHolder_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IOleAdviseHolder_Release(p) (p)->lpVtbl->Release(p)
/*** IOleAdviseHolder methods ***/
#define IOleAdviseHolder_Advise(p,a,b) (p)->lpVtbl->Advise(p,a,b)
#define IOleAdviseHolder_Unadvise(p,a) (p)->lpVtbl->Unadvise(p,a)
#define IOleAdviseHolder_EnumAdvise(p,a) (p)->lpVtbl->EnumAdvise(p,a)
#define IOleAdviseHolder_SendOnRename(p,a) (p)->lpVtbl->SendOnRename(p,a)
#define IOleAdviseHolder_SendOnSave(p) (p)->lpVtbl->SendOnSave(p)
#define IOleAdviseHolder_SendOnClose(p) (p)->lpVtbl->SendOnClose(p)
#endif

#endif

#define IOleAdviseHolder_METHODS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IOleAdviseHolder methods ***/ \
    STDMETHOD_(HRESULT,Advise)(THIS_ IAdviseSink* pAdvise, DWORD* pdwConnection) PURE; \
    STDMETHOD_(HRESULT,Unadvise)(THIS_ DWORD dwConnection) PURE; \
    STDMETHOD_(HRESULT,EnumAdvise)(THIS_ IEnumSTATDATA** ppenumAdvise) PURE; \
    STDMETHOD_(HRESULT,SendOnRename)(THIS_ IMoniker* pmk) PURE; \
    STDMETHOD_(HRESULT,SendOnSave)(THIS) PURE; \
    STDMETHOD_(HRESULT,SendOnClose)(THIS) PURE;

HRESULT CALLBACK IOleAdviseHolder_Advise_Proxy(
    IOleAdviseHolder* This,
    IAdviseSink* pAdvise,
    DWORD* pdwConnection);
void __RPC_STUB IOleAdviseHolder_Advise_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleAdviseHolder_Unadvise_Proxy(
    IOleAdviseHolder* This,
    DWORD dwConnection);
void __RPC_STUB IOleAdviseHolder_Unadvise_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleAdviseHolder_EnumAdvise_Proxy(
    IOleAdviseHolder* This,
    IEnumSTATDATA** ppenumAdvise);
void __RPC_STUB IOleAdviseHolder_EnumAdvise_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleAdviseHolder_SendOnRename_Proxy(
    IOleAdviseHolder* This,
    IMoniker* pmk);
void __RPC_STUB IOleAdviseHolder_SendOnRename_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleAdviseHolder_SendOnSave_Proxy(
    IOleAdviseHolder* This);
void __RPC_STUB IOleAdviseHolder_SendOnSave_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IOleAdviseHolder_SendOnClose_Proxy(
    IOleAdviseHolder* This);
void __RPC_STUB IOleAdviseHolder_SendOnClose_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IOleAdviseHolder_INTERFACE_DEFINED__ */

#ifndef __IContinue_FWD_DEFINED__
#define __IContinue_FWD_DEFINED__
typedef struct IContinue IContinue;
#endif

/*****************************************************************************
 * IContinue interface
 */
#ifndef __IContinue_INTERFACE_DEFINED__
#define __IContinue_INTERFACE_DEFINED__

DEFINE_GUID(IID_IContinue, 0x0000012a, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IContinue : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE FContinue(
        ) = 0;

};
#else
typedef struct IContinueVtbl IContinueVtbl;
struct IContinue {
    const IContinueVtbl* lpVtbl;
};
struct IContinueVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IContinue* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IContinue* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IContinue* This);

    /*** IContinue methods ***/
    HRESULT (STDMETHODCALLTYPE *FContinue)(
        IContinue* This);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IContinue_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IContinue_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IContinue_Release(p) (p)->lpVtbl->Release(p)
/*** IContinue methods ***/
#define IContinue_FContinue(p) (p)->lpVtbl->FContinue(p)
#endif

#endif

#define IContinue_METHODS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IContinue methods ***/ \
    STDMETHOD_(HRESULT,FContinue)(THIS) PURE;

HRESULT CALLBACK IContinue_FContinue_Proxy(
    IContinue* This);
void __RPC_STUB IContinue_FContinue_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IContinue_INTERFACE_DEFINED__ */

#ifndef __IViewObject_FWD_DEFINED__
#define __IViewObject_FWD_DEFINED__
typedef struct IViewObject IViewObject;
#endif

typedef IViewObject *LPVIEWOBJECT;

/*****************************************************************************
 * IViewObject interface
 */
#ifndef __IViewObject_INTERFACE_DEFINED__
#define __IViewObject_INTERFACE_DEFINED__

DEFINE_GUID(IID_IViewObject, 0x0000010d, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IViewObject : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Draw(
        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) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetColorSet(
        DWORD dwDrawAspect,
        LONG lindex,
        void* pvAspect,
        DVTARGETDEVICE* ptd,
        HDC hicTargetDev,
        LOGPALETTE** ppColorSet) = 0;

    virtual HRESULT STDMETHODCALLTYPE Freeze(
        DWORD dwDrawAspect,
        LONG lindex,
        void* pvAspect,
        DWORD* pdwFreeze) = 0;

    virtual HRESULT STDMETHODCALLTYPE Unfreeze(
        DWORD dwFreeze) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetAdvise(
        DWORD aspects,
        DWORD advf,
        IAdviseSink* pAdvSink) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetAdvise(
        DWORD* pAspects,
        DWORD* pAdvf,
        IAdviseSink** ppAdvSink) = 0;

};
#else
typedef struct IViewObjectVtbl IViewObjectVtbl;
struct IViewObject {
    const IViewObjectVtbl* lpVtbl;
};
struct IViewObjectVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IViewObject* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IViewObject* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IViewObject* This);

    /*** IViewObject methods ***/
    HRESULT (STDMETHODCALLTYPE *Draw)(
        IViewObject* 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)(
        IViewObject* This,
        DWORD dwDrawAspect,
        LONG lindex,
        void* pvAspect,
        DVTARGETDEVICE* ptd,
        HDC hicTargetDev,
        LOGPALETTE** ppColorSet);

    HRESULT (STDMETHODCALLTYPE *Freeze)(
        IViewObject* This,
        DWORD dwDrawAspect,
        LONG lindex,
        void* pvAspect,
        DWORD* pdwFreeze);

    HRESULT (STDMETHODCALLTYPE *Unfreeze)(
        IViewObject* This,
        DWORD dwFreeze);

    HRESULT (STDMETHODCALLTYPE *SetAdvise)(
        IViewObject* This,
        DWORD aspects,
        DWORD advf,
        IAdviseSink* pAdvSink);

    HRESULT (STDMETHODCALLTYPE *GetAdvise)(
        IViewObject* This,
        DWORD* pAspects,
        DWORD* pAdvf,
        IAdviseSink** ppAdvSink);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IViewObject_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IViewObject_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IViewObject_Release(p) (p)->lpVtbl->Release(p)
/*** IViewObject methods ***/
#define IViewObject_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 IViewObject_GetColorSet(p,a,b,c,d,e,f) (p)->lpVtbl->GetColorSet(p,a,b,c,d,e,f)
#define IViewObject_Freeze(p,a,b,c,d) (p)->lpVtbl->Freeze(p,a,b,c,d)
#define IViewObject_Unfreeze(p,a) (p)->lpVtbl->Unfreeze(p,a)
#define IViewObject_SetAdvise(p,a,b,c) (p)->lpVtbl->SetAdvise(p,a,b,c)
#define IViewObject_GetAdvise(p,a,b,c) (p)->lpVtbl->GetAdvise(p,a,b,c)
#endif

#endif

#define IViewObject_METHODS \
    /*** 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;

HRESULT CALLBACK IViewObject_RemoteDraw_Proxy(
    IViewObject* This,
    DWORD dwDrawAspect,
    LONG lindex,
    ULONG_PTR pvAspect,
    DVTARGETDEVICE* ptd,
    ULONG_PTR hdcTargetDev,
    ULONG_PTR hdcDraw,
    LPCRECTL lprcBounds,
    LPCRECTL lprcWBounds,
    IContinue* pContinue);
void __RPC_STUB IViewObject_RemoteDraw_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IViewObject_Draw_Proxy(
    IViewObject* 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 __RPC_STUB IViewObject_Draw_Stub(
    IViewObject* This,
    DWORD dwDrawAspect,
    LONG lindex,
    ULONG_PTR pvAspect,
    DVTARGETDEVICE* ptd,
    ULONG_PTR hdcTargetDev,
    ULONG_PTR hdcDraw,
    LPCRECTL lprcBounds,
    LPCRECTL lprcWBounds,
    IContinue* pContinue);
HRESULT CALLBACK IViewObject_RemoteGetColorSet_Proxy(
    IViewObject* This,
    DWORD dwDrawAspect,
    LONG lindex,
    ULONG_PTR pvAspect,
    DVTARGETDEVICE* ptd,
    ULONG_PTR hicTargetDev,
    LOGPALETTE** ppColorSet);
void __RPC_STUB IViewObject_RemoteGetColorSet_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IViewObject_GetColorSet_Proxy(
    IViewObject* This,
    DWORD dwDrawAspect,
    LONG lindex,
    void* pvAspect,
    DVTARGETDEVICE* ptd,
    HDC hicTargetDev,
    LOGPALETTE** ppColorSet);
HRESULT __RPC_STUB IViewObject_GetColorSet_Stub(
    IViewObject* This,
    DWORD dwDrawAspect,
    LONG lindex,
    ULONG_PTR pvAspect,
    DVTARGETDEVICE* ptd,
    ULONG_PTR hicTargetDev,
    LOGPALETTE** ppColorSet);
HRESULT CALLBACK IViewObject_RemoteFreeze_Proxy(
    IViewObject* This,
    DWORD dwDrawAspect,
    LONG lindex,
    ULONG_PTR pvAspect,
    DWORD* pdwFreeze);
void __RPC_STUB IViewObject_RemoteFreeze_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IViewObject_Freeze_Proxy(
    IViewObject* This,
    DWORD dwDrawAspect,
    LONG lindex,
    void* pvAspect,
    DWORD* pdwFreeze);
HRESULT __RPC_STUB IViewObject_Freeze_Stub(
    IViewObject* This,
    DWORD dwDrawAspect,
    LONG lindex,
    ULONG_PTR pvAspect,
    DWORD* pdwFreeze);
HRESULT CALLBACK IViewObject_Unfreeze_Proxy(
    IViewObject* This,
    DWORD dwFreeze);
void __RPC_STUB IViewObject_Unfreeze_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IViewObject_SetAdvise_Proxy(
    IViewObject* This,
    DWORD aspects,
    DWORD advf,
    IAdviseSink* pAdvSink);
void __RPC_STUB IViewObject_SetAdvise_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IViewObject_RemoteGetAdvise_Proxy(
    IViewObject* This,
    DWORD* pAspects,
    DWORD* pAdvf,
    IAdviseSink** ppAdvSink);
void __RPC_STUB IViewObject_RemoteGetAdvise_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IViewObject_GetAdvise_Proxy(
    IViewObject* This,
    DWORD* pAspects,
    DWORD* pAdvf,
    IAdviseSink** ppAdvSink);
HRESULT __RPC_STUB IViewObject_GetAdvise_Stub(
    IViewObject* This,
    DWORD* pAspects,
    DWORD* pAdvf,
    IAdviseSink** ppAdvSink);

#endif  /* __IViewObject_INTERFACE_DEFINED__ */

#ifndef __IViewObject2_FWD_DEFINED__
#define __IViewObject2_FWD_DEFINED__
typedef struct IViewObject2 IViewObject2;
#endif

typedef IViewObject2 *LPVIEWOBJECT2;

/*****************************************************************************
 * IViewObject2 interface
 */
#ifndef __IViewObject2_INTERFACE_DEFINED__
#define __IViewObject2_INTERFACE_DEFINED__

DEFINE_GUID(IID_IViewObject2, 0x00000127, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IViewObject2 : public IViewObject
{
    virtual HRESULT STDMETHODCALLTYPE GetExtent(
        DWORD dwDrawAspect,
        LONG lindex,
        DVTARGETDEVICE* ptd,
        LPSIZEL lpsizel) = 0;

};
#else
typedef struct IViewObject2Vtbl IViewObject2Vtbl;
struct IViewObject2 {
    const IViewObject2Vtbl* lpVtbl;
};
struct IViewObject2Vtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IViewObject2* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IViewObject2* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IViewObject2* This);

    /*** IViewObject methods ***/
    HRESULT (STDMETHODCALLTYPE *Draw)(
        IViewObject2* 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)(
        IViewObject2* This,
        DWORD dwDrawAspect,
        LONG lindex,
        void* pvAspect,
        DVTARGETDEVICE* ptd,
        HDC hicTargetDev,
        LOGPALETTE** ppColorSet);

    HRESULT (STDMETHODCALLTYPE *Freeze)(
        IViewObject2* This,
        DWORD dwDrawAspect,
        LONG lindex,
        void* pvAspect,
        DWORD* pdwFreeze);

    HRESULT (STDMETHODCALLTYPE *Unfreeze)(
        IViewObject2* This,
        DWORD dwFreeze);

    HRESULT (STDMETHODCALLTYPE *SetAdvise)(
        IViewObject2* This,
        DWORD aspects,
        DWORD advf,
        IAdviseSink* pAdvSink);

    HRESULT (STDMETHODCALLTYPE *GetAdvise)(
        IViewObject2* This,
        DWORD* pAspects,
        DWORD* pAdvf,
        IAdviseSink** ppAdvSink);

    /*** IViewObject2 methods ***/
    HRESULT (STDMETHODCALLTYPE *GetExtent)(
        IViewObject2* This,
        DWORD dwDrawAspect,
        LONG lindex,
        DVTARGETDEVICE* ptd,
        LPSIZEL lpsizel);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IViewObject2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IViewObject2_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IViewObject2_Release(p) (p)->lpVtbl->Release(p)
/*** IViewObject methods ***/
#define IViewObject2_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 IViewObject2_GetColorSet(p,a,b,c,d,e,f) (p)->lpVtbl->GetColorSet(p,a,b,c,d,e,f)
#define IViewObject2_Freeze(p,a,b,c,d) (p)->lpVtbl->Freeze(p,a,b,c,d)
#define IViewObject2_Unfreeze(p,a) (p)->lpVtbl->Unfreeze(p,a)
#define IViewObject2_SetAdvise(p,a,b,c) (p)->lpVtbl->SetAdvise(p,a,b,c)
#define IViewObject2_GetAdvise(p,a,b,c) (p)->lpVtbl->GetAdvise(p,a,b,c)
/*** IViewObject2 methods ***/
#define IViewObject2_GetExtent(p,a,b,c,d) (p)->lpVtbl->GetExtent(p,a,b,c,d)
#endif

#endif

#define IViewObject2_METHODS \
    /*** 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;

HRESULT CALLBACK IViewObject2_GetExtent_Proxy(
    IViewObject2* This,
    DWORD dwDrawAspect,
    LONG lindex,
    DVTARGETDEVICE* ptd,
    LPSIZEL lpsizel);
void __RPC_STUB IViewObject2_GetExtent_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IViewObject2_INTERFACE_DEFINED__ */

#ifndef __IDropSource_FWD_DEFINED__
#define __IDropSource_FWD_DEFINED__
typedef struct IDropSource IDropSource;
#endif

typedef IDropSource *LPDROPSOURCE;

/*****************************************************************************
 * IDropSource interface
 */
#ifndef __IDropSource_INTERFACE_DEFINED__
#define __IDropSource_INTERFACE_DEFINED__

DEFINE_GUID(IID_IDropSource, 0x00000121, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IDropSource : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE QueryContinueDrag(
        BOOL fEscapePressed,
        DWORD grfKeyState) = 0;

    virtual HRESULT STDMETHODCALLTYPE GiveFeedback(
        DWORD dwEffect) = 0;

};
#else
typedef struct IDropSourceVtbl IDropSourceVtbl;
struct IDropSource {
    const IDropSourceVtbl* lpVtbl;
};
struct IDropSourceVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IDropSource* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IDropSource* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IDropSource* This);

    /*** IDropSource methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryContinueDrag)(
        IDropSource* This,
        BOOL fEscapePressed,
        DWORD grfKeyState);

    HRESULT (STDMETHODCALLTYPE *GiveFeedback)(
        IDropSource* This,
        DWORD dwEffect);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IDropSource_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IDropSource_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IDropSource_Release(p) (p)->lpVtbl->Release(p)
/*** IDropSource methods ***/
#define IDropSource_QueryContinueDrag(p,a,b) (p)->lpVtbl->QueryContinueDrag(p,a,b)
#define IDropSource_GiveFeedback(p,a) (p)->lpVtbl->GiveFeedback(p,a)
#endif

#endif

#define IDropSource_METHODS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IDropSource methods ***/ \
    STDMETHOD_(HRESULT,QueryContinueDrag)(THIS_ BOOL fEscapePressed, DWORD grfKeyState) PURE; \
    STDMETHOD_(HRESULT,GiveFeedback)(THIS_ DWORD dwEffect) PURE;

HRESULT CALLBACK IDropSource_QueryContinueDrag_Proxy(
    IDropSource* This,
    BOOL fEscapePressed,
    DWORD grfKeyState);
void __RPC_STUB IDropSource_QueryContinueDrag_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDropSource_GiveFeedback_Proxy(
    IDropSource* This,
    DWORD dwEffect);
void __RPC_STUB IDropSource_GiveFeedback_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IDropSource_INTERFACE_DEFINED__ */

#ifndef __IDropTarget_FWD_DEFINED__
#define __IDropTarget_FWD_DEFINED__
typedef struct IDropTarget IDropTarget;
#endif

typedef IDropTarget *LPDROPTARGET;

#define MK_ALT (0x20)

#define DROPEFFECT_NONE (0)

#define DROPEFFECT_COPY (1)

#define DROPEFFECT_MOVE (2)

#define DROPEFFECT_LINK (4)

#define DROPEFFECT_SCROLL (0x80000000)

#define DD_DEFSCROLLINSET (11)

#define DD_DEFSCROLLDELAY (50)

#define DD_DEFSCROLLINTERVAL (50)

#define DD_DEFDRAGDELAY (200)

#define DD_DEFDRAGMINDIST (2)

/*****************************************************************************
 * IDropTarget interface
 */
#ifndef __IDropTarget_INTERFACE_DEFINED__
#define __IDropTarget_INTERFACE_DEFINED__

DEFINE_GUID(IID_IDropTarget, 0x00000122, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IDropTarget : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE DragEnter(
        IDataObject* pDataObj,
        DWORD grfKeyState,
        POINTL pt,
        DWORD* pdwEffect) = 0;

    virtual HRESULT STDMETHODCALLTYPE DragOver(
        DWORD grfKeyState,
        POINTL pt,
        DWORD* pdwEffect) = 0;

    virtual HRESULT STDMETHODCALLTYPE DragLeave(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Drop(
        IDataObject* pDataObj,
        DWORD grfKeyState,
        POINTL pt,
        DWORD* pdwEffect) = 0;

};
#else
typedef struct IDropTargetVtbl IDropTargetVtbl;
struct IDropTarget {
    const IDropTargetVtbl* lpVtbl;
};
struct IDropTargetVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IDropTarget* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IDropTarget* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IDropTarget* This);

    /*** IDropTarget methods ***/
    HRESULT (STDMETHODCALLTYPE *DragEnter)(
        IDropTarget* This,
        IDataObject* pDataObj,
        DWORD grfKeyState,
        POINTL pt,
        DWORD* pdwEffect);

    HRESULT (STDMETHODCALLTYPE *DragOver)(
        IDropTarget* This,
        DWORD grfKeyState,
        POINTL pt,
        DWORD* pdwEffect);

    HRESULT (STDMETHODCALLTYPE *DragLeave)(
        IDropTarget* This);

    HRESULT (STDMETHODCALLTYPE *Drop)(
        IDropTarget* This,
        IDataObject* pDataObj,
        DWORD grfKeyState,
        POINTL pt,
        DWORD* pdwEffect);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IDropTarget_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IDropTarget_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IDropTarget_Release(p) (p)->lpVtbl->Release(p)
/*** IDropTarget methods ***/
#define IDropTarget_DragEnter(p,a,b,c,d) (p)->lpVtbl->DragEnter(p,a,b,c,d)
#define IDropTarget_DragOver(p,a,b,c) (p)->lpVtbl->DragOver(p,a,b,c)
#define IDropTarget_DragLeave(p) (p)->lpVtbl->DragLeave(p)
#define IDropTarget_Drop(p,a,b,c,d) (p)->lpVtbl->Drop(p,a,b,c,d)
#endif

#endif

#define IDropTarget_METHODS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IDropTarget methods ***/ \
    STDMETHOD_(HRESULT,DragEnter)(THIS_ IDataObject* pDataObj, DWORD grfKeyState, POINTL pt, DWORD* pdwEffect) PURE; \
    STDMETHOD_(HRESULT,DragOver)(THIS_ DWORD grfKeyState, POINTL pt, DWORD* pdwEffect) PURE; \
    STDMETHOD_(HRESULT,DragLeave)(THIS) PURE; \
    STDMETHOD_(HRESULT,Drop)(THIS_ IDataObject* pDataObj, DWORD grfKeyState, POINTL pt, DWORD* pdwEffect) PURE;

HRESULT CALLBACK IDropTarget_DragEnter_Proxy(
    IDropTarget* This,
    IDataObject* pDataObj,
    DWORD grfKeyState,
    POINTL pt,
    DWORD* pdwEffect);
void __RPC_STUB IDropTarget_DragEnter_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDropTarget_DragOver_Proxy(
    IDropTarget* This,
    DWORD grfKeyState,
    POINTL pt,
    DWORD* pdwEffect);
void __RPC_STUB IDropTarget_DragOver_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDropTarget_DragLeave_Proxy(
    IDropTarget* This);
void __RPC_STUB IDropTarget_DragLeave_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDropTarget_Drop_Proxy(
    IDropTarget* This,
    IDataObject* pDataObj,
    DWORD grfKeyState,
    POINTL pt,
    DWORD* pdwEffect);
void __RPC_STUB IDropTarget_Drop_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IDropTarget_INTERFACE_DEFINED__ */

#ifdef __cplusplus
}
#endif
#endif /* __WIDL_OLEIDL_H */