include/oleidl.idl

/*
 * Copyright (C) 1999 Paul Quinn
 * Copyright (C) 1999 Francis Beaudet
 * Copyright (C) 2003 Alexandre Julliard
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#ifndef DO_NO_IMPORTS
import "objidl.idl";
#endif

interface IOleInPlaceActiveObject;

cpp_quote("#include <winuser.h>")

/*****************************************************************************
 * IOleTypes interface
 */
[
    uuid(b0916c84-7416-101a-bcea-08002b2b79ef)
]
interface IOLETypes
{
    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;
}


/*****************************************************************************
 * IOleWindow interface
 */
[
    object,
    uuid(00000114-0000-0000-c000-000000000046),
    pointer_default(unique)
]
interface IOleWindow : IUnknown
{
    typedef [unique] IOleWindow *LPOLEWINDOW;

    HRESULT GetWindow(
        [out] HWND *phwnd);

    HRESULT ContextSensitiveHelp(
        [in] BOOL fEnterMode);
}


/*****************************************************************************
 * IOleInPlaceObject interface
 */
[
    object,
    uuid(00000113-0000-0000-c000-000000000046),
    pointer_default(unique)
]
interface IOleInPlaceObject : IOleWindow
{
    typedef [unique] IOleInPlaceObject *LPOLEINPLACEOBJECT;

    HRESULT InPlaceDeactivate();

    HRESULT UIDeactivate();

    HRESULT SetObjectRects(
        [in] LPCRECT lprcPosRect,
        [in] LPCRECT lprcClipRect);

    HRESULT ReactivateAndUndo();
}


/*****************************************************************************
 * IOleInPlaceUIWindow interface
 */
[
    object,
    uuid(00000115-0000-0000-c000-000000000046),
    pointer_default(unique)
]

interface IOleInPlaceUIWindow : IOleWindow
{
    typedef [unique] IOleInPlaceUIWindow *LPOLEINPLACEUIWINDOW;

    typedef RECT BORDERWIDTHS;
    typedef LPRECT LPBORDERWIDTHS;
    typedef LPCRECT LPCBORDERWIDTHS;

    HRESULT GetBorder(
        [out] LPRECT lprectBorder);

    HRESULT RequestBorderSpace(
        [in, unique] LPCBORDERWIDTHS pborderwidths);

    HRESULT SetBorderSpace(
        [in, unique] LPCBORDERWIDTHS pborderwidths);

    HRESULT SetActiveObject(
        [in, unique] IOleInPlaceActiveObject *pActiveObject,
        [in, string, unique] LPCOLESTR pszObjName);
}


/* avoid conflict with Wine Unicode macros */
cpp_quote("#ifdef WINE_NO_UNICODE_MACROS")
cpp_quote("#undef TranslateAccelerator")
cpp_quote("#endif")

/*****************************************************************************
 * IOleInPlaceFrame interface
 */
[
    object,
    uuid(00000116-0000-0000-c000-000000000046),
    pointer_default(unique)
]
interface IOleInPlaceFrame : IOleInPlaceUIWindow
{
    typedef [unique] 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;

    HRESULT InsertMenus(
        [in] HMENU hmenuShared,
        [in,out] LPOLEMENUGROUPWIDTHS lpMenuWidths);

    HRESULT SetMenu(
        [in] HMENU hmenuShared,
        [in] HOLEMENU holemenu,
        [in] HWND hwndActiveObject);

    HRESULT RemoveMenus(
        [in] HMENU hmenuShared);

    HRESULT SetStatusText(
        [in, unique] LPCOLESTR pszStatusText);

    HRESULT EnableModeless(
        [in] BOOL fEnable);

    HRESULT TranslateAccelerator(
        [in] LPMSG lpmsg,
        [in] WORD wID);
}


/*****************************************************************************
 * IOleInPlaceActiveObject interface
 */
