Module:  OLE
Copyright:    Original Code is Copyright (c) 1995-2004 Functional Objects, Inc.
              All rights reserved.
License:      See License.txt in this distribution for details.
Warranty:     Distributed WITHOUT WARRANTY OF ANY KIND


/* This file is automatically generated from oleidl.h; do not edit. */

/* File created by MIDL compiler version 3.03.0110 */
/* at Thu Sep 11 10:57:06 1997
 */
// Adapted from:
//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//--------------------------------------------------------------------------



	/*  ----  IOleAdviseHolder  ----  */


define C-address $IID-IOleAdviseHolder :: <REFIID>
		c-name: "IID_IOleAdviseHolder"; end;


define open generic IOleAdviseHolder/Advise (This, pAdvise)
		=> (status :: <HRESULT>, dwConnection);

define inline-only C-function IOleAdviseHolder_Advise
  input parameter This :: <C-interface>;
  input parameter pAdvise :: <Interface>;
  output parameter pdwConnection :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleAdviseHolder_Advise";
end;

define method IOleAdviseHolder/Advise(This :: <C-interface>,
		pAdvise :: <Interface>) => (status :: <HRESULT>, dwConnection)
  IOleAdviseHolder_Advise(This, pAdvise)
end;

define open generic IOleAdviseHolder/Unadvise (This,
		dwConnection) => (status :: <HRESULT>);

define inline-only C-function IOleAdviseHolder_Unadvise
  input parameter This :: <C-interface>;
  input parameter dwConnection :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleAdviseHolder_Unadvise";
end;

define method IOleAdviseHolder/Unadvise(This :: <C-interface>,
		dwConnection) => (status :: <HRESULT>)
  IOleAdviseHolder_Unadvise(This, dwConnection)
end;

define open generic IOleAdviseHolder/EnumAdvise (This)
		=> (status :: <HRESULT>, penumAdvise :: <Interface>);

define inline-only C-function IOleAdviseHolder_EnumAdvise
  input parameter This :: <C-interface>;
  output parameter ppenumAdvise :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleAdviseHolder_EnumAdvise";
end;

define method IOleAdviseHolder/EnumAdvise(This :: <C-interface>)
		=> (status :: <HRESULT>, penumAdvise :: <Interface>)
  IOleAdviseHolder_EnumAdvise(This)
end;

define open generic IOleAdviseHolder/SendOnRename (This, pmk)
		=> (status :: <HRESULT>);

define inline-only C-function IOleAdviseHolder_SendOnRename
  input parameter This :: <C-interface>;
  input parameter pmk :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleAdviseHolder_SendOnRename";
end;

define method IOleAdviseHolder/SendOnRename(This :: <C-interface>,
		pmk :: <Interface>) => (status :: <HRESULT>)
  IOleAdviseHolder_SendOnRename(This, pmk)
end;

define open generic IOleAdviseHolder/SendOnSave (This)
		=> (status :: <HRESULT>);

define inline-only C-function IOleAdviseHolder_SendOnSave
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleAdviseHolder_SendOnSave";
end;