[
    object,
    uuid(00000117-0000-0000-c000-000000000046)
]
interface IOleInPlaceActiveObject : IOleWindow
{
    typedef [unique] IOleInPlaceActiveObject *LPOLEINPLACEACTIVEOBJECT;

    [local]
    HRESULT TranslateAccelerator(
        [in] LPMSG lpmsg);

    [call_as(TranslateAccelerator)]
    HRESULT RemoteTranslateAccelerator();

    HRESULT OnFrameWindowActivate(
        [in] BOOL fActivate);

    HRESULT OnDocWindowActivate(
        [in] BOOL fActivate);

    [local]
    HRESULT ResizeBorder(
        [in] LPCRECT prcBorder,
        [in, unique] IOleInPlaceUIWindow *pUIWindow,
        [in] BOOL fFrameWindow);

    [call_as(ResizeBorder)]
    HRESULT RemoteResizeBorder(
        [in] LPCRECT prcBorder,
        [in] REFIID riid,
        [in, unique, iid_is(riid)] IOleInPlaceUIWindow *pUIWindow,
        [in] BOOL fFrameWindow);

    HRESULT EnableModeless(
        [in] BOOL fEnable);
}


/*****************************************************************************
 * IOleInPlaceSite interface
 */
[
    object,
    uuid(00000119-0000-0000-c000-000000000046),
    pointer_default(unique)
]
interface IOleInPlaceSite : IOleWindow
{
    typedef [unique] IOleInPlaceSite *LPOLEINPLACESITE;

    HRESULT CanInPlaceActivate();
    HRESULT OnInPlaceActivate();
    HRESULT OnUIActivate();

    HRESULT GetWindowContext(
        [out] IOleInPlaceFrame **ppFrame,
        [out] IOleInPlaceUIWindow **ppDoc,
        [out] LPRECT lprcPosRect,
        [out] LPRECT lprcClipRect,
        [in, out] LPOLEINPLACEFRAMEINFO lpFrameInfo);

    HRESULT Scroll(
        [in] SIZE scrollExtent);

    HRESULT OnUIDeactivate(
        [in] BOOL fUndoable);

    HRESULT OnInPlaceDeactivate();
    HRESULT DiscardUndoState();
    HRESULT DeactivateAndUndo();

    HRESULT OnPosRectChange(
        [in] LPCRECT lprcPosRect);
}


/*****************************************************************************
 * IParseDisplayName interface
 */
[
    object,
    uuid(0000011a-0000-0000-c000-000000000046),
    pointer_default(unique)
]
interface IParseDisplayName : IUnknown
{
    typedef [unique] IParseDisplayName *LPPARSEDISPLAYNAME;

    HRESULT ParseDisplayName(
        [in, unique] IBindCtx *pbc,
        [in] LPOLESTR pszDisplayName,
        [out] ULONG *pchEaten,
        [out] IMoniker **ppmkOut);
}


/*****************************************************************************
 * IOleContainer interface
 */
[
    object,
    uuid(0000011b-0000-0000-c000-000000000046),
    pointer_default(unique)
]
interface IOleContainer : IParseDisplayName
{
    typedef [unique] IOleContainer *LPOLECONTAINER;

    HRESULT EnumObjects(
        [in] DWORD grfFlags,
        [out] IEnumUnknown **ppenum);

    HRESULT LockContainer(
        [in] BOOL fLock);
}


/*****************************************************************************
 * IOleItemContainer interface
 */
[
    object,
    uuid(0000011c-0000-0000-c000-000000000046),
    pointer_default(unique)
]
interface IOleItemContainer : IOleContainer
{
    typedef [unique] 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_ONLYUSER = 8,
	OLECONTF_ONLYIFRUNNING = 16
    } OLECONTF;

cpp_quote("#ifdef WINE_NO_UNICODE_MACROS")
cpp_quote("#undef GetObject")
cpp_quote("#endif")
    HRESULT GetObject(
        [in] LPOLESTR pszItem,
        [in] DWORD dwSpeedNeeded,
        [in, unique] IBindCtx *pbc,
        [in] REFIID riid,
        [out, iid_is(riid)] void **ppvObject);

    HRESULT GetObjectStorage(
        [in] LPOLESTR pszItem,
        [in, unique] IBindCtx *pbc,
        [in] REFIID riid,
        [out, iid_is(riid)] void **ppvStorage);

    HRESULT IsRunning(
        [in] LPOLESTR pszItem);
}


/*****************************************************************************
 * IOleLink interface
 */
[
    object,
    uuid(0000011d-0000-0000-c000-000000000046)
]
interface IOleLink : IUnknown
{
    typedef [unique] IOleLink *LPOLELINK;

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

    typedef enum tagOLELINKBIND
    {
	OLELINKBIND_EVENIFCLASSDIFF = 1
    } OLELINKBIND;

    HRESULT SetUpdateOptions(
        [in] DWORD dwUpdateOpt);

    HRESULT GetUpdateOptions(
        [out] DWORD *pdwUpdateOpt);

    HRESULT SetSourceMoniker(
        [in, unique] IMoniker *pmk,
        [in] REFCLSID rclsid);

    HRESULT GetSourceMoniker(
        [out] IMoniker **ppmk);

    HRESULT SetSourceDisplayName(
        [in]LPCOLESTR pszStatusText);

    HRESULT GetSourceDisplayName(
        [out] LPOLESTR *ppszDisplayName);

    HRESULT BindToSource(
        [in] DWORD bindflags,
        [in, unique] IBindCtx *pbc);

    HRESULT BindIfRunning();

    HRESULT GetBoundSource(
        [out] IUnknown **ppunk);

    HRESULT UnbindSource();

    HRESULT Update(
        [in, unique] IBindCtx *pbc);
}


/*****************************************************************************
 * IOleClientSite interface
 */
[
    object,
    uuid(00000118-0000-0000-c000-000000000046),
    pointer_default(unique)
]
interface IOleClientSite : IUnknown
{
    typedef [unique] IOleClientSite * LPOLECLIENTSITE;

    HRESULT SaveObject();

    HRESULT GetMoniker(
        [in] DWORD dwAssign,
        [in] DWORD dwWhichMoniker,
        [out] IMoniker **ppmk);

    HRESULT GetContainer(
        [out] IOleContainer **ppContainer);

    HRESULT ShowObject();

    HRESULT OnShowWindow(
        [in] BOOL fShow);

    HRESULT RequestNewObjectLayout();
}


/*****************************************************************************
 * IOleCache interface
 */
[
    object,
    uuid(0000011e-0000-0000-c000-000000000046),
    pointer_default(unique)
]
interface IOleCache : IUnknown
{
    typedef [unique] IOleCache *LPOLECACHE;

    HRESULT Cache(
        [in, unique] FORMATETC *pformatetc,
        [in] DWORD advf,
        [out] DWORD *pdwConnection);

    HRESULT Uncache(
        [in] DWORD dwConnection);

    HRESULT EnumCache(
        [out] IEnumSTATDATA **ppenumSTATDATA);

    HRESULT InitCache(
        [in, unique] IDataObject *pDataObject);

    HRESULT SetData(
        [in, unique] FORMATETC *pformatetc,
        [in, unique] STGMEDIUM *pmedium,
        [in] BOOL fRelease);
}


/*****************************************************************************
 * IOleCache2 interface
 */
[
    object,
    uuid(00000128-0000-0000-c000-000000000046),
    pointer_default(unique)
]
interface IOleCache2 : IOleCache
{
    typedef [unique] IOleCache2 *LPOLECACHE2;