define method IOleAdviseHolder/SendOnSave(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleAdviseHolder_SendOnSave(This)
end;

define open generic IOleAdviseHolder/SendOnClose (This)
		=> (status :: <HRESULT>);

define inline-only C-function IOleAdviseHolder_SendOnClose
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleAdviseHolder_SendOnClose";
end;

define method IOleAdviseHolder/SendOnClose(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleAdviseHolder_SendOnClose(This)
end;


	/*  ----  IOleCache  ----  */


define open primary COM-interface <IOleCache> ( <IUnknown> )
end <IOleCache>;

define C-address IOleCache_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleCache_DW_vtbl"; end;
define C-address $IID-IOleCache :: <REFIID>
		c-name: "IID_IOleCache"; end;

define method initialize ( This :: <IOleCache>, #rest ignore, #key );
  next-method();
  This.vtbl := IOleCache_DW_vtbl;
  add-interface(This, $IID-IOleCache);
end initialize;

define open generic IOleCache/Cache (This, pformatetc, advf)
		=> (status :: <HRESULT>, dwConnection);

define C-callable-wrapper of IOleCache/Cache
  input parameter This :: <mapped-interface>;
  input parameter pformatetc :: <LPFORMATETC>;
  input parameter advf :: <DWORD>;
  output parameter pdwConnection :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleCache_Cache", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleCache_Cache
  input parameter This :: <C-interface>;
  input parameter pformatetc :: <LPFORMATETC>;
  input parameter advf :: <DWORD>;
  output parameter pdwConnection :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleCache_Cache";
end;

define method IOleCache/Cache(This :: <C-interface>,
		pformatetc :: <LPFORMATETC>, advf)
		=> (status :: <HRESULT>, dwConnection)
  IOleCache_Cache(This, pformatetc, advf)
end;

define open generic IOleCache/Uncache (This, dwConnection)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleCache/Uncache
  input parameter This :: <mapped-interface>;
  input parameter dwConnection :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleCache_Uncache", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleCache_Uncache
  input parameter This :: <C-interface>;
  input parameter dwConnection :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleCache_Uncache";
end;

define method IOleCache/Uncache(This :: <C-interface>,
		dwConnection) => (status :: <HRESULT>)
  IOleCache_Uncache(This, dwConnection)
end;

define open generic IOleCache/EnumCache (This)
		=> (status :: <HRESULT>, penumSTATDATA :: <Interface>);

define C-callable-wrapper of IOleCache/EnumCache
  input parameter This :: <mapped-interface>;
  output parameter ppenumSTATDATA :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleCache_EnumCache", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleCache_EnumCache
  input parameter This :: <C-interface>;
  output parameter ppenumSTATDATA :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleCache_EnumCache";
end;

define method IOleCache/EnumCache(This :: <C-interface>)
		=> (status :: <HRESULT>, penumSTATDATA :: <Interface>)
  IOleCache_EnumCache(This)
end;

define open generic IOleCache/InitCache (This, pDataObject)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleCache/InitCache
  input parameter This :: <mapped-interface>;
  input parameter pDataObject :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleCache_InitCache", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleCache_InitCache
  input parameter This :: <C-interface>;
  input parameter pDataObject :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleCache_InitCache";
end;

define method IOleCache/InitCache(This :: <C-interface>,
		pDataObject :: <Interface>) => (status :: <HRESULT>)
  IOleCache_InitCache(This, pDataObject)
end;

define open generic IOleCache/SetData (This, pformatetc, pmedium,
		fRelease) => (status :: <HRESULT>);

define C-callable-wrapper of IOleCache/SetData
  input parameter This :: <mapped-interface>;
  input parameter pformatetc :: <LPFORMATETC>;
  input parameter pmedium :: <LPSTGMEDIUM>;
  input parameter fRelease :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleCache_SetData", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleCache_SetData
  input parameter This :: <C-interface>;
  input parameter pformatetc :: <LPFORMATETC>;
  input parameter pmedium :: <LPSTGMEDIUM>;
  input parameter fRelease :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleCache_SetData";
end;

define method IOleCache/SetData(This :: <C-interface>,
		pformatetc :: <LPFORMATETC>, pmedium :: <LPSTGMEDIUM>,
		fRelease :: <boolean>) => (status :: <HRESULT>)
  IOleCache_SetData(This, pformatetc, pmedium, fRelease)
end;


	/*  ----  IOleCache2  ----  */


define open primary COM-interface <IOleCache2> ( <IOleCache> )
end <IOleCache2>;

define C-address IOleCache2_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleCache2_DW_vtbl"; end;
define C-address $IID-IOleCache2 :: <REFIID>
		c-name: "IID_IOleCache2"; end;

define method initialize ( This :: <IOleCache2>, #rest ignore, #key );
  next-method();
  This.vtbl := IOleCache2_DW_vtbl;
  add-interface(This, $IID-IOleCache2);
end initialize;

define open generic IOleCache2/UpdateCache (This, pDataObject,
		grfUpdf, pReserved) => (status :: <HRESULT>);

define C-callable-wrapper of IOleCache2/UpdateCache
  input parameter This :: <mapped-interface>;
  input parameter pDataObject :: <IDataObject>;
  input parameter grfUpdf :: <DWORD>;
  input parameter pReserved :: <LPVOID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleCache2_UpdateCache", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleCache2_UpdateCache
  input parameter This :: <C-interface>;
  input parameter pDataObject :: <IDataObject>;
  input parameter grfUpdf :: <DWORD>;
  input parameter pReserved :: <LPVOID>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleCache2_UpdateCache";
end;

define method IOleCache2/UpdateCache(This :: <C-interface>,
		pDataObject, grfUpdf, pReserved :: <C-pointer>)
		=> (status :: <HRESULT>)
  IOleCache2_UpdateCache(This, pDataObject, grfUpdf, pReserved)
end;

define open generic IOleCache2/DiscardCache (This,
		dwDiscardOptions) => (status :: <HRESULT>);

define C-callable-wrapper of IOleCache2/DiscardCache
  input parameter This :: <mapped-interface>;
  input parameter dwDiscardOptions :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleCache2_DiscardCache",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleCache2_DiscardCache
  input parameter This :: <C-interface>;
  input parameter dwDiscardOptions :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleCache2_DiscardCache";
end;

define method IOleCache2/DiscardCache(This :: <C-interface>,
		dwDiscardOptions) => (status :: <HRESULT>)
  IOleCache2_DiscardCache(This, dwDiscardOptions)
end;


	/*  ----  IOleCacheControl  ----  */


define C-address $IID-IOleCacheControl :: <REFIID>
		c-name: "IID_IOleCacheControl"; end;


define open generic IOleCacheControl/OnRun (This, pDataObject)
		=> (status :: <HRESULT>);

define inline-only C-function IOleCacheControl_OnRun
  input parameter This :: <C-interface>;
  input parameter pDataObject :: <IDataObject>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleCacheControl_OnRun";
end;

define method IOleCacheControl/OnRun(This :: <C-interface>,
		pDataObject) => (status :: <HRESULT>)
  IOleCacheControl_OnRun(This, pDataObject)
end;

define open generic IOleCacheControl/OnStop (This)
		=> (status :: <HRESULT>);

define inline-only C-function IOleCacheControl_OnStop
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleCacheControl_OnStop";
end;

define method IOleCacheControl/OnStop(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleCacheControl_OnStop(This)
end;


	/*  ----  IParseDisplayName  ----  */


define open primary COM-interface <IParseDisplayName> ( <IUnknown> )
end <IParseDisplayName>;

define C-address IParseDisplayName_DW_vtbl :: <C-COM-vtbl>
		c-name: "IParseDisplayName_DW_vtbl"; end;
define C-address $IID-IParseDisplayName :: <REFIID>
		c-name: "IID_IParseDisplayName"; end;

define method initialize ( This :: <IParseDisplayName>, #rest ignore, #key );
  next-method();
  This.vtbl := IParseDisplayName_DW_vtbl;
  add-interface(This, $IID-IParseDisplayName);
end initialize;

define open generic IParseDisplayName/ParseDisplayName (This,
		pbc, pszDisplayName)
		=> (status :: <HRESULT>, chEaten, pmkOut :: <Interface>);

define C-callable-wrapper of IParseDisplayName/ParseDisplayName
  input parameter This :: <mapped-interface>;
  input parameter pbc :: <C-interface>;
  input parameter pszDisplayName :: <LPOLESTR>;
  output parameter pchEaten :: <LPULONG>;
  output parameter ppmkOut :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IParseDisplayName_ParseDisplayName",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IParseDisplayName_ParseDisplayName
  input parameter This :: <C-interface>;
  input parameter pbc :: <Interface>;
  input parameter pszDisplayName :: <LPOLESTR>;
  output parameter pchEaten :: <LPULONG>;
  output parameter ppmkOut :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IParseDisplayName_ParseDisplayName";
end;

define method IParseDisplayName/ParseDisplayName(This :: <C-interface>,
		pbc :: <Interface>, pszDisplayName :: <LPOLESTR>)
		=> (status :: <HRESULT>, chEaten, pmkOut :: <Interface>)
  IParseDisplayName_ParseDisplayName(This, pbc, pszDisplayName)
end;


	/*  ----  IOleContainer  ----  */


define open primary COM-interface <IOleContainer> ( <IParseDisplayName> )
end <IOleContainer>;

define C-address IOleContainer_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleContainer_DW_vtbl"; end;
define C-address $IID-IOleContainer :: <REFIID>
		c-name: "IID_IOleContainer"; end;

define method initialize ( This :: <IOleContainer>, #rest ignore, #key );
  next-method();
  This.vtbl := IOleContainer_DW_vtbl;
  add-interface(This, $IID-IOleContainer);
end initialize;

define open generic IOleContainer/EnumObjects (This, grfFlags)
		=> (status :: <HRESULT>, penum :: <Interface>);

define C-callable-wrapper of IOleContainer/EnumObjects
  input parameter This :: <mapped-interface>;
  input parameter grfFlags :: <DWORD>;
  output parameter ppenum :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleContainer_EnumObjects",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleContainer_EnumObjects
  input parameter This :: <C-interface>;
  input parameter grfFlags :: <DWORD>;
  output parameter ppenum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleContainer_EnumObjects";
end;

define method IOleContainer/EnumObjects(This :: <C-interface>,
		grfFlags) => (status :: <HRESULT>, penum :: <Interface>)
  IOleContainer_EnumObjects(This, grfFlags)
end;

define open generic IOleContainer/LockContainer (This, fLock)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleContainer/LockContainer
  input parameter This :: <mapped-interface>;
  input parameter fLock :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleContainer_LockContainer",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleContainer_LockContainer
  input parameter This :: <C-interface>;
  input parameter fLock :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleContainer_LockContainer";
end;

define method IOleContainer/LockContainer(This :: <C-interface>,
		fLock :: <boolean>) => (status :: <HRESULT>)
  IOleContainer_LockContainer(This, fLock)
end;


	/*  ----  IOleClientSite  ----  */


define open primary COM-interface <IOleClientSite> ( <IUnknown> )
end <IOleClientSite>;

define C-address IOleClientSite_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleClientSite_DW_vtbl"; end;
define C-address $IID-IOleClientSite :: <REFIID>
		c-name: "IID_IOleClientSite"; end;

define method initialize ( This :: <IOleClientSite>, #rest ignore, #key );
  next-method();
  This.vtbl := IOleClientSite_DW_vtbl;
  add-interface(This, $IID-IOleClientSite);
end initialize;

define open generic IOleClientSite/SaveObject (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleClientSite/SaveObject
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleClientSite_SaveObject",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleClientSite_SaveObject
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleClientSite_SaveObject";
end;

define method IOleClientSite/SaveObject(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleClientSite_SaveObject(This)
end;

define open generic IOleClientSite/GetMoniker (This, dwAssign,
		dwWhichMoniker) => (status :: <HRESULT>, pmk :: <Interface>);

define C-callable-wrapper of IOleClientSite/GetMoniker
  input parameter This :: <mapped-interface>;
  input parameter dwAssign :: <DWORD>;
  input parameter dwWhichMoniker :: <DWORD>;
  output parameter ppmk :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleClientSite_GetMoniker",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleClientSite_GetMoniker
  input parameter This :: <C-interface>;
  input parameter dwAssign :: <DWORD>;
  input parameter dwWhichMoniker :: <DWORD>;
  output parameter ppmk :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleClientSite_GetMoniker";
end;

define method IOleClientSite/GetMoniker(This :: <C-interface>,
		dwAssign, dwWhichMoniker)
		=> (status :: <HRESULT>, pmk :: <Interface>)
  IOleClientSite_GetMoniker(This, dwAssign, dwWhichMoniker)
end;

define open generic IOleClientSite/GetContainer (This)
		=> (status :: <HRESULT>, pContainer :: <Interface>);

define C-callable-wrapper of IOleClientSite/GetContainer
  input parameter This :: <mapped-interface>;
  output parameter ppContainer :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleClientSite_GetContainer",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleClientSite_GetContainer
  input parameter This :: <C-interface>;
  output parameter ppContainer :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleClientSite_GetContainer";
end;

define method IOleClientSite/GetContainer(This :: <C-interface>)
		=> (status :: <HRESULT>, pContainer :: <Interface>)
  IOleClientSite_GetContainer(This)
end;

define open generic IOleClientSite/ShowObject (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleClientSite/ShowObject
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleClientSite_ShowObject",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleClientSite_ShowObject
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleClientSite_ShowObject";
end;

define method IOleClientSite/ShowObject(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleClientSite_ShowObject(This)
end;

define open generic IOleClientSite/OnShowWindow (This, fShow)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleClientSite/OnShowWindow
  input parameter This :: <mapped-interface>;
  input parameter fShow :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleClientSite_OnShowWindow",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleClientSite_OnShowWindow
  input parameter This :: <C-interface>;
  input parameter fShow :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleClientSite_OnShowWindow";
end;

define method IOleClientSite/OnShowWindow(This :: <C-interface>,
		fShow :: <boolean>) => (status :: <HRESULT>)
  IOleClientSite_OnShowWindow(This, fShow)
end;

define open generic IOleClientSite/RequestNewObjectLayout (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper
		of IOleClientSite/RequestNewObjectLayout
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleClientSite_RequestNewObjectLayout",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleClientSite_RequestNewObjectLayout
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleClientSite_RequestNewObjectLayout";
end;

define method IOleClientSite/RequestNewObjectLayout(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleClientSite_RequestNewObjectLayout(This)
end;


	/*  ----  IOleObject  ----  */


define open primary COM-interface <IOleObject> ( <IUnknown> )
end <IOleObject>;

define C-address IOleObject_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleObject_DW_vtbl"; end;
define C-address $IID-IOleObject :: <REFIID>
		c-name: "IID_IOleObject"; end;

define method initialize ( This :: <IOleObject>, #rest ignore, #key );
  next-method();
  This.vtbl := IOleObject_DW_vtbl;
  add-interface(This, $IID-IOleObject);
end initialize;

define open generic IOleObject/SetClientSite (This, pClientSite)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleObject/SetClientSite
  input parameter This :: <mapped-interface>;
  input parameter pClientSite :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_SetClientSite",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_SetClientSite
  input parameter This :: <C-interface>;
  input parameter pClientSite :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_SetClientSite";
end;

define method IOleObject/SetClientSite(This :: <C-interface>,
		pClientSite :: <Interface>) => (status :: <HRESULT>)
  IOleObject_SetClientSite(This, pClientSite)
end;

define open generic IOleObject/GetClientSite (This)
		=> (status :: <HRESULT>, pClientSite :: <Interface>);

define C-callable-wrapper of IOleObject/GetClientSite
  input parameter This :: <mapped-interface>;
  output parameter ppClientSite :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_GetClientSite",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_GetClientSite
  input parameter This :: <C-interface>;
  output parameter ppClientSite :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_GetClientSite";
end;

define method IOleObject/GetClientSite(This :: <C-interface>)
		=> (status :: <HRESULT>, pClientSite :: <Interface>)
  IOleObject_GetClientSite(This)
end;

define open generic IOleObject/SetHostNames (This,
		szContainerApp, szContainerObj) => (status :: <HRESULT>);

define C-callable-wrapper of IOleObject/SetHostNames
  input parameter This :: <mapped-interface>;
  input parameter szContainerApp :: <LPCOLESTR>;
  input parameter szContainerObj :: <LPCOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_SetHostNames",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_SetHostNames
  input parameter This :: <C-interface>;
  input parameter szContainerApp :: <LPCOLESTR>;
  input parameter szContainerObj :: <LPCOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_SetHostNames";
end;

define method IOleObject/SetHostNames(This :: <C-interface>,
		szContainerApp :: <string>, szContainerObj :: <string>)
		=> (status :: <HRESULT>)
  IOleObject_SetHostNames(This, szContainerApp, szContainerObj)
end;

define open generic IOleObject/Close (This, dwSaveOption)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleObject/Close
  input parameter This :: <mapped-interface>;
  input parameter dwSaveOption :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_Close", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_Close
  input parameter This :: <C-interface>;
  input parameter dwSaveOption :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_Close";
end;

define method IOleObject/Close(This :: <C-interface>,
		dwSaveOption) => (status :: <HRESULT>)
  IOleObject_Close(This, dwSaveOption)
end;

define open generic IOleObject/SetMoniker (This, dwWhichMoniker,
		pmk) => (status :: <HRESULT>);

define C-callable-wrapper of IOleObject/SetMoniker
  input parameter This :: <mapped-interface>;
  input parameter dwWhichMoniker :: <DWORD>;
  input parameter pmk :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_SetMoniker", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_SetMoniker
  input parameter This :: <C-interface>;
  input parameter dwWhichMoniker :: <DWORD>;
  input parameter pmk :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_SetMoniker";
end;

define method IOleObject/SetMoniker(This :: <C-interface>,
		dwWhichMoniker, pmk :: <Interface>) => (status :: <HRESULT>)
  IOleObject_SetMoniker(This, dwWhichMoniker, pmk)
end;

define open generic IOleObject/GetMoniker (This, dwAssign,
		dwWhichMoniker) => (status :: <HRESULT>, pmk :: <Interface>);

define C-callable-wrapper of IOleObject/GetMoniker
  input parameter This :: <mapped-interface>;
  input parameter dwAssign :: <DWORD>;
  input parameter dwWhichMoniker :: <DWORD>;
  output parameter ppmk :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_GetMoniker", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_GetMoniker
  input parameter This :: <C-interface>;
  input parameter dwAssign :: <DWORD>;
  input parameter dwWhichMoniker :: <DWORD>;
  output parameter ppmk :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_GetMoniker";
end;

define method IOleObject/GetMoniker(This :: <C-interface>,
		dwAssign, dwWhichMoniker)
		=> (status :: <HRESULT>, pmk :: <Interface>)
  IOleObject_GetMoniker(This, dwAssign, dwWhichMoniker)
end;

define open generic IOleObject/InitFromData (This, pDataObject,
		fCreation, dwReserved) => (status :: <HRESULT>);

define C-callable-wrapper of IOleObject/InitFromData
  input parameter This :: <mapped-interface>;
  input parameter pDataObject :: <C-interface>;
  input parameter fCreation :: <BOOL>;
  input parameter dwReserved :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_InitFromData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_InitFromData
  input parameter This :: <C-interface>;
  input parameter pDataObject :: <Interface>;
  input parameter fCreation :: <BOOL>;
  input parameter dwReserved :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_InitFromData";
end;

define method IOleObject/InitFromData(This :: <C-interface>,
		pDataObject :: <Interface>, fCreation :: <boolean>, dwReserved)
		=> (status :: <HRESULT>)
  IOleObject_InitFromData(This, pDataObject, fCreation,
		dwReserved)
end;

define open generic IOleObject/GetClipboardData (This,
		dwReserved)
		=> (status :: <HRESULT>, pDataObject :: <Interface>);

define C-callable-wrapper of IOleObject/GetClipboardData
  input parameter This :: <mapped-interface>;
  input parameter dwReserved :: <DWORD>;
  output parameter ppDataObject :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_GetClipboardData",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_GetClipboardData
  input parameter This :: <C-interface>;
  input parameter dwReserved :: <DWORD>;
  output parameter ppDataObject :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_GetClipboardData";
end;

define method IOleObject/GetClipboardData(This :: <C-interface>,
		dwReserved)
		=> (status :: <HRESULT>, pDataObject :: <Interface>)
  IOleObject_GetClipboardData(This, dwReserved)
end;

define open generic IOleObject/DoVerb (This, iVerb, lpmsg,
		pActiveSite, lindex, hwndParent, lprcPosRect)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleObject/DoVerb
  input parameter This :: <mapped-interface>;
  input parameter iVerb :: <LONG>;
  input parameter lpmsg :: <LPMSG>;
  input parameter pActiveSite :: <C-interface>;
  input parameter lindex :: <LONG>;
  input parameter hwndParent :: <HWND>;
  input parameter lprcPosRect :: <LPCRECT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_DoVerb", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_DoVerb
  input parameter This :: <C-interface>;
  input parameter iVerb :: <LONG>;
  input parameter lpmsg :: <LPMSG>;
  input parameter pActiveSite :: <Interface>;
  input parameter lindex :: <LONG>;
  input parameter hwndParent :: <HWND>;
  input parameter lprcPosRect :: <LPCRECT>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_DoVerb";
end;

define method IOleObject/DoVerb(This :: <C-interface>, iVerb,
		lpmsg :: <LPMSG>, pActiveSite :: <Interface>, lindex,
		hwndParent :: <HWND>, lprcPosRect :: <LPCRECT>)
		=> (status :: <HRESULT>)
  IOleObject_DoVerb(This, iVerb, lpmsg, pActiveSite, lindex,
		hwndParent, lprcPosRect)
end;

define open generic IOleObject/EnumVerbs (This)
		=> (status :: <HRESULT>, pEnumOleVerb :: <Interface>);

define C-callable-wrapper of IOleObject/EnumVerbs
  input parameter This :: <mapped-interface>;
  output parameter ppEnumOleVerb :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_EnumVerbs", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_EnumVerbs
  input parameter This :: <C-interface>;
  output parameter ppEnumOleVerb :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_EnumVerbs";
end;

define method IOleObject/EnumVerbs(This :: <C-interface>)
		=> (status :: <HRESULT>, pEnumOleVerb :: <Interface>)
  IOleObject_EnumVerbs(This)
end;

define open generic IOleObject/Update (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleObject/Update
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_Update", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_Update
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_Update";
end;

define method IOleObject/Update(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleObject_Update(This)
end;

define open generic IOleObject/IsUpToDate (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleObject/IsUpToDate
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_IsUpToDate", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_IsUpToDate
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_IsUpToDate";
end;

define method IOleObject/IsUpToDate(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleObject_IsUpToDate(This)
end;

define open generic IOleObject/GetUserClassID (This, pClsid)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleObject/GetUserClassID
  input parameter This :: <mapped-interface>;
  parameter pClsid :: <LPCLSID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_GetUserClassID",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_GetUserClassID
  input parameter This :: <C-interface>;
  parameter pClsid :: <LPCLSID>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_GetUserClassID";
end;

define method IOleObject/GetUserClassID(This :: <C-interface>,
		pClsid :: <LPCLSID>) => (status :: <HRESULT>)
  IOleObject_GetUserClassID(This, pClsid)
end;

define open generic IOleObject/GetUserType (This, dwFormOfType)
		=> (status :: <HRESULT>, szUserType :: <LPOLESTR>);

define C-callable-wrapper of IOleObject/GetUserType
  input parameter This :: <mapped-interface>;
  input parameter dwFormOfType :: <DWORD>;
  output parameter pszUserType :: <LPLPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_GetUserType", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_GetUserType
  input parameter This :: <C-interface>;
  input parameter dwFormOfType :: <DWORD>;
  output parameter pszUserType :: <LPLPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_GetUserType";
end;

define method IOleObject/GetUserType(This :: <C-interface>,
		dwFormOfType)
		=> (status :: <HRESULT>, szUserType :: <LPOLESTR>)
  IOleObject_GetUserType(This, dwFormOfType)
end;

define open generic IOleObject/SetExtent (This, dwDrawAspect,
		psizel) => (status :: <HRESULT>);

define C-callable-wrapper of IOleObject/SetExtent
  input parameter This :: <mapped-interface>;
  input parameter dwDrawAspect :: <DWORD>;
  input parameter psizel :: <LPSIZEL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_SetExtent", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_SetExtent
  input parameter This :: <C-interface>;
  input parameter dwDrawAspect :: <DWORD>;
  input parameter psizel :: <LPSIZEL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_SetExtent";
end;

define method IOleObject/SetExtent(This :: <C-interface>,
		dwDrawAspect, psizel :: <LPSIZEL>) => (status :: <HRESULT>)
  IOleObject_SetExtent(This, dwDrawAspect, psizel)
end;

define open generic IOleObject/GetExtent (This, dwDrawAspect,
		psizel) => (status :: <HRESULT>);

define C-callable-wrapper of IOleObject/GetExtent
  input parameter This :: <mapped-interface>;
  input parameter dwDrawAspect :: <DWORD>;
  parameter psizel :: <LPSIZEL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_GetExtent", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_GetExtent
  input parameter This :: <C-interface>;
  input parameter dwDrawAspect :: <DWORD>;
  parameter psizel :: <LPSIZEL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_GetExtent";
end;

define method IOleObject/GetExtent(This :: <C-interface>,
		dwDrawAspect, psizel :: <LPSIZEL>) => (status :: <HRESULT>)
  IOleObject_GetExtent(This, dwDrawAspect, psizel)
end;

define open generic IOleObject/Advise (This, pAdvSink)
		=> (status :: <HRESULT>, dwConnection);

define C-callable-wrapper of IOleObject/Advise
  input parameter This :: <mapped-interface>;
  input parameter pAdvSink :: <C-interface>;
  output parameter pdwConnection :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_Advise", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_Advise
  input parameter This :: <C-interface>;
  input parameter pAdvSink :: <Interface>;
  output parameter pdwConnection :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_Advise";
end;

define method IOleObject/Advise(This :: <C-interface>,
		pAdvSink :: <Interface>)
		=> (status :: <HRESULT>, dwConnection)
  IOleObject_Advise(This, pAdvSink)
end;

define open generic IOleObject/Unadvise (This, dwConnection)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleObject/Unadvise
  input parameter This :: <mapped-interface>;
  input parameter dwConnection :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_Unadvise", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_Unadvise
  input parameter This :: <C-interface>;
  input parameter dwConnection :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_Unadvise";
end;

define method IOleObject/Unadvise(This :: <C-interface>,
		dwConnection) => (status :: <HRESULT>)
  IOleObject_Unadvise(This, dwConnection)
end;

define open generic IOleObject/EnumAdvise (This)
		=> (status :: <HRESULT>, penumAdvise :: <Interface>);

define C-callable-wrapper of IOleObject/EnumAdvise
  input parameter This :: <mapped-interface>;
  output parameter ppenumAdvise :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_EnumAdvise", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_EnumAdvise
  input parameter This :: <C-interface>;
  output parameter ppenumAdvise :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_EnumAdvise";
end;

define method IOleObject/EnumAdvise(This :: <C-interface>)
		=> (status :: <HRESULT>, penumAdvise :: <Interface>)
  IOleObject_EnumAdvise(This)
end;

define open generic IOleObject/GetMiscStatus (This, dwAspect)
		=> (status :: <HRESULT>, dwStatus);

define C-callable-wrapper of IOleObject/GetMiscStatus
  input parameter This :: <mapped-interface>;
  input parameter dwAspect :: <DWORD>;
  output parameter pdwStatus :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_GetMiscStatus",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_GetMiscStatus
  input parameter This :: <C-interface>;
  input parameter dwAspect :: <DWORD>;
  output parameter pdwStatus :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_GetMiscStatus";
end;

define method IOleObject/GetMiscStatus(This :: <C-interface>,
		dwAspect) => (status :: <HRESULT>, dwStatus)
  IOleObject_GetMiscStatus(This, dwAspect)
end;

define open generic IOleObject/SetColorScheme (This, pLogpal)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleObject/SetColorScheme
  input parameter This :: <mapped-interface>;
  input parameter pLogpal :: <LPLOGPALETTE>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleObject_SetColorScheme",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleObject_SetColorScheme
  input parameter This :: <C-interface>;
  input parameter pLogpal :: <LPLOGPALETTE>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleObject_SetColorScheme";
end;

define method IOleObject/SetColorScheme(This :: <C-interface>,
		pLogpal :: <LPLOGPALETTE>) => (status :: <HRESULT>)
  IOleObject_SetColorScheme(This, pLogpal)
end;


	/*  ----  IOLETypes  ----  */



	/*  ----  IOleWindow  ----  */


define open primary COM-interface <IOleWindow> ( <IUnknown> )
end <IOleWindow>;

define C-address IOleWindow_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleWindow_DW_vtbl"; end;
define C-address $IID-IOleWindow :: <REFIID>
		c-name: "IID_IOleWindow"; end;

define method initialize ( This :: <IOleWindow>, #rest ignore, #key );
  next-method();
  This.vtbl := IOleWindow_DW_vtbl;
  add-interface(This, $IID-IOleWindow);
end initialize;

define open generic IOleWindow/GetWindow (This)
		=> (status :: <HRESULT>, hwnd);

define C-callable-wrapper of IOleWindow/GetWindow
  input parameter This :: <mapped-interface>;
  output parameter phwnd :: <LPHWND>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IOleWindow_GetWindow", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleWindow_GetWindow
  input parameter This :: <C-interface>;
  output parameter phwnd :: <LPHWND>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleWindow_GetWindow";
end;

define method IOleWindow/GetWindow(This :: <C-interface>)
		=> (status :: <HRESULT>, hwnd)
  IOleWindow_GetWindow(This)
end;

define open generic IOleWindow/ContextSensitiveHelp (This,
		fEnterMode) => (status :: <HRESULT>);

define C-callable-wrapper of IOleWindow/ContextSensitiveHelp
  input parameter This :: <mapped-interface>;
  input parameter fEnterMode :: <BOOL>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IOleWindow_ContextSensitiveHelp",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleWindow_ContextSensitiveHelp
  input parameter This :: <C-interface>;
  input parameter fEnterMode :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleWindow_ContextSensitiveHelp";
end;

define method IOleWindow/ContextSensitiveHelp(This :: <C-interface>,
		fEnterMode :: <boolean>) => (status :: <HRESULT>)
  IOleWindow_ContextSensitiveHelp(This, fEnterMode)
end;


	/*  ----  IOleLink  ----  */


define C-address $IID-IOleLink :: <REFIID>
		c-name: "IID_IOleLink"; end;


define open generic IOleLink/SetUpdateOptions (This, dwUpdateOpt)
		=> (status :: <HRESULT>);

define inline-only C-function IOleLink_SetUpdateOptions
  input parameter This :: <C-interface>;
  input parameter dwUpdateOpt :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleLink_SetUpdateOptions";
end;

define method IOleLink/SetUpdateOptions(This :: <C-interface>,
		dwUpdateOpt) => (status :: <HRESULT>)
  IOleLink_SetUpdateOptions(This, dwUpdateOpt)
end;

define open generic IOleLink/GetUpdateOptions (This)
		=> (status :: <HRESULT>, dwUpdateOpt);

define inline-only C-function IOleLink_GetUpdateOptions
  input parameter This :: <C-interface>;
  output parameter pdwUpdateOpt :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleLink_GetUpdateOptions";
end;

define method IOleLink/GetUpdateOptions(This :: <C-interface>)
		=> (status :: <HRESULT>, dwUpdateOpt)
  IOleLink_GetUpdateOptions(This)
end;

define open generic IOleLink/SetSourceMoniker (This, pmk, rclsid)
		=> (status :: <HRESULT>);

define inline-only C-function IOleLink_SetSourceMoniker
  input parameter This :: <C-interface>;
  input parameter pmk :: <Interface>;
  input parameter rclsid :: <REFCLSID>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleLink_SetSourceMoniker";
end;

define method IOleLink/SetSourceMoniker(This :: <C-interface>,
		pmk :: <Interface>, rclsid :: <REFCLSID>)
		=> (status :: <HRESULT>)
  IOleLink_SetSourceMoniker(This, pmk, rclsid)
end;

define open generic IOleLink/GetSourceMoniker (This)
		=> (status :: <HRESULT>, pmk :: <Interface>);

define inline-only C-function IOleLink_GetSourceMoniker
  input parameter This :: <C-interface>;
  output parameter ppmk :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleLink_GetSourceMoniker";
end;

define method IOleLink/GetSourceMoniker(This :: <C-interface>)
		=> (status :: <HRESULT>, pmk :: <Interface>)
  IOleLink_GetSourceMoniker(This)
end;

define open generic IOleLink/SetSourceDisplayName (This,
		pszStatusText) => (status :: <HRESULT>);

define inline-only C-function IOleLink_SetSourceDisplayName
  input parameter This :: <C-interface>;
  input parameter pszStatusText :: <LPCOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleLink_SetSourceDisplayName";
end;

define method IOleLink/SetSourceDisplayName(This :: <C-interface>,
		pszStatusText :: <string>) => (status :: <HRESULT>)
  IOleLink_SetSourceDisplayName(This, pszStatusText)
end;

define open generic IOleLink/GetSourceDisplayName (This)
		=> (status :: <HRESULT>, pszDisplayName :: <LPOLESTR>);

define inline-only C-function IOleLink_GetSourceDisplayName
  input parameter This :: <C-interface>;
  output parameter ppszDisplayName :: <LPLPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleLink_GetSourceDisplayName";
end;

define method IOleLink/GetSourceDisplayName(This :: <C-interface>)
		=> (status :: <HRESULT>, pszDisplayName :: <LPOLESTR>)
  IOleLink_GetSourceDisplayName(This)
end;

define open generic IOleLink/BindToSource (This, bindflags, pbc)
		=> (status :: <HRESULT>);

define inline-only C-function IOleLink_BindToSource
  input parameter This :: <C-interface>;
  input parameter bindflags :: <DWORD>;
  input parameter pbc :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleLink_BindToSource";
end;

define method IOleLink/BindToSource(This :: <C-interface>,
		bindflags, pbc :: <Interface>) => (status :: <HRESULT>)
  IOleLink_BindToSource(This, bindflags, pbc)
end;

define open generic IOleLink/BindIfRunning (This)
		=> (status :: <HRESULT>);

define inline-only C-function IOleLink_BindIfRunning
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleLink_BindIfRunning";
end;

define method IOleLink/BindIfRunning(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleLink_BindIfRunning(This)
end;

define open generic IOleLink/GetBoundSource (This)
		=> (status :: <HRESULT>, punk :: <Interface>);

define inline-only C-function IOleLink_GetBoundSource
  input parameter This :: <C-interface>;
  output parameter ppunk :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleLink_GetBoundSource";
end;

define method IOleLink/GetBoundSource(This :: <C-interface>)
		=> (status :: <HRESULT>, punk :: <Interface>)
  IOleLink_GetBoundSource(This)
end;

define open generic IOleLink/UnbindSource (This)
		=> (status :: <HRESULT>);

define inline-only C-function IOleLink_UnbindSource
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleLink_UnbindSource";
end;

define method IOleLink/UnbindSource(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleLink_UnbindSource(This)
end;

define open generic IOleLink/Update (This, pbc)
		=> (status :: <HRESULT>);

define inline-only C-function IOleLink_Update
  input parameter This :: <C-interface>;
  input parameter pbc :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleLink_Update";
end;

define method IOleLink/Update(This :: <C-interface>,
		pbc :: <Interface>) => (status :: <HRESULT>)
  IOleLink_Update(This, pbc)
end;


	/*  ----  IOleItemContainer  ----  */


define open primary COM-interface <IOleItemContainer> ( <IOleContainer> )
end <IOleItemContainer>;

define C-address IOleItemContainer_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleItemContainer_DW_vtbl"; end;
define C-address $IID-IOleItemContainer :: <REFIID>
		c-name: "IID_IOleItemContainer"; end;

define method initialize ( This :: <IOleItemContainer>, #rest ignore, #key );
  next-method();
  This.vtbl := IOleItemContainer_DW_vtbl;
  add-interface(This, $IID-IOleItemContainer);
end initialize;

define open generic IOleItemContainer/GetObject (This, pszItem,
		dwSpeedNeeded, pbc, riid)
		=> (status :: <HRESULT>, Object :: <Interface>);

define C-callable-wrapper of IOleItemContainer/GetObject
  input parameter This :: <mapped-interface>;
  input parameter pszItem :: <LPOLESTR>;
  input parameter dwSpeedNeeded :: <DWORD>;
  input parameter pbc :: <C-interface>;
  input parameter riid :: <REFIID>;
  output parameter Object :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleItemContainer_GetObject",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleItemContainer_GetObject
  input parameter This :: <C-interface>;
  input parameter pszItem :: <LPOLESTR>;
  input parameter dwSpeedNeeded :: <DWORD>;
  input parameter pbc :: <Interface>;
  input parameter riid :: <REFIID>;
  output parameter Object :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleItemContainer_GetObject";
end;

define method IOleItemContainer/GetObject(This :: <C-interface>,
		pszItem :: <LPOLESTR>, dwSpeedNeeded, pbc :: <Interface>,
		riid :: <REFIID>)
		=> (status :: <HRESULT>, Object :: <Interface>)
  IOleItemContainer_GetObject(This, pszItem, dwSpeedNeeded, pbc,
		riid)
end;

define open generic IOleItemContainer/GetObjectStorage (This,
		pszItem, pbc, riid)
		=> (status :: <HRESULT>, Object :: <Interface>);

define C-callable-wrapper of IOleItemContainer/GetObjectStorage
  input parameter This :: <mapped-interface>;
  input parameter pszItem :: <LPOLESTR>;
  input parameter pbc :: <C-interface>;
  input parameter riid :: <REFIID>;
  output parameter Object :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleItemContainer_GetObjectStorage",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleItemContainer_GetObjectStorage
  input parameter This :: <C-interface>;
  input parameter pszItem :: <LPOLESTR>;
  input parameter pbc :: <Interface>;
  input parameter riid :: <REFIID>;
  output parameter Object :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleItemContainer_GetObjectStorage";
end;

define method IOleItemContainer/GetObjectStorage(This :: <C-interface>,
		pszItem :: <LPOLESTR>, pbc :: <Interface>, riid :: <REFIID>)
		=> (status :: <HRESULT>, Object :: <Interface>)
  IOleItemContainer_GetObjectStorage(This, pszItem, pbc, riid)
end;

define open generic IOleItemContainer/IsRunning (This, pszItem)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleItemContainer/IsRunning
  input parameter This :: <mapped-interface>;
  input parameter pszItem :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleItemContainer_IsRunning",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleItemContainer_IsRunning
  input parameter This :: <C-interface>;
  input parameter pszItem :: <LPOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleItemContainer_IsRunning";
end;

define method IOleItemContainer/IsRunning(This :: <C-interface>,
		pszItem :: <LPOLESTR>) => (status :: <HRESULT>)
  IOleItemContainer_IsRunning(This, pszItem)
end;


	/*  ----  IOleInPlaceUIWindow  ----  */


define open primary COM-interface <IOleInPlaceUIWindow> ( <IOleWindow> )
end <IOleInPlaceUIWindow>;

define C-address IOleInPlaceUIWindow_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleInPlaceUIWindow_DW_vtbl"; end;
define C-address $IID-IOleInPlaceUIWindow :: <REFIID>
		c-name: "IID_IOleInPlaceUIWindow"; end;

define method initialize ( This :: <IOleInPlaceUIWindow>, #rest ignore, #key );
  next-method();
  This.vtbl := IOleInPlaceUIWindow_DW_vtbl;
  add-interface(This, $IID-IOleInPlaceUIWindow);
end initialize;

define open generic IOleInPlaceUIWindow/GetBorder (This,
		lprectBorder) => (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceUIWindow/GetBorder
  input parameter This :: <mapped-interface>;
  parameter lprectBorder :: <LPRECT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceUIWindow_GetBorder",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceUIWindow_GetBorder
  input parameter This :: <C-interface>;
  parameter lprectBorder :: <LPRECT>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceUIWindow_GetBorder";
end;

define method IOleInPlaceUIWindow/GetBorder(This :: <C-interface>,
		lprectBorder :: <LPRECT>) => (status :: <HRESULT>)
  IOleInPlaceUIWindow_GetBorder(This, lprectBorder)
end;

define open generic IOleInPlaceUIWindow/RequestBorderSpace (This,
		pborderwidths) => (status :: <HRESULT>);

define C-callable-wrapper
		of IOleInPlaceUIWindow/RequestBorderSpace
  input parameter This :: <mapped-interface>;
  input parameter pborderwidths :: <LPCBORDERWIDTHS>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceUIWindow_RequestBorderSpace",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceUIWindow_RequestBorderSpace
  input parameter This :: <C-interface>;
  input parameter pborderwidths :: <LPCBORDERWIDTHS>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceUIWindow_RequestBorderSpace";
end;

define method IOleInPlaceUIWindow/RequestBorderSpace(This :: <C-interface>,
		pborderwidths :: <LPCBORDERWIDTHS>) => (status :: <HRESULT>)
  IOleInPlaceUIWindow_RequestBorderSpace(This, pborderwidths)
end;

define open generic IOleInPlaceUIWindow/SetBorderSpace (This,
		pborderwidths) => (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceUIWindow/SetBorderSpace
  input parameter This :: <mapped-interface>;
  input parameter pborderwidths :: <LPCBORDERWIDTHS>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceUIWindow_SetBorderSpace",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceUIWindow_SetBorderSpace
  input parameter This :: <C-interface>;
  input parameter pborderwidths :: <LPCBORDERWIDTHS>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceUIWindow_SetBorderSpace";
end;

define method IOleInPlaceUIWindow/SetBorderSpace(This :: <C-interface>,
		pborderwidths :: <LPCBORDERWIDTHS>) => (status :: <HRESULT>)
  IOleInPlaceUIWindow_SetBorderSpace(This, pborderwidths)
end;

define open generic IOleInPlaceUIWindow/SetActiveObject (This,
		pActiveObject, pszObjName) => (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceUIWindow/SetActiveObject
  input parameter This :: <mapped-interface>;
  input parameter pActiveObject :: <C-interface>;
  input parameter pszObjName :: <LPCOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceUIWindow_SetActiveObject",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceUIWindow_SetActiveObject
  input parameter This :: <C-interface>;
  input parameter pActiveObject :: <Interface>;
  input parameter pszObjName :: <LPCOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceUIWindow_SetActiveObject";
end;

define method IOleInPlaceUIWindow/SetActiveObject(This :: <C-interface>,
		pActiveObject :: <Interface>, pszObjName :: <string>)
		=> (status :: <HRESULT>)
  IOleInPlaceUIWindow_SetActiveObject(This, pActiveObject,
		pszObjName)
end;


	/*  ----  IOleInPlaceActiveObject  ----  */


define open primary COM-interface <IOleInPlaceActiveObject> ( <IOleWindow> )
end <IOleInPlaceActiveObject>;

define C-address IOleInPlaceActiveObject_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleInPlaceActiveObject_DW_vtbl"; end;
define C-address $IID-IOleInPlaceActiveObject :: <REFIID>
		c-name: "IID_IOleInPlaceActiveObject"; end;

define method initialize ( This :: <IOleInPlaceActiveObject>, #rest ignore, #key );
  next-method();
  This.vtbl := IOleInPlaceActiveObject_DW_vtbl;
  add-interface(This, $IID-IOleInPlaceActiveObject);
end initialize;

define open generic IOleInPlaceActiveObject/TranslateAccelerator
		(This, lpmsg) => (status :: <HRESULT>);

define C-callable-wrapper
		of IOleInPlaceActiveObject/TranslateAccelerator
  input parameter This :: <mapped-interface>;
  input parameter lpmsg :: <LPMSG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceActiveObject_TranslateAccelerator",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceActiveObject_TranslateAccelerator
  input parameter This :: <C-interface>;
  input parameter lpmsg :: <LPMSG>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceActiveObject_TranslateAccelerator";
end;

define method IOleInPlaceActiveObject/TranslateAccelerator(This :: <C-interface>,
		lpmsg :: <LPMSG>) => (status :: <HRESULT>)
  IOleInPlaceActiveObject_TranslateAccelerator(This, lpmsg)
end;

define open generic IOleInPlaceActiveObject/OnFrameWindowActivate
		(This, fActivate) => (status :: <HRESULT>);

define C-callable-wrapper
		of IOleInPlaceActiveObject/OnFrameWindowActivate
  input parameter This :: <mapped-interface>;
  input parameter fActivate :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceActiveObject_OnFrameWindowActivate",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceActiveObject_OnFrameWindowActivate
  input parameter This :: <C-interface>;
  input parameter fActivate :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceActiveObject_OnFrameWindowActivate";
end;

define method IOleInPlaceActiveObject/OnFrameWindowActivate(This :: <C-interface>,
		fActivate :: <boolean>) => (status :: <HRESULT>)
  IOleInPlaceActiveObject_OnFrameWindowActivate(This, fActivate)
end;

define open generic IOleInPlaceActiveObject/OnDocWindowActivate
		(This, fActivate) => (status :: <HRESULT>);

define C-callable-wrapper
		of IOleInPlaceActiveObject/OnDocWindowActivate
  input parameter This :: <mapped-interface>;
  input parameter fActivate :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceActiveObject_OnDocWindowActivate",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceActiveObject_OnDocWindowActivate
  input parameter This :: <C-interface>;
  input parameter fActivate :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceActiveObject_OnDocWindowActivate";
end;

define method IOleInPlaceActiveObject/OnDocWindowActivate(This :: <C-interface>,
		fActivate :: <boolean>) => (status :: <HRESULT>)
  IOleInPlaceActiveObject_OnDocWindowActivate(This, fActivate)
end;

define open generic IOleInPlaceActiveObject/ResizeBorder (This,
		prcBorder, pUIWindow, fFrameWindow) => (status :: <HRESULT>);

define C-callable-wrapper
		of IOleInPlaceActiveObject/ResizeBorder
  input parameter This :: <mapped-interface>;
  input parameter prcBorder :: <LPCRECT>;
  input parameter pUIWindow :: <C-interface>;
  input parameter fFrameWindow :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceActiveObject_ResizeBorder",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceActiveObject_ResizeBorder
  input parameter This :: <C-interface>;
  input parameter prcBorder :: <LPCRECT>;
  input parameter pUIWindow :: <Interface>;
  input parameter fFrameWindow :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceActiveObject_ResizeBorder";
end;

define method IOleInPlaceActiveObject/ResizeBorder(This :: <C-interface>,
		prcBorder :: <LPCRECT>, pUIWindow :: <Interface>,
		fFrameWindow :: <boolean>) => (status :: <HRESULT>)
  IOleInPlaceActiveObject_ResizeBorder(This, prcBorder,
		pUIWindow, fFrameWindow)
end;

define open generic IOleInPlaceActiveObject/EnableModeless (This,
		fEnable) => (status :: <HRESULT>);

define C-callable-wrapper
		of IOleInPlaceActiveObject/EnableModeless
  input parameter This :: <mapped-interface>;
  input parameter fEnable :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceActiveObject_EnableModeless",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceActiveObject_EnableModeless
  input parameter This :: <C-interface>;
  input parameter fEnable :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceActiveObject_EnableModeless";
end;

define method IOleInPlaceActiveObject/EnableModeless(This :: <C-interface>,
		fEnable :: <boolean>) => (status :: <HRESULT>)
  IOleInPlaceActiveObject_EnableModeless(This, fEnable)
end;


	/*  ----  IOleInPlaceFrame  ----  */


define open primary COM-interface <IOleInPlaceFrame> ( <IOleInPlaceUIWindow> )
end <IOleInPlaceFrame>;

define C-address IOleInPlaceFrame_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleInPlaceFrame_DW_vtbl"; end;
define C-address $IID-IOleInPlaceFrame :: <REFIID>
		c-name: "IID_IOleInPlaceFrame"; end;

define method initialize ( This :: <IOleInPlaceFrame>, #rest ignore, #key );
  next-method();
  This.vtbl := IOleInPlaceFrame_DW_vtbl;
  add-interface(This, $IID-IOleInPlaceFrame);
end initialize;

define open generic IOleInPlaceFrame/InsertMenus (This,
		hmenuShared, lpMenuWidths) => (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceFrame/InsertMenus
  input parameter This :: <mapped-interface>;
  input parameter hmenuShared :: <HMENU>;
   parameter lpMenuWidths :: <LPOLEMENUGROUPWIDTHS>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceFrame_InsertMenus",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceFrame_InsertMenus
  input parameter This :: <C-interface>;
  input parameter hmenuShared :: <HMENU>;
   parameter lpMenuWidths :: <LPOLEMENUGROUPWIDTHS>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceFrame_InsertMenus";
end;

define method IOleInPlaceFrame/InsertMenus(This :: <C-interface>,
		hmenuShared :: <HMENU>, lpMenuWidths :: <LPOLEMENUGROUPWIDTHS>)
		=> (status :: <HRESULT>)
  IOleInPlaceFrame_InsertMenus(This, hmenuShared, lpMenuWidths)
end;

define open generic IOleInPlaceFrame/SetMenu (This, hmenuShared,
		holemenu, hwndActiveObject) => (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceFrame/SetMenu
  input parameter This :: <mapped-interface>;
  input parameter hmenuShared :: <HMENU>;
  input parameter holemenu :: <HOLEMENU>;
  input parameter hwndActiveObject :: <HWND>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceFrame_SetMenu",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceFrame_SetMenu
  input parameter This :: <C-interface>;
  input parameter hmenuShared :: <HMENU>;
  input parameter holemenu :: <HOLEMENU>;
  input parameter hwndActiveObject :: <HWND>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceFrame_SetMenu";
end;

define method IOleInPlaceFrame/SetMenu(This :: <C-interface>,
		hmenuShared :: <HMENU>, holemenu :: <HOLEMENU>,
		hwndActiveObject :: <HWND>) => (status :: <HRESULT>)
  IOleInPlaceFrame_SetMenu(This, hmenuShared, holemenu,
		hwndActiveObject)
end;

define open generic IOleInPlaceFrame/RemoveMenus (This,
		hmenuShared) => (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceFrame/RemoveMenus
  input parameter This :: <mapped-interface>;
  input parameter hmenuShared :: <HMENU>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceFrame_RemoveMenus",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceFrame_RemoveMenus
  input parameter This :: <C-interface>;
  input parameter hmenuShared :: <HMENU>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceFrame_RemoveMenus";
end;

define method IOleInPlaceFrame/RemoveMenus(This :: <C-interface>,
		hmenuShared :: <HMENU>) => (status :: <HRESULT>)
  IOleInPlaceFrame_RemoveMenus(This, hmenuShared)
end;

define open generic IOleInPlaceFrame/SetStatusText (This,
		pszStatusText) => (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceFrame/SetStatusText
  input parameter This :: <mapped-interface>;
  input parameter pszStatusText :: <LPCOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceFrame_SetStatusText",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceFrame_SetStatusText
  input parameter This :: <C-interface>;
  input parameter pszStatusText :: <LPCOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceFrame_SetStatusText";
end;

define method IOleInPlaceFrame/SetStatusText(This :: <C-interface>,
		pszStatusText :: <string>) => (status :: <HRESULT>)
  IOleInPlaceFrame_SetStatusText(This, pszStatusText)
end;

define open generic IOleInPlaceFrame/EnableModeless (This,
		fEnable) => (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceFrame/EnableModeless
  input parameter This :: <mapped-interface>;
  input parameter fEnable :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceFrame_EnableModeless",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceFrame_EnableModeless
  input parameter This :: <C-interface>;
  input parameter fEnable :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceFrame_EnableModeless";
end;

define method IOleInPlaceFrame/EnableModeless(This :: <C-interface>,
		fEnable :: <boolean>) => (status :: <HRESULT>)
  IOleInPlaceFrame_EnableModeless(This, fEnable)
end;

define open generic IOleInPlaceFrame/TranslateAccelerator (This,
		lpmsg, wID) => (status :: <HRESULT>);

define C-callable-wrapper
		of IOleInPlaceFrame/TranslateAccelerator
  input parameter This :: <mapped-interface>;
  input parameter lpmsg :: <LPMSG>;
  input parameter wID :: <WORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceFrame_TranslateAccelerator",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceFrame_TranslateAccelerator
  input parameter This :: <C-interface>;
  input parameter lpmsg :: <LPMSG>;
  input parameter wID :: <WORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceFrame_TranslateAccelerator";
end;

define method IOleInPlaceFrame/TranslateAccelerator(This :: <C-interface>,
		lpmsg :: <LPMSG>, wID) => (status :: <HRESULT>)
  IOleInPlaceFrame_TranslateAccelerator(This, lpmsg, wID)
end;


	/*  ----  IOleInPlaceObject  ----  */


define open primary COM-interface <IOleInPlaceObject> ( <IOleWindow> )
end <IOleInPlaceObject>;

define C-address IOleInPlaceObject_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleInPlaceObject_DW_vtbl"; end;
define C-address $IID-IOleInPlaceObject :: <REFIID>
		c-name: "IID_IOleInPlaceObject"; end;

define method initialize ( This :: <IOleInPlaceObject>, #rest ignore, #key );
  next-method();
  This.vtbl := IOleInPlaceObject_DW_vtbl;
  add-interface(This, $IID-IOleInPlaceObject);
end initialize;

define open generic IOleInPlaceObject/InPlaceDeactivate (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceObject/InPlaceDeactivate
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IOleInPlaceObject_InPlaceDeactivate",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceObject_InPlaceDeactivate
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceObject_InPlaceDeactivate";
end;

define method IOleInPlaceObject/InPlaceDeactivate(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleInPlaceObject_InPlaceDeactivate(This)
end;

define open generic IOleInPlaceObject/UIDeactivate (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceObject/UIDeactivate
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IOleInPlaceObject_UIDeactivate",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceObject_UIDeactivate
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceObject_UIDeactivate";
end;

define method IOleInPlaceObject/UIDeactivate(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleInPlaceObject_UIDeactivate(This)
end;

define open generic IOleInPlaceObject/SetObjectRects (This,
		lprcPosRect, lprcClipRect) => (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceObject/SetObjectRects
  input parameter This :: <mapped-interface>;
  input parameter lprcPosRect :: <LPCRECT>;
  input parameter lprcClipRect :: <LPCRECT>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IOleInPlaceObject_SetObjectRects",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceObject_SetObjectRects
  input parameter This :: <C-interface>;
  input parameter lprcPosRect :: <LPCRECT>;
  input parameter lprcClipRect :: <LPCRECT>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceObject_SetObjectRects";
end;

define method IOleInPlaceObject/SetObjectRects(This :: <C-interface>,
		lprcPosRect :: <LPCRECT>, lprcClipRect :: <LPCRECT>)
		=> (status :: <HRESULT>)
  IOleInPlaceObject_SetObjectRects(This, lprcPosRect,
		lprcClipRect)
end;

define open generic IOleInPlaceObject/ReactivateAndUndo (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceObject/ReactivateAndUndo
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IOleInPlaceObject_ReactivateAndUndo",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceObject_ReactivateAndUndo
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceObject_ReactivateAndUndo";
end;

define method IOleInPlaceObject/ReactivateAndUndo(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleInPlaceObject_ReactivateAndUndo(This)
end;


	/*  ----  IOleInPlaceSite  ----  */


define open primary COM-interface <IOleInPlaceSite> ( <IOleWindow> )
end <IOleInPlaceSite>;

define C-address IOleInPlaceSite_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleInPlaceSite_DW_vtbl"; end;
define C-address $IID-IOleInPlaceSite :: <REFIID>
		c-name: "IID_IOleInPlaceSite"; end;

define method initialize ( This :: <IOleInPlaceSite>, #rest ignore, #key );
  next-method();
  This.vtbl := IOleInPlaceSite_DW_vtbl;
  add-interface(This, $IID-IOleInPlaceSite);
end initialize;

define open generic IOleInPlaceSite/CanInPlaceActivate (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceSite/CanInPlaceActivate
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IOleInPlaceSite_CanInPlaceActivate",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSite_CanInPlaceActivate
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSite_CanInPlaceActivate";
end;

define method IOleInPlaceSite/CanInPlaceActivate(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleInPlaceSite_CanInPlaceActivate(This)
end;

define open generic IOleInPlaceSite/OnInPlaceActivate (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceSite/OnInPlaceActivate
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IOleInPlaceSite_OnInPlaceActivate",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSite_OnInPlaceActivate
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSite_OnInPlaceActivate";
end;

define method IOleInPlaceSite/OnInPlaceActivate(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleInPlaceSite_OnInPlaceActivate(This)
end;

define open generic IOleInPlaceSite/OnUIActivate (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceSite/OnUIActivate
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IOleInPlaceSite_OnUIActivate",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSite_OnUIActivate
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSite_OnUIActivate";
end;

define method IOleInPlaceSite/OnUIActivate(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleInPlaceSite_OnUIActivate(This)
end;

define open generic IOleInPlaceSite/GetWindowContext (This,
		lprcPosRect, lprcClipRect, lpFrameInfo)
		=> (status :: <HRESULT>, pFrame :: <Interface>,
		pDoc :: <Interface>);

define C-callable-wrapper of IOleInPlaceSite/GetWindowContext
  input parameter This :: <mapped-interface>;
  output parameter ppFrame :: <Interface*>;
  output parameter ppDoc :: <Interface*>;
  parameter lprcPosRect :: <LPRECT>;
  parameter lprcClipRect :: <LPRECT>;
   parameter lpFrameInfo :: <LPOLEINPLACEFRAMEINFO>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IOleInPlaceSite_GetWindowContext",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSite_GetWindowContext
  input parameter This :: <C-interface>;
  output parameter ppFrame :: <C-interface*>;
  output parameter ppDoc :: <C-interface*>;
  parameter lprcPosRect :: <LPRECT>;
  parameter lprcClipRect :: <LPRECT>;
   parameter lpFrameInfo :: <LPOLEINPLACEFRAMEINFO>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSite_GetWindowContext";
end;

define method IOleInPlaceSite/GetWindowContext(This :: <C-interface>,
		lprcPosRect :: <LPRECT>, lprcClipRect :: <LPRECT>,
		lpFrameInfo :: <LPOLEINPLACEFRAMEINFO>)
		=> (status :: <HRESULT>, pFrame :: <Interface>,
		pDoc :: <Interface>)
  IOleInPlaceSite_GetWindowContext(This, lprcPosRect,
		lprcClipRect, lpFrameInfo)
end;

define open generic IOleInPlaceSite/Scroll (This, scrollExtant)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceSite/Scroll
  input parameter This :: <mapped-interface>;
  input parameter scrollExtant :: <SIZE>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IOleInPlaceSite_Scroll", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSite_Scroll
  input parameter This :: <C-interface>;
  input parameter scrollExtant :: <SIZE>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSite_Scroll";
end;

define method IOleInPlaceSite/Scroll(This :: <C-interface>,
		scrollExtant) => (status :: <HRESULT>)
  IOleInPlaceSite_Scroll(This, scrollExtant)
end;

define open generic IOleInPlaceSite/OnUIDeactivate (This,
		fUndoable) => (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceSite/OnUIDeactivate
  input parameter This :: <mapped-interface>;
  input parameter fUndoable :: <BOOL>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IOleInPlaceSite_OnUIDeactivate",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSite_OnUIDeactivate
  input parameter This :: <C-interface>;
  input parameter fUndoable :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSite_OnUIDeactivate";
end;

define method IOleInPlaceSite/OnUIDeactivate(This :: <C-interface>,
		fUndoable :: <boolean>) => (status :: <HRESULT>)
  IOleInPlaceSite_OnUIDeactivate(This, fUndoable)
end;

define open generic IOleInPlaceSite/OnInPlaceDeactivate (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceSite/OnInPlaceDeactivate
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IOleInPlaceSite_OnInPlaceDeactivate",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSite_OnInPlaceDeactivate
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSite_OnInPlaceDeactivate";
end;

define method IOleInPlaceSite/OnInPlaceDeactivate(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleInPlaceSite_OnInPlaceDeactivate(This)
end;

define open generic IOleInPlaceSite/DiscardUndoState (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceSite/DiscardUndoState
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IOleInPlaceSite_DiscardUndoState",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSite_DiscardUndoState
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSite_DiscardUndoState";
end;

define method IOleInPlaceSite/DiscardUndoState(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleInPlaceSite_DiscardUndoState(This)
end;

define open generic IOleInPlaceSite/DeactivateAndUndo (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceSite/DeactivateAndUndo
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IOleInPlaceSite_DeactivateAndUndo",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSite_DeactivateAndUndo
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSite_DeactivateAndUndo";
end;

define method IOleInPlaceSite/DeactivateAndUndo(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleInPlaceSite_DeactivateAndUndo(This)
end;

define open generic IOleInPlaceSite/OnPosRectChange (This,
		lprcPosRect) => (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceSite/OnPosRectChange
  input parameter This :: <mapped-interface>;
  input parameter lprcPosRect :: <LPCRECT>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IOleInPlaceSite_OnPosRectChange",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSite_OnPosRectChange
  input parameter This :: <C-interface>;
  input parameter lprcPosRect :: <LPCRECT>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSite_OnPosRectChange";
end;

define method IOleInPlaceSite/OnPosRectChange(This :: <C-interface>,
		lprcPosRect :: <LPCRECT>) => (status :: <HRESULT>)
  IOleInPlaceSite_OnPosRectChange(This, lprcPosRect)
end;


	/*  ----  IContinue  ----  */


define open primary COM-interface <IContinue> ( <IUnknown> )
end <IContinue>;

define C-address IContinue_DW_vtbl :: <C-COM-vtbl>
		c-name: "IContinue_DW_vtbl"; end;
define C-address $IID-IContinue :: <REFIID>
		c-name: "IID_IContinue"; end;

define method initialize ( This :: <IContinue>, #rest ignore, #key );
  next-method();
  This.vtbl := IContinue_DW_vtbl;
  add-interface(This, $IID-IContinue);
end initialize;

define open generic IContinue/FContinue (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IContinue/FContinue
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IContinue_FContinue", c-modifiers: "__stdcall";
end;

define inline-only C-function IContinue_FContinue
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IContinue_FContinue";
end;

define method IContinue/FContinue(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IContinue_FContinue(This)
end;


	/*  ----  IViewObject  ----  */


define open primary COM-interface <IViewObject> ( <IUnknown> )
end <IViewObject>;

define C-address IViewObject_DW_vtbl :: <C-COM-vtbl>
		c-name: "IViewObject_DW_vtbl"; end;
define C-address $IID-IViewObject :: <REFIID>
		c-name: "IID_IViewObject"; end;

define method initialize ( This :: <IViewObject>, #rest ignore, #key );
  next-method();
  This.vtbl := IViewObject_DW_vtbl;
  add-interface(This, $IID-IViewObject);
end initialize;

define open generic IViewObject/Draw (This, dwDrawAspect, lindex,
		pvAspect, ptd, hdcTargetDev, hdcDraw, lprcBounds, lprcWBounds,
		pfnContinue, dwContinue) => (status :: <HRESULT>);

define C-callable-wrapper of IViewObject/Draw
  input parameter This :: <mapped-interface>;
  input parameter dwDrawAspect :: <DWORD>;
  input parameter lindex :: <LONG>;
  input parameter pvAspect :: <C-void*>;
  input parameter ptd :: <LPDVTARGETDEVICE>;
  input parameter hdcTargetDev :: <HDC>;
  input parameter hdcDraw :: <HDC>;
  input parameter lprcBounds :: <LPCRECTL>;
  input parameter lprcWBounds :: <LPCRECTL>;
  input parameter pfnContinue :: <C-function-pointer>;
  input parameter dwContinue :: <DWORD>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IViewObject_Draw", c-modifiers: "__stdcall";
end;

define inline-only C-function IViewObject_Draw
  input parameter This :: <C-interface>;
  input parameter dwDrawAspect :: <DWORD>;
  input parameter lindex :: <LONG>;
  input parameter pvAspect :: <C-void*>;
  input parameter ptd :: <LPDVTARGETDEVICE>;
  input parameter hdcTargetDev :: <HDC>;
  input parameter hdcDraw :: <HDC>;
  input parameter lprcBounds :: <LPCRECTL>;
  input parameter lprcWBounds :: <LPCRECTL>;
  input parameter pfnContinue :: <C-function-pointer>;
  input parameter dwContinue :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IViewObject_Draw";
end;

define method IViewObject/Draw(This :: <C-interface>,
		dwDrawAspect, lindex, pvAspect :: <C-pointer>,
		ptd :: <LPDVTARGETDEVICE>, hdcTargetDev :: <HDC>,
		hdcDraw :: <HDC>, lprcBounds :: <LPCRECTL>,
		lprcWBounds :: <LPCRECTL>, pfnContinue, dwContinue)
		=> (status :: <HRESULT>)
  IViewObject_Draw(This, dwDrawAspect, lindex, pvAspect, ptd,
		hdcTargetDev, hdcDraw, lprcBounds, lprcWBounds, pfnContinue,
		dwContinue)
end;

define open generic IViewObject/GetColorSet (This, dwDrawAspect,
		lindex, pvAspect, ptd, hicTargetDev)
		=> (status :: <HRESULT>, pColorSet);

define C-callable-wrapper of IViewObject/GetColorSet
  input parameter This :: <mapped-interface>;
  input parameter dwDrawAspect :: <DWORD>;
  input parameter lindex :: <LONG>;
  input parameter pvAspect :: <C-void*>;
  input parameter ptd :: <LPDVTARGETDEVICE>;
  input parameter hicTargetDev :: <HDC>;
  output parameter ppColorSet :: <LPLOGPALETTE*>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IViewObject_GetColorSet",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IViewObject_GetColorSet
  input parameter This :: <C-interface>;
  input parameter dwDrawAspect :: <DWORD>;
  input parameter lindex :: <LONG>;
  input parameter pvAspect :: <C-void*>;
  input parameter ptd :: <LPDVTARGETDEVICE>;
  input parameter hicTargetDev :: <HDC>;
  output parameter ppColorSet :: <LPLOGPALETTE*>;
  result status :: <C-HRESULT>;
  c-name: "C_IViewObject_GetColorSet";
end;

define method IViewObject/GetColorSet(This :: <C-interface>,
		dwDrawAspect, lindex, pvAspect :: <C-pointer>,
		ptd :: <LPDVTARGETDEVICE>, hicTargetDev :: <HDC>)
		=> (status :: <HRESULT>, pColorSet)
  IViewObject_GetColorSet(This, dwDrawAspect, lindex, pvAspect,
		ptd, hicTargetDev)
end;

define open generic IViewObject/Freeze (This, dwDrawAspect,
		lindex, pvAspect) => (status :: <HRESULT>, dwFreeze);

define C-callable-wrapper of IViewObject/Freeze
  input parameter This :: <mapped-interface>;
  input parameter dwDrawAspect :: <DWORD>;
  input parameter lindex :: <LONG>;
  input parameter pvAspect :: <C-void*>;
  output parameter pdwFreeze :: <LPDWORD>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IViewObject_Freeze", c-modifiers: "__stdcall";
end;

define inline-only C-function IViewObject_Freeze
  input parameter This :: <C-interface>;
  input parameter dwDrawAspect :: <DWORD>;
  input parameter lindex :: <LONG>;
  input parameter pvAspect :: <C-void*>;
  output parameter pdwFreeze :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IViewObject_Freeze";
end;

define method IViewObject/Freeze(This :: <C-interface>,
		dwDrawAspect, lindex, pvAspect :: <C-pointer>)
		=> (status :: <HRESULT>, dwFreeze)
  IViewObject_Freeze(This, dwDrawAspect, lindex, pvAspect)
end;

define open generic IViewObject/Unfreeze (This, dwFreeze)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IViewObject/Unfreeze
  input parameter This :: <mapped-interface>;
  input parameter dwFreeze :: <DWORD>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IViewObject_Unfreeze", c-modifiers: "__stdcall";
end;

define inline-only C-function IViewObject_Unfreeze
  input parameter This :: <C-interface>;
  input parameter dwFreeze :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IViewObject_Unfreeze";
end;

define method IViewObject/Unfreeze(This :: <C-interface>,
		dwFreeze) => (status :: <HRESULT>)
  IViewObject_Unfreeze(This, dwFreeze)
end;

define open generic IViewObject/SetAdvise (This, aspects, advf,
		pAdvSink) => (status :: <HRESULT>);

define C-callable-wrapper of IViewObject/SetAdvise
  input parameter This :: <mapped-interface>;
  input parameter aspects :: <DWORD>;
  input parameter advf :: <DWORD>;
  input parameter pAdvSink :: <C-interface>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IViewObject_SetAdvise", c-modifiers: "__stdcall";
end;

define inline-only C-function IViewObject_SetAdvise
  input parameter This :: <C-interface>;
  input parameter aspects :: <DWORD>;
  input parameter advf :: <DWORD>;
  input parameter pAdvSink :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IViewObject_SetAdvise";
end;

define method IViewObject/SetAdvise(This :: <C-interface>,
		aspects, advf, pAdvSink :: <Interface>)
		=> (status :: <HRESULT>)
  IViewObject_SetAdvise(This, aspects, advf, pAdvSink)
end;

define open generic IViewObject/GetAdvise (This, pAspects, pAdvf,
		ppAdvSink) => (status :: <HRESULT>);

define C-callable-wrapper of IViewObject/GetAdvise
  input parameter This :: <mapped-interface>;
  parameter pAspects :: <LPDWORD>;
  parameter pAdvf :: <LPDWORD>;
  parameter ppAdvSink :: <Interface*>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IViewObject_GetAdvise", c-modifiers: "__stdcall";
end;

define inline-only C-function IViewObject_GetAdvise
  input parameter This :: <C-interface>;
  parameter pAspects :: <LPDWORD>;
  parameter pAdvf :: <LPDWORD>;
  parameter ppAdvSink :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IViewObject_GetAdvise";
end;

define method IViewObject/GetAdvise(This :: <C-interface>,
		pAspects :: <LPDWORD>, pAdvf :: <LPDWORD>, ppAdvSink)
		=> (status :: <HRESULT>)
  IViewObject_GetAdvise(This, pAspects, pAdvf, ppAdvSink)
end;


	/*  ----  IViewObject2  ----  */


define open primary COM-interface <IViewObject2> ( <IViewObject> )
end <IViewObject2>;

define C-address IViewObject2_DW_vtbl :: <C-COM-vtbl>
		c-name: "IViewObject2_DW_vtbl"; end;
define C-address $IID-IViewObject2 :: <REFIID>
		c-name: "IID_IViewObject2"; end;

define method initialize ( This :: <IViewObject2>, #rest ignore, #key );
  next-method();
  This.vtbl := IViewObject2_DW_vtbl;
  add-interface(This, $IID-IViewObject2);
end initialize;

define open generic IViewObject2/GetExtent (This, dwDrawAspect,
		lindex, ptd, lpsizel) => (status :: <HRESULT>);

define C-callable-wrapper of IViewObject2/GetExtent
  input parameter This :: <mapped-interface>;
  input parameter dwDrawAspect :: <DWORD>;
  input parameter lindex :: <LONG>;
  input parameter ptd :: <LPDVTARGETDEVICE>;
  parameter lpsizel :: <LPSIZEL>;
  result status :: <C-HRESULT>;
  export: #t,
  c-name: "DW_IViewObject2_GetExtent", c-modifiers: "__stdcall";
end;

define inline-only C-function IViewObject2_GetExtent
  input parameter This :: <C-interface>;
  input parameter dwDrawAspect :: <DWORD>;
  input parameter lindex :: <LONG>;
  input parameter ptd :: <LPDVTARGETDEVICE>;
  parameter lpsizel :: <LPSIZEL>;
  result status :: <C-HRESULT>;
  c-name: "C_IViewObject2_GetExtent";
end;

define method IViewObject2/GetExtent(This :: <C-interface>,
		dwDrawAspect, lindex, ptd :: <LPDVTARGETDEVICE>,
		lpsizel :: <LPSIZEL>) => (status :: <HRESULT>)
  IViewObject2_GetExtent(This, dwDrawAspect, lindex, ptd,
		lpsizel)
end;


	/*  ----  IDropSource  ----  */


define open primary COM-interface <IDropSource> ( <IUnknown> )
end <IDropSource>;

define C-address IDropSource_DW_vtbl :: <C-COM-vtbl>
		c-name: "IDropSource_DW_vtbl"; end;
define C-address $IID-IDropSource :: <REFIID>
		c-name: "IID_IDropSource"; end;

define method initialize ( This :: <IDropSource>, #rest ignore, #key );
  next-method();
  This.vtbl := IDropSource_DW_vtbl;
  add-interface(This, $IID-IDropSource);
end initialize;

define open generic IDropSource/QueryContinueDrag (This,
		fEscapePressed, grfKeyState) => (status :: <HRESULT>);

define C-callable-wrapper of IDropSource/QueryContinueDrag
  input parameter This :: <mapped-interface>;
  input parameter fEscapePressed :: <BOOL>;
  input parameter grfKeyState :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDropSource_QueryContinueDrag",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IDropSource_QueryContinueDrag
  input parameter This :: <C-interface>;
  input parameter fEscapePressed :: <BOOL>;
  input parameter grfKeyState :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IDropSource_QueryContinueDrag";
end;

define method IDropSource/QueryContinueDrag(This :: <C-interface>,
		fEscapePressed :: <boolean>, grfKeyState)
		=> (status :: <HRESULT>)
  IDropSource_QueryContinueDrag(This, fEscapePressed,
		grfKeyState)
end;

define open generic IDropSource/GiveFeedback (This, dwEffect)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IDropSource/GiveFeedback
  input parameter This :: <mapped-interface>;
  input parameter dwEffect :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDropSource_GiveFeedback",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IDropSource_GiveFeedback
  input parameter This :: <C-interface>;
  input parameter dwEffect :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IDropSource_GiveFeedback";
end;

define method IDropSource/GiveFeedback(This :: <C-interface>,
		dwEffect) => (status :: <HRESULT>)
  IDropSource_GiveFeedback(This, dwEffect)
end;


	/*  ----  IDropTarget  ----  */


define open primary COM-interface <IDropTarget> ( <IUnknown> )
end <IDropTarget>;

define C-address IDropTarget_DW_vtbl :: <C-COM-vtbl>
		c-name: "IDropTarget_DW_vtbl"; end;
define C-address $IID-IDropTarget :: <REFIID>
		c-name: "IID_IDropTarget"; end;

define method initialize ( This :: <IDropTarget>, #rest ignore, #key );
  next-method();
  This.vtbl := IDropTarget_DW_vtbl;
  add-interface(This, $IID-IDropTarget);
end initialize;

define open generic IDropTarget/DragEnter (This, pDataObj,
		grfKeyState, pt, pdwEffect) => (status :: <HRESULT>);

define C-callable-wrapper of IDropTarget/DragEnter
  input parameter This :: <mapped-interface>;
  input parameter pDataObj :: <C-interface>;
  input parameter grfKeyState :: <DWORD>;
  input parameter pt :: <POINTL>;
   parameter pdwEffect :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDropTarget_DragEnter", c-modifiers: "__stdcall";
end;

define inline-only C-function IDropTarget_DragEnter
  input parameter This :: <C-interface>;
  input parameter pDataObj :: <Interface>;
  input parameter grfKeyState :: <DWORD>;
  input parameter pt :: <POINTL>;
   parameter pdwEffect :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IDropTarget_DragEnter";
end;

define method IDropTarget/DragEnter(This :: <C-interface>,
		pDataObj :: <Interface>, grfKeyState, pt,
		pdwEffect :: <LPDWORD>) => (status :: <HRESULT>)
  IDropTarget_DragEnter(This, pDataObj, grfKeyState, pt,
		pdwEffect)
end;

define open generic IDropTarget/DragOver (This, grfKeyState, pt,
		pdwEffect) => (status :: <HRESULT>);

define C-callable-wrapper of IDropTarget/DragOver
  input parameter This :: <mapped-interface>;
  input parameter grfKeyState :: <DWORD>;
  input parameter pt :: <POINTL>;
   parameter pdwEffect :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDropTarget_DragOver", c-modifiers: "__stdcall";
end;

define inline-only C-function IDropTarget_DragOver
  input parameter This :: <C-interface>;
  input parameter grfKeyState :: <DWORD>;
  input parameter pt :: <POINTL>;
   parameter pdwEffect :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IDropTarget_DragOver";
end;

define method IDropTarget/DragOver(This :: <C-interface>,
		grfKeyState, pt, pdwEffect :: <LPDWORD>)
		=> (status :: <HRESULT>)
  IDropTarget_DragOver(This, grfKeyState, pt, pdwEffect)
end;

define open generic IDropTarget/DragLeave (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IDropTarget/DragLeave
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDropTarget_DragLeave", c-modifiers: "__stdcall";
end;

define inline-only C-function IDropTarget_DragLeave
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IDropTarget_DragLeave";
end;

define method IDropTarget/DragLeave(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IDropTarget_DragLeave(This)
end;

define open generic IDropTarget/Drop (This, pDataObj,
		grfKeyState, pt, pdwEffect) => (status :: <HRESULT>);

define C-callable-wrapper of IDropTarget/Drop
  input parameter This :: <mapped-interface>;
  input parameter pDataObj :: <C-interface>;
  input parameter grfKeyState :: <DWORD>;
  input parameter pt :: <POINTL>;
   parameter pdwEffect :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IDropTarget_Drop", c-modifiers: "__stdcall";
end;

define inline-only C-function IDropTarget_Drop
  input parameter This :: <C-interface>;
  input parameter pDataObj :: <Interface>;
  input parameter grfKeyState :: <DWORD>;
  input parameter pt :: <POINTL>;
   parameter pdwEffect :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IDropTarget_Drop";
end;

define method IDropTarget/Drop(This :: <C-interface>,
		pDataObj :: <Interface>, grfKeyState, pt,
		pdwEffect :: <LPDWORD>) => (status :: <HRESULT>)
  IDropTarget_Drop(This, pDataObj, grfKeyState, pt, pdwEffect)
end;


	/*  ----  IEnumOLEVERB  ----  */


define open primary COM-interface <IEnumOLEVERB> ( <IUnknown> )
end <IEnumOLEVERB>;

define C-address IEnumOLEVERB_DW_vtbl :: <C-COM-vtbl>
		c-name: "IEnumOLEVERB_DW_vtbl"; end;
define C-address $IID-IEnumOLEVERB :: <REFIID>
		c-name: "IID_IEnumOLEVERB"; end;

define method initialize ( This :: <IEnumOLEVERB>, #rest ignore, #key );
  next-method();
  This.vtbl := IEnumOLEVERB_DW_vtbl;
  add-interface(This, $IID-IEnumOLEVERB);
end initialize;

define open generic IEnumOLEVERB/Next (This, celt, rgelt)
		=> (status :: <HRESULT>, celtFetched);

define C-callable-wrapper of IEnumOLEVERB/Next
  input parameter This :: <mapped-interface>;
  input parameter celt :: <ULONG>;
   parameter rgelt :: <LPOLEVERB>;
  output parameter pceltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumOLEVERB_Next", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumOLEVERB_Next
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
   parameter rgelt :: <LPOLEVERB>;
  output parameter pceltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumOLEVERB_Next";
end;

define method IEnumOLEVERB/Next(This :: <C-interface>, celt,
		rgelt :: <LPOLEVERB>) => (status :: <HRESULT>, celtFetched)
  IEnumOLEVERB_Next(This, celt, rgelt)
end;

define open generic IEnumOLEVERB/Skip (This, celt)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IEnumOLEVERB/Skip
  input parameter This :: <mapped-interface>;
  input parameter celt :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumOLEVERB_Skip", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumOLEVERB_Skip
  input parameter This :: <C-interface>;
  input parameter celt :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumOLEVERB_Skip";
end;

define method IEnumOLEVERB/Skip(This :: <C-interface>, celt)
		=> (status :: <HRESULT>)
  IEnumOLEVERB_Skip(This, celt)
end;

define open generic IEnumOLEVERB/Reset (This)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IEnumOLEVERB/Reset
  input parameter This :: <mapped-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumOLEVERB_Reset", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumOLEVERB_Reset
  input parameter This :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumOLEVERB_Reset";
end;

define method IEnumOLEVERB/Reset(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IEnumOLEVERB_Reset(This)
end;

define open generic IEnumOLEVERB/Clone (This)
		=> (status :: <HRESULT>, penum :: <Interface>);

define C-callable-wrapper of IEnumOLEVERB/Clone
  input parameter This :: <mapped-interface>;
  output parameter ppenum :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumOLEVERB_Clone", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumOLEVERB_Clone
  input parameter This :: <C-interface>;
  output parameter ppenum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumOLEVERB_Clone";
end;

define method IEnumOLEVERB/Clone(This :: <C-interface>)
		=> (status :: <HRESULT>, penum :: <Interface>)
  IEnumOLEVERB_Clone(This)
end;