    const DWORD UPDFCACHE_NODATACACHE = 0x00000001;
    const DWORD UPDFCACHE_ONSAVECACHE = 0x00000002;
    const DWORD UPDFCACHE_ONSTOPCACHE = 0x00000004;
    const DWORD UPDFCACHE_NORMALCACHE = 0x00000008;
    const DWORD UPDFCACHE_IFBLANK     = 0x00000010;
    const DWORD UPDFCACHE_ONLYIFBLANK = 0x80000000;

    const DWORD UPDFCACHE_IFBLANKORONSAVECACHE = (UPDFCACHE_IFBLANK | UPDFCACHE_ONSAVECACHE);
    const DWORD UPDFCACHE_ALL = ((DWORD)(~(UPDFCACHE_ONLYIFBLANK)));
    const DWORD UPDFCACHE_ALLBUTNODATACACHE = (UPDFCACHE_ALL & ((DWORD)(~UPDFCACHE_NODATACACHE)));

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

    [local]
    HRESULT UpdateCache(
        [in] LPDATAOBJECT pDataObject,
        [in] DWORD grfUpdf,
        [in] LPVOID pReserved);

    [call_as(UpdateCache)]
    HRESULT RemoteUpdateCache(
        [in] LPDATAOBJECT pDataObject,
        [in] DWORD grfUpdf,
        [in] LONG_PTR pReserved);

    HRESULT DiscardCache(
        [in] DWORD dwDiscardOptions);
}


/*****************************************************************************
 * IOleCacheControl interface
 */
[
    object,
    uuid(00000129-0000-0000-c000-000000000046)
]
interface IOleCacheControl : IUnknown
{
    typedef [unique] IOleCacheControl *LPOLECACHECONTROL;

    HRESULT OnRun(
        LPDATAOBJECT pDataObject);

    HRESULT OnStop();
}


/*****************************************************************************
 *  IEnumOLEVERB interface
 */
[
    object,
    uuid(00000104-0000-0000-c000-000000000046),
    pointer_default(unique)
]
interface IEnumOLEVERB : IUnknown
{
    typedef [unique] 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;

    [local]
    HRESULT Next(
        [in] ULONG celt,
        [out, size_is(celt), length_is(*pceltFetched)] LPOLEVERB rgelt,
        [out] ULONG *pceltFetched);

    [call_as(Next)]
    HRESULT RemoteNext(
        [in] ULONG celt,
        [out, size_is(celt), length_is(*pceltFetched)] LPOLEVERB rgelt,
        [out] ULONG *pceltFetched);

    HRESULT Skip(
        [in] ULONG celt);

    HRESULT Reset();

    HRESULT Clone(
        [out] IEnumOLEVERB **ppenum);
}


/*****************************************************************************
 * IOleObject interface
 */
[
    object,
    uuid(00000112-0000-0000-c000-000000000046),
    pointer_default(unique)
]
interface IOleObject : IUnknown
{
    typedef [unique] 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;

    HRESULT SetClientSite(
        [in, unique] IOleClientSite *pClientSite);

    HRESULT GetClientSite(
        [out] IOleClientSite **ppClientSite);

    HRESULT SetHostNames(
        [in] LPCOLESTR szContainerApp,
        [in, unique] LPCOLESTR szContainerObj);

    HRESULT Close(
        [in] DWORD dwSaveOption);

    HRESULT SetMoniker(
        [in] DWORD dwWhichMoniker,
        [in, unique] IMoniker *pmk);

    HRESULT GetMoniker(
        [in] DWORD dwAssign,
        [in] DWORD dwWhichMoniker,
        [out] IMoniker **ppmk);

    HRESULT InitFromData(
        [in, unique] IDataObject *pDataObject,
        [in] BOOL fCreation,
        [in] DWORD dwReserved);

    HRESULT GetClipboardData(
        [in] DWORD dwReserved,
        [out] IDataObject **ppDataObject);

    HRESULT DoVerb(
        [in] LONG iVerb,
        [in, unique] LPMSG lpmsg,
        [in, unique] IOleClientSite *pActiveSite,
        [in] LONG lindex,
        [in] HWND hwndParent,
        [in, unique] LPCRECT lprcPosRect);

    HRESULT EnumVerbs(
        [out] IEnumOLEVERB **ppEnumOleVerb);

    HRESULT Update();

    HRESULT IsUpToDate();

    HRESULT GetUserClassID(
        [out] CLSID *pClsid);

    HRESULT GetUserType(
        [in] DWORD dwFormOfType,
        [out] LPOLESTR *pszUserType);

    HRESULT SetExtent(
        [in] DWORD dwDrawAspect,
        [in] SIZEL *psizel);

    HRESULT GetExtent(
        [in] DWORD dwDrawAspect,
        [out] SIZEL *psizel);

    HRESULT Advise(
        [in, unique] IAdviseSink *pAdvSink,
        [out] DWORD *pdwConnection);

    HRESULT Unadvise(
        [in] DWORD dwConnection);

    HRESULT EnumAdvise(
        [out] IEnumSTATDATA **ppenumAdvise);

    HRESULT GetMiscStatus(
        [in] DWORD dwAspect,
        [out] DWORD *pdwStatus);

    HRESULT SetColorScheme(
        [in] LOGPALETTE *pLogpal);
}


/*****************************************************************************
 * IOleAdviseHolder interface
 */
[
    local,
    object,
    uuid(00000111-0000-0000-c000-000000000046)
]
interface IOleAdviseHolder : IUnknown
{
    typedef [unique] IOleAdviseHolder * LPOLEADVISEHOLDER;

    HRESULT Advise(
        [in, unique] IAdviseSink *pAdvise,
        [out] DWORD *pdwConnection);

    HRESULT Unadvise(
        [in] DWORD dwConnection);

    HRESULT EnumAdvise(
        [out] IEnumSTATDATA **ppenumAdvise);

    HRESULT SendOnRename(
        [in, unique] IMoniker *pmk);

    HRESULT SendOnSave();
    HRESULT SendOnClose();
}


/*****************************************************************************
 * IContinue interface
 */
[
    object,
    uuid(0000012a-0000-0000-c000-000000000046)
]
interface IContinue : IUnknown
{
    HRESULT FContinue();
}


/*****************************************************************************
 * IViewObject interface
 */
[
    object,
    uuid(0000010d-0000-0000-c000-000000000046)
]
interface IViewObject : IUnknown
{
    typedef [unique] IViewObject *LPVIEWOBJECT;

    [local]
    HRESULT Draw(
        [in] DWORD dwDrawAspect,
        [in] LONG lindex,
        [in, unique] void * pvAspect,
        [in, unique] DVTARGETDEVICE *ptd,
        [in] HDC hdcTargetDev,
        [in] HDC hdcDraw,
        [in] LPCRECTL lprcBounds,
        [in, unique] LPCRECTL lprcWBounds,
        [in] BOOL (*pfnContinue)(ULONG_PTR dwContinue),
        [in] ULONG_PTR dwContinue);

    [call_as(Draw)]
    HRESULT RemoteDraw(
        [in] DWORD dwDrawAspect,
        [in] LONG lindex,
        [in] ULONG_PTR pvAspect,
        [in, unique] DVTARGETDEVICE *ptd,
        [in] ULONG_PTR hdcTargetDev,
        [in] ULONG_PTR hdcDraw,
        [in] LPCRECTL lprcBounds,
        [in, unique] LPCRECTL lprcWBounds,
        [in] IContinue *pContinue);

    [local]
    HRESULT GetColorSet(
        [in] DWORD dwDrawAspect,
        [in] LONG lindex,
        [in, unique] void *pvAspect,
        [in, unique] DVTARGETDEVICE *ptd,
        [in] HDC hicTargetDev,
        [out] LOGPALETTE **ppColorSet);

    [call_as(GetColorSet)]
    HRESULT RemoteGetColorSet(
        [in] DWORD dwDrawAspect,
        [in] LONG lindex,
        [in] ULONG_PTR pvAspect,
        [in, unique] DVTARGETDEVICE *ptd,
        [in] ULONG_PTR hicTargetDev,
        [out] LOGPALETTE **ppColorSet);

    [local]
    HRESULT Freeze(
        [in] DWORD dwDrawAspect,
        [in] LONG lindex,
        [in, unique] void *pvAspect,
        [out] DWORD *pdwFreeze);

    [call_as(Freeze)]
    HRESULT RemoteFreeze(
        [in] DWORD dwDrawAspect,
        [in] LONG lindex,
        [in] ULONG_PTR pvAspect,
        [out] DWORD *pdwFreeze);

    HRESULT Unfreeze(
        [in] DWORD dwFreeze);

    HRESULT SetAdvise(
        [in] DWORD aspects,
        [in] DWORD advf,
        [in, unique] IAdviseSink *pAdvSink);

    [local]
    HRESULT GetAdvise(
        [out, unique] DWORD *pAspects,
        [out, unique] DWORD *pAdvf,
        [out] IAdviseSink **ppAdvSink);

    [call_as(GetAdvise)]
    HRESULT RemoteGetAdvise(
        [out] DWORD *pAspects,
        [out] DWORD *pAdvf,
        [out] IAdviseSink **ppAdvSink);
}


/*****************************************************************************
 * IViewObject2 interface
 */
[
    object,
    uuid(00000127-0000-0000-c000-000000000046)
]
interface IViewObject2 : IViewObject
{
    typedef [unique] IViewObject2 *LPVIEWOBJECT2;

    HRESULT GetExtent(
        [in]  DWORD dwDrawAspect,
        [in]  LONG lindex,
        [in, unique]  DVTARGETDEVICE* ptd,
        [out] LPSIZEL lpsizel);
}


/*****************************************************************************
 * IDropSource interface
 */
[
    local,
    object,
    uuid(00000121-0000-0000-c000-000000000046)
]
interface IDropSource : IUnknown
{
    typedef [unique] IDropSource *LPDROPSOURCE;

    HRESULT QueryContinueDrag(
        [in] BOOL fEscapePressed,
        [in] DWORD grfKeyState);

    HRESULT GiveFeedback(
        [in] DWORD dwEffect);
}


/*****************************************************************************
 * IDropTarget interface
 */
[
    object,
    uuid(00000122-0000-0000-c000-000000000046),
    pointer_default(unique)
]
interface IDropTarget : IUnknown
{
    typedef [unique] IDropTarget *LPDROPTARGET;

    const DWORD MK_ALT = 0x20;
    const DWORD DROPEFFECT_NONE = 0;
    const DWORD DROPEFFECT_COPY = 1;
    const DWORD DROPEFFECT_MOVE = 2;
    const DWORD DROPEFFECT_LINK = 4;
    const DWORD DROPEFFECT_SCROLL = 0x80000000;
    const DWORD DD_DEFSCROLLINSET = 11;
    const DWORD DD_DEFSCROLLDELAY = 50;
    const DWORD DD_DEFSCROLLINTERVAL = 50;
    const DWORD DD_DEFDRAGDELAY = 200;
    const DWORD DD_DEFDRAGMINDIST = 2;

    HRESULT DragEnter(
        [in, unique] IDataObject *pDataObj,
        [in] DWORD grfKeyState,
        [in] POINTL pt,
        [in, out] DWORD *pdwEffect);

    HRESULT DragOver(
        [in] DWORD grfKeyState,
        [in] POINTL pt,
        [in, out] DWORD *pdwEffect);

    HRESULT DragLeave();

    HRESULT Drop(
        [in, unique] IDataObject *pDataObj,
        [in] DWORD grfKeyState,
        [in] POINTL pt,
        [in, out] DWORD *pdwEffect);
}