Module:  Ole-Controls
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 ocidl.h; do not edit. */

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



	/*  ----  IOleControlTypes  ----  */



	/*  ----  IEnumConnections  ----  */


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

define C-address IEnumConnections_DW_vtbl :: <C-COM-vtbl>
		c-name: "IEnumConnections_DW_vtbl"; end;
define C-address $IID-IEnumConnections :: <REFIID>
		c-name: "IID_IEnumConnections"; end;

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

define open generic IEnumConnections/Next (This, cConnections,
		rgcd) => (status :: <HRESULT>, cFetched);

define C-callable-wrapper of IEnumConnections/Next
  input parameter This :: <mapped-interface>;
  input parameter cConnections :: <ULONG>;
   parameter rgcd :: <LPCONNECTDATA>;
  output parameter pcFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumConnections_Next", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumConnections_Next
  input parameter This :: <C-interface>;
  input parameter cConnections :: <ULONG>;
   parameter rgcd :: <LPCONNECTDATA>;
  output parameter pcFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumConnections_Next";
end;

define method IEnumConnections/Next(This :: <C-interface>,
		cConnections, rgcd :: <LPCONNECTDATA>)
		=> (status :: <HRESULT>, cFetched)
  IEnumConnections_Next(This, cConnections, rgcd)
end;

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

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

define inline-only C-function IEnumConnections_Skip
  input parameter This :: <C-interface>;
  input parameter cConnections :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumConnections_Skip";
end;

define method IEnumConnections/Skip(This :: <C-interface>,
		cConnections) => (status :: <HRESULT>)
  IEnumConnections_Skip(This, cConnections)
end;

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

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

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

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

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

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

define inline-only C-function IEnumConnections_Clone
  input parameter This :: <C-interface>;
  output parameter ppEnum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumConnections_Clone";
end;

define method IEnumConnections/Clone(This :: <C-interface>)
		=> (status :: <HRESULT>, pEnum :: <Interface>)
  IEnumConnections_Clone(This)
end;


	/*  ----  IConnectionPoint  ----  */


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

define C-address IConnectionPoint_DW_vtbl :: <C-COM-vtbl>
		c-name: "IConnectionPoint_DW_vtbl"; end;
define C-address $IID-IConnectionPoint :: <REFIID>
		c-name: "IID_IConnectionPoint"; end;

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

define open generic IConnectionPoint/GetConnectionInterface
		(This, pIID) => (status :: <HRESULT>);

define C-callable-wrapper
		of IConnectionPoint/GetConnectionInterface
  input parameter This :: <mapped-interface>;
  parameter pIID :: <REFIID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IConnectionPoint_GetConnectionInterface",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IConnectionPoint_GetConnectionInterface
  input parameter This :: <C-interface>;
  parameter pIID :: <REFIID>;
  result status :: <C-HRESULT>;
  c-name: "C_IConnectionPoint_GetConnectionInterface";
end;

define method IConnectionPoint/GetConnectionInterface(This :: <C-interface>,
		pIID :: <REFIID>) => (status :: <HRESULT>)
  IConnectionPoint_GetConnectionInterface(This, pIID)
end;

define open generic IConnectionPoint/GetConnectionPointContainer
		(This) => (status :: <HRESULT>, pCPC :: <Interface>);

define C-callable-wrapper
		of IConnectionPoint/GetConnectionPointContainer
  input parameter This :: <mapped-interface>;
  output parameter ppCPC :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IConnectionPoint_GetConnectionPointContainer",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IConnectionPoint_GetConnectionPointContainer
  input parameter This :: <C-interface>;
  output parameter ppCPC :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IConnectionPoint_GetConnectionPointContainer";
end;

define method IConnectionPoint/GetConnectionPointContainer(This :: <C-interface>)
		=> (status :: <HRESULT>, pCPC :: <Interface>)
  IConnectionPoint_GetConnectionPointContainer(This)
end;

define open generic IConnectionPoint/Advise (This, pUnkSink)
		=> (status :: <HRESULT>, dwCookie);

define C-callable-wrapper of IConnectionPoint/Advise
  input parameter This :: <mapped-interface>;
  input parameter pUnkSink :: <C-interface>;
  output parameter pdwCookie :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IConnectionPoint_Advise",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IConnectionPoint_Advise
  input parameter This :: <C-interface>;
  input parameter pUnkSink :: <Interface>;
  output parameter pdwCookie :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IConnectionPoint_Advise";
end;

define method IConnectionPoint/Advise(This :: <C-interface>,
		pUnkSink :: <Interface>) => (status :: <HRESULT>, dwCookie)
  IConnectionPoint_Advise(This, pUnkSink)
end;

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

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

define inline-only C-function IConnectionPoint_Unadvise
  input parameter This :: <C-interface>;
  input parameter dwCookie :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IConnectionPoint_Unadvise";
end;

define method IConnectionPoint/Unadvise(This :: <C-interface>,
		dwCookie) => (status :: <HRESULT>)
  IConnectionPoint_Unadvise(This, dwCookie)
end;

define open generic IConnectionPoint/EnumConnections (This)
		=> (status :: <HRESULT>, pEnum :: <Interface>);

define C-callable-wrapper of IConnectionPoint/EnumConnections
  input parameter This :: <mapped-interface>;
  output parameter ppEnum :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IConnectionPoint_EnumConnections",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IConnectionPoint_EnumConnections
  input parameter This :: <C-interface>;
  output parameter ppEnum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IConnectionPoint_EnumConnections";
end;

define method IConnectionPoint/EnumConnections(This :: <C-interface>)
		=> (status :: <HRESULT>, pEnum :: <Interface>)
  IConnectionPoint_EnumConnections(This)
end;


	/*  ----  IEnumConnectionPoints  ----  */


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

define C-address IEnumConnectionPoints_DW_vtbl :: <C-COM-vtbl>
		c-name: "IEnumConnectionPoints_DW_vtbl"; end;
define C-address $IID-IEnumConnectionPoints :: <REFIID>
		c-name: "IID_IEnumConnectionPoints"; end;

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

define open generic IEnumConnectionPoints/Next (This,
		cConnections, ppCP) => (status :: <HRESULT>, cFetched);

define C-callable-wrapper of IEnumConnectionPoints/Next
  input parameter This :: <mapped-interface>;
  input parameter cConnections :: <ULONG>;
   parameter ppCP :: <LPLPCONNECTIONPOINT>;
  output parameter pcFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumConnectionPoints_Next",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumConnectionPoints_Next
  input parameter This :: <C-interface>;
  input parameter cConnections :: <ULONG>;
   parameter ppCP :: <LPLPCONNECTIONPOINT>;
  output parameter pcFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumConnectionPoints_Next";
end;

define method IEnumConnectionPoints/Next(This :: <C-interface>,
		cConnections, ppCP :: <LPLPCONNECTIONPOINT>)
		=> (status :: <HRESULT>, cFetched)
  IEnumConnectionPoints_Next(This, cConnections, ppCP)
end;

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

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

define inline-only C-function IEnumConnectionPoints_Skip
  input parameter This :: <C-interface>;
  input parameter cConnections :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumConnectionPoints_Skip";
end;

define method IEnumConnectionPoints/Skip(This :: <C-interface>,
		cConnections) => (status :: <HRESULT>)
  IEnumConnectionPoints_Skip(This, cConnections)
end;

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

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

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

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

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

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

define inline-only C-function IEnumConnectionPoints_Clone
  input parameter This :: <C-interface>;
  output parameter ppEnum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumConnectionPoints_Clone";
end;

define method IEnumConnectionPoints/Clone(This :: <C-interface>)
		=> (status :: <HRESULT>, pEnum :: <Interface>)
  IEnumConnectionPoints_Clone(This)
end;


	/*  ----  IConnectionPointContainer  ----  */


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

define C-address IConnectionPointContainer_DW_vtbl :: <C-COM-vtbl>
		c-name: "IConnectionPointContainer_DW_vtbl"; end;
define C-address $IID-IConnectionPointContainer :: <REFIID>
		c-name: "IID_IConnectionPointContainer"; end;

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

define open generic IConnectionPointContainer/EnumConnectionPoints
		(This) => (status :: <HRESULT>, pEnum :: <Interface>);

define C-callable-wrapper
		of IConnectionPointContainer/EnumConnectionPoints
  input parameter This :: <mapped-interface>;
  output parameter ppEnum :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IConnectionPointContainer_EnumConnectionPoints",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IConnectionPointContainer_EnumConnectionPoints
  input parameter This :: <C-interface>;
  output parameter ppEnum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IConnectionPointContainer_EnumConnectionPoints";
end;

define method IConnectionPointContainer/EnumConnectionPoints(This :: <C-interface>)
		=> (status :: <HRESULT>, pEnum :: <Interface>)
  IConnectionPointContainer_EnumConnectionPoints(This)
end;

define open generic IConnectionPointContainer/FindConnectionPoint
		(This, riid) => (status :: <HRESULT>, pCP :: <Interface>);

define C-callable-wrapper
		of IConnectionPointContainer/FindConnectionPoint
  input parameter This :: <mapped-interface>;
  input parameter riid :: <REFIID>;
  output parameter ppCP :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IConnectionPointContainer_FindConnectionPoint",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IConnectionPointContainer_FindConnectionPoint
  input parameter This :: <C-interface>;
  input parameter riid :: <REFIID>;
  output parameter ppCP :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IConnectionPointContainer_FindConnectionPoint";
end;

define method IConnectionPointContainer/FindConnectionPoint(This :: <C-interface>,
		riid :: <REFIID>) => (status :: <HRESULT>, pCP :: <Interface>)
  IConnectionPointContainer_FindConnectionPoint(This, riid)
end;


	/*  ----  IClassFactory2  ----  */


define open primary COM-interface <IClassFactory2> ( <IClassFactory> )
end <IClassFactory2>;

define C-address IClassFactory2_DW_vtbl :: <C-COM-vtbl>
		c-name: "IClassFactory2_DW_vtbl"; end;
define C-address $IID-IClassFactory2 :: <REFIID>
		c-name: "IID_IClassFactory2"; end;

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

define open generic IClassFactory2/GetLicInfo (This, pLicInfo)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IClassFactory2/GetLicInfo
  input parameter This :: <mapped-interface>;
  parameter pLicInfo :: <LPLICINFO>;
  result status :: <C-HRESULT>;
  c-name: "DW_IClassFactory2_GetLicInfo",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IClassFactory2_GetLicInfo
  input parameter This :: <C-interface>;
  parameter pLicInfo :: <LPLICINFO>;
  result status :: <C-HRESULT>;
  c-name: "C_IClassFactory2_GetLicInfo";
end;

define method IClassFactory2/GetLicInfo(This :: <C-interface>,
		pLicInfo :: <LPLICINFO>) => (status :: <HRESULT>)
  IClassFactory2_GetLicInfo(This, pLicInfo)
end;

define open generic IClassFactory2/RequestLicKey (This,
		dwReserved) => (status :: <HRESULT>, BstrKey :: <BSTR>);

define C-callable-wrapper of IClassFactory2/RequestLicKey
  input parameter This :: <mapped-interface>;
  input parameter dwReserved :: <DWORD>;
  output parameter pBstrKey :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IClassFactory2_RequestLicKey",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IClassFactory2_RequestLicKey
  input parameter This :: <C-interface>;
  input parameter dwReserved :: <DWORD>;
  output parameter pBstrKey :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IClassFactory2_RequestLicKey";
end;

define method IClassFactory2/RequestLicKey(This :: <C-interface>,
		dwReserved) => (status :: <HRESULT>, BstrKey :: <BSTR>)
  IClassFactory2_RequestLicKey(This, dwReserved)
end;

define open generic IClassFactory2/CreateInstanceLic (This,
		pUnkOuter, pUnkReserved, riid, bstrKey)
		=> (status :: <HRESULT>, pvObj :: <C-void*>);

define C-callable-wrapper of IClassFactory2/CreateInstanceLic
  input parameter This :: <mapped-interface>;
  input parameter pUnkOuter :: <C-interface>;
  input parameter pUnkReserved :: <C-interface>;
  input parameter riid :: <REFIID>;
  input parameter bstrKey :: <BSTR>;
  output parameter ppvObj :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "DW_IClassFactory2_CreateInstanceLic",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IClassFactory2_CreateInstanceLic
  input parameter This :: <C-interface>;
  input parameter pUnkOuter :: <Interface>;
  input parameter pUnkReserved :: <Interface>;
  input parameter riid :: <REFIID>;
  input parameter bstrKey :: <BSTR>;
  output parameter ppvObj :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "C_IClassFactory2_CreateInstanceLic";
end;

define method IClassFactory2/CreateInstanceLic(This :: <C-interface>,
		pUnkOuter :: <Interface>, pUnkReserved :: <Interface>,
		riid :: <REFIID>, bstrKey)
		=> (status :: <HRESULT>, pvObj :: <C-void*>)
  IClassFactory2_CreateInstanceLic(This, pUnkOuter, pUnkReserved,
		riid, bstrKey)
end;


	/*  ----  IProvideClassInfo  ----  */


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

define C-address IProvideClassInfo_DW_vtbl :: <C-COM-vtbl>
		c-name: "IProvideClassInfo_DW_vtbl"; end;
define C-address $IID-IProvideClassInfo :: <REFIID>
		c-name: "IID_IProvideClassInfo"; end;

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

define open generic IProvideClassInfo/GetClassInfo (This)
		=> (status :: <HRESULT>, pTI :: <Interface>);

define C-callable-wrapper of IProvideClassInfo/GetClassInfo
  input parameter This :: <mapped-interface>;
  output parameter ppTI :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IProvideClassInfo_GetClassInfo",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IProvideClassInfo_GetClassInfo
  input parameter This :: <C-interface>;
  output parameter ppTI :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IProvideClassInfo_GetClassInfo";
end;

define method IProvideClassInfo/GetClassInfo(This :: <C-interface>)
		=> (status :: <HRESULT>, pTI :: <Interface>)
  IProvideClassInfo_GetClassInfo(This)
end;


	/*  ----  IProvideClassInfo2  ----  */


define open primary COM-interface <IProvideClassInfo2> ( <IProvideClassInfo> )
end <IProvideClassInfo2>;

define C-address IProvideClassInfo2_DW_vtbl :: <C-COM-vtbl>
		c-name: "IProvideClassInfo2_DW_vtbl"; end;
define C-address $IID-IProvideClassInfo2 :: <REFIID>
		c-name: "IID_IProvideClassInfo2"; end;

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

define open generic IProvideClassInfo2/GetGUID (This, dwGuidKind,
		pGUID) => (status :: <HRESULT>);

define C-callable-wrapper of IProvideClassInfo2/GetGUID
  input parameter This :: <mapped-interface>;
  input parameter dwGuidKind :: <DWORD>;
  parameter pGUID :: <LPGUID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IProvideClassInfo2_GetGUID",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IProvideClassInfo2_GetGUID
  input parameter This :: <C-interface>;
  input parameter dwGuidKind :: <DWORD>;
  parameter pGUID :: <LPGUID>;
  result status :: <C-HRESULT>;
  c-name: "C_IProvideClassInfo2_GetGUID";
end;

define method IProvideClassInfo2/GetGUID(This :: <C-interface>,
		dwGuidKind, pGUID :: <LPGUID>) => (status :: <HRESULT>)
  IProvideClassInfo2_GetGUID(This, dwGuidKind, pGUID)
end;


	/*  ----  IProvideMultipleClassInfo  ----  */


define open primary COM-interface <IProvideMultipleClassInfo> ( <IProvideClassInfo2> )
end <IProvideMultipleClassInfo>;

define C-address IProvideMultipleClassInfo_DW_vtbl :: <C-COM-vtbl>
		c-name: "IProvideMultipleClassInfo_DW_vtbl"; end;
define C-address $IID-IProvideMultipleClassInfo :: <REFIID>
		c-name: "IID_IProvideMultipleClassInfo"; end;

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

define open generic IProvideMultipleClassInfo/GetMultiTypeInfoCount
		(This) => (status :: <HRESULT>, cti);

define C-callable-wrapper
		of IProvideMultipleClassInfo/GetMultiTypeInfoCount
  input parameter This :: <mapped-interface>;
  output parameter pcti :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IProvideMultipleClassInfo_GetMultiTypeInfoCount",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IProvideMultipleClassInfo_GetMultiTypeInfoCount
  input parameter This :: <C-interface>;
  output parameter pcti :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IProvideMultipleClassInfo_GetMultiTypeInfoCount";
end;

define method IProvideMultipleClassInfo/GetMultiTypeInfoCount(This :: <C-interface>)
		=> (status :: <HRESULT>, cti)
  IProvideMultipleClassInfo_GetMultiTypeInfoCount(This)
end;

define open generic IProvideMultipleClassInfo/GetInfoOfIndex
		(This, iti, dwFlags, piidPrimary, piidSource)
		=> (status :: <HRESULT>, ptiCoClass :: <Interface>, dwTIFlags,
		cdispidReserved);

define C-callable-wrapper
		of IProvideMultipleClassInfo/GetInfoOfIndex
  input parameter This :: <mapped-interface>;
  input parameter iti :: <ULONG>;
  input parameter dwFlags :: <DWORD>;
  output parameter pptiCoClass :: <Interface*>;
  output parameter pdwTIFlags :: <LPDWORD>;
  output parameter pcdispidReserved :: <LPULONG>;
  parameter piidPrimary :: <REFIID>;
  parameter piidSource :: <REFIID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IProvideMultipleClassInfo_GetInfoOfIndex",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IProvideMultipleClassInfo_GetInfoOfIndex
  input parameter This :: <C-interface>;
  input parameter iti :: <ULONG>;
  input parameter dwFlags :: <DWORD>;
  output parameter pptiCoClass :: <C-interface*>;
  output parameter pdwTIFlags :: <LPDWORD>;
  output parameter pcdispidReserved :: <LPULONG>;
  parameter piidPrimary :: <REFIID>;
  parameter piidSource :: <REFIID>;
  result status :: <C-HRESULT>;
  c-name: "C_IProvideMultipleClassInfo_GetInfoOfIndex";
end;

define method IProvideMultipleClassInfo/GetInfoOfIndex(This :: <C-interface>,
		iti, dwFlags, piidPrimary :: <REFIID>, piidSource :: <REFIID>)
		=> (status :: <HRESULT>, ptiCoClass :: <Interface>, dwTIFlags,
		cdispidReserved)
  IProvideMultipleClassInfo_GetInfoOfIndex(This, iti, dwFlags,
		piidPrimary, piidSource)
end;


	/*  ----  IOleControl  ----  */


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

define C-address IOleControl_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleControl_DW_vtbl"; end;
define C-address $IID-IOleControl :: <REFIID>
		c-name: "IID_IOleControl"; end;

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

define open generic IOleControl/GetControlInfo (This, pCI)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleControl/GetControlInfo
  input parameter This :: <mapped-interface>;
  parameter pCI :: <LPCONTROLINFO>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleControl_GetControlInfo",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleControl_GetControlInfo
  input parameter This :: <C-interface>;
  parameter pCI :: <LPCONTROLINFO>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleControl_GetControlInfo";
end;

define method IOleControl/GetControlInfo(This :: <C-interface>,
		pCI :: <LPCONTROLINFO>) => (status :: <HRESULT>)
  IOleControl_GetControlInfo(This, pCI)
end;

define open generic IOleControl/OnMnemonic (This, pMsg)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleControl/OnMnemonic
  input parameter This :: <mapped-interface>;
  input parameter pMsg :: <LPMSG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleControl_OnMnemonic", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleControl_OnMnemonic
  input parameter This :: <C-interface>;
  input parameter pMsg :: <LPMSG>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleControl_OnMnemonic";
end;

define method IOleControl/OnMnemonic(This :: <C-interface>,
		pMsg :: <LPMSG>) => (status :: <HRESULT>)
  IOleControl_OnMnemonic(This, pMsg)
end;

define open generic IOleControl/OnAmbientPropertyChange (This,
		dispID) => (status :: <HRESULT>);

define C-callable-wrapper of IOleControl/OnAmbientPropertyChange
  input parameter This :: <mapped-interface>;
  input parameter dispID :: <DISPID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleControl_OnAmbientPropertyChange",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleControl_OnAmbientPropertyChange
  input parameter This :: <C-interface>;
  input parameter dispID :: <DISPID>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleControl_OnAmbientPropertyChange";
end;

define method IOleControl/OnAmbientPropertyChange(This :: <C-interface>,
		dispID) => (status :: <HRESULT>)
  IOleControl_OnAmbientPropertyChange(This, dispID)
end;

define open generic IOleControl/FreezeEvents (This, bFreeze)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleControl/FreezeEvents
  input parameter This :: <mapped-interface>;
  input parameter bFreeze :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleControl_FreezeEvents",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleControl_FreezeEvents
  input parameter This :: <C-interface>;
  input parameter bFreeze :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleControl_FreezeEvents";
end;

define method IOleControl/FreezeEvents(This :: <C-interface>,
		bFreeze :: <boolean>) => (status :: <HRESULT>)
  IOleControl_FreezeEvents(This, bFreeze)
end;


	/*  ----  IOleControlSite  ----  */


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

define C-address IOleControlSite_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleControlSite_DW_vtbl"; end;
define C-address $IID-IOleControlSite :: <REFIID>
		c-name: "IID_IOleControlSite"; end;

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

define open generic IOleControlSite/OnControlInfoChanged (This)
		=> (status :: <HRESULT>);

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

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

define method IOleControlSite/OnControlInfoChanged(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleControlSite_OnControlInfoChanged(This)
end;

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

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

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

define method IOleControlSite/LockInPlaceActive(This :: <C-interface>,
		fLock :: <boolean>) => (status :: <HRESULT>)
  IOleControlSite_LockInPlaceActive(This, fLock)
end;

define open generic IOleControlSite/GetExtendedControl (This)
		=> (status :: <HRESULT>, pDisp :: <Interface>);

define C-callable-wrapper of IOleControlSite/GetExtendedControl
  input parameter This :: <mapped-interface>;
  output parameter ppDisp :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleControlSite_GetExtendedControl",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleControlSite_GetExtendedControl
  input parameter This :: <C-interface>;
  output parameter ppDisp :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleControlSite_GetExtendedControl";
end;

define method IOleControlSite/GetExtendedControl(This :: <C-interface>)
		=> (status :: <HRESULT>, pDisp :: <Interface>)
  IOleControlSite_GetExtendedControl(This)
end;

define open generic IOleControlSite/TransformCoords (This,
		pPtlHimetric, pPtfContainer, dwFlags)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleControlSite/TransformCoords
  input parameter This :: <mapped-interface>;
   parameter pPtlHimetric :: <LPPOINTL>;
   parameter pPtfContainer :: <LPPOINTF>;
  input parameter dwFlags :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleControlSite_TransformCoords",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleControlSite_TransformCoords
  input parameter This :: <C-interface>;
   parameter pPtlHimetric :: <LPPOINTL>;
   parameter pPtfContainer :: <LPPOINTF>;
  input parameter dwFlags :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleControlSite_TransformCoords";
end;

define method IOleControlSite/TransformCoords(This :: <C-interface>,
		pPtlHimetric :: <LPPOINTL>, pPtfContainer :: <LPPOINTF>,
		dwFlags) => (status :: <HRESULT>)
  IOleControlSite_TransformCoords(This, pPtlHimetric,
		pPtfContainer, dwFlags)
end;

define open generic IOleControlSite/TranslateAccelerator (This,
		pMsg, grfModifiers) => (status :: <HRESULT>);

define C-callable-wrapper
		of IOleControlSite/TranslateAccelerator
  input parameter This :: <mapped-interface>;
  input parameter pMsg :: <LPMSG>;
  input parameter grfModifiers :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleControlSite_TranslateAccelerator",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleControlSite_TranslateAccelerator
  input parameter This :: <C-interface>;
  input parameter pMsg :: <LPMSG>;
  input parameter grfModifiers :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleControlSite_TranslateAccelerator";
end;

define method IOleControlSite/TranslateAccelerator(This :: <C-interface>,
		pMsg :: <LPMSG>, grfModifiers) => (status :: <HRESULT>)
  IOleControlSite_TranslateAccelerator(This, pMsg, grfModifiers)
end;

define open generic IOleControlSite/OnFocus (This, fGotFocus)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleControlSite/OnFocus
  input parameter This :: <mapped-interface>;
  input parameter fGotFocus :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleControlSite_OnFocus",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleControlSite_OnFocus
  input parameter This :: <C-interface>;
  input parameter fGotFocus :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleControlSite_OnFocus";
end;

define method IOleControlSite/OnFocus(This :: <C-interface>,
		fGotFocus :: <boolean>) => (status :: <HRESULT>)
  IOleControlSite_OnFocus(This, fGotFocus)
end;

define open generic IOleControlSite/ShowPropertyFrame (This)
		=> (status :: <HRESULT>);

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

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

define method IOleControlSite/ShowPropertyFrame(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleControlSite_ShowPropertyFrame(This)
end;


	/*  ----  IPropertyPage  ----  */


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

define C-address IPropertyPage_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPropertyPage_DW_vtbl"; end;
define C-address $IID-IPropertyPage :: <REFIID>
		c-name: "IID_IPropertyPage"; end;

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

define open generic IPropertyPage/SetPageSite (This, pPageSite)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPropertyPage/SetPageSite
  input parameter This :: <mapped-interface>;
  input parameter pPageSite :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyPage_SetPageSite",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyPage_SetPageSite
  input parameter This :: <C-interface>;
  input parameter pPageSite :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyPage_SetPageSite";
end;

define method IPropertyPage/SetPageSite(This :: <C-interface>,
		pPageSite :: <Interface>) => (status :: <HRESULT>)
  IPropertyPage_SetPageSite(This, pPageSite)
end;

define open generic IPropertyPage/Activate (This, hWndParent,
		pRect, bModal) => (status :: <HRESULT>);

define C-callable-wrapper of IPropertyPage/Activate
  input parameter This :: <mapped-interface>;
  input parameter hWndParent :: <HWND>;
  input parameter pRect :: <LPCRECT>;
  input parameter bModal :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyPage_Activate", c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyPage_Activate
  input parameter This :: <C-interface>;
  input parameter hWndParent :: <HWND>;
  input parameter pRect :: <LPCRECT>;
  input parameter bModal :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyPage_Activate";
end;

define method IPropertyPage/Activate(This :: <C-interface>,
		hWndParent :: <HWND>, pRect :: <LPCRECT>, bModal :: <boolean>)
		=> (status :: <HRESULT>)
  IPropertyPage_Activate(This, hWndParent, pRect, bModal)
end;

define open generic IPropertyPage/Deactivate (This)
		=> (status :: <HRESULT>);

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

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

define method IPropertyPage/Deactivate(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IPropertyPage_Deactivate(This)
end;

define open generic IPropertyPage/GetPageInfo (This, pPageInfo)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPropertyPage/GetPageInfo
  input parameter This :: <mapped-interface>;
  parameter pPageInfo :: <LPPROPPAGEINFO>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyPage_GetPageInfo",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyPage_GetPageInfo
  input parameter This :: <C-interface>;
  parameter pPageInfo :: <LPPROPPAGEINFO>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyPage_GetPageInfo";
end;

define method IPropertyPage/GetPageInfo(This :: <C-interface>,
		pPageInfo :: <LPPROPPAGEINFO>) => (status :: <HRESULT>)
  IPropertyPage_GetPageInfo(This, pPageInfo)
end;

define open generic IPropertyPage/SetObjects (This, cObjects,
		ppUnk) => (status :: <HRESULT>);

define C-callable-wrapper of IPropertyPage/SetObjects
  input parameter This :: <mapped-interface>;
  input parameter cObjects :: <ULONG>;
  input parameter ppUnk :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyPage_SetObjects",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyPage_SetObjects
  input parameter This :: <C-interface>;
  input parameter cObjects :: <ULONG>;
  input parameter ppUnk :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyPage_SetObjects";
end;

define method IPropertyPage/SetObjects(This :: <C-interface>,
		cObjects, ppUnk) => (status :: <HRESULT>)
  IPropertyPage_SetObjects(This, cObjects, ppUnk)
end;

define open generic IPropertyPage/Show (This, nCmdShow)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPropertyPage/Show
  input parameter This :: <mapped-interface>;
  input parameter nCmdShow :: <UINT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyPage_Show", c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyPage_Show
  input parameter This :: <C-interface>;
  input parameter nCmdShow :: <UINT>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyPage_Show";
end;

define method IPropertyPage/Show(This :: <C-interface>, nCmdShow)
		=> (status :: <HRESULT>)
  IPropertyPage_Show(This, nCmdShow)
end;

define open generic IPropertyPage/Move (This, pRect)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPropertyPage/Move
  input parameter This :: <mapped-interface>;
  input parameter pRect :: <LPCRECT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyPage_Move", c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyPage_Move
  input parameter This :: <C-interface>;
  input parameter pRect :: <LPCRECT>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyPage_Move";
end;

define method IPropertyPage/Move(This :: <C-interface>,
		pRect :: <LPCRECT>) => (status :: <HRESULT>)
  IPropertyPage_Move(This, pRect)
end;

define open generic IPropertyPage/IsPageDirty (This)
		=> (status :: <HRESULT>);

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

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

define method IPropertyPage/IsPageDirty(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IPropertyPage_IsPageDirty(This)
end;

define open generic IPropertyPage/Apply (This)
		=> (status :: <HRESULT>);

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

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

define method IPropertyPage/Apply(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IPropertyPage_Apply(This)
end;

define open generic IPropertyPage/Help (This, pszHelpDir)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPropertyPage/Help
  input parameter This :: <mapped-interface>;
  input parameter pszHelpDir :: <LPCOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyPage_Help", c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyPage_Help
  input parameter This :: <C-interface>;
  input parameter pszHelpDir :: <LPCOLESTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyPage_Help";
end;

define method IPropertyPage/Help(This :: <C-interface>,
		pszHelpDir :: <string>) => (status :: <HRESULT>)
  IPropertyPage_Help(This, pszHelpDir)
end;

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

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

define inline-only C-function IPropertyPage_TranslateAccelerator
  input parameter This :: <C-interface>;
  input parameter pMsg :: <LPMSG>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyPage_TranslateAccelerator";
end;

define method IPropertyPage/TranslateAccelerator(This :: <C-interface>,
		pMsg :: <LPMSG>) => (status :: <HRESULT>)
  IPropertyPage_TranslateAccelerator(This, pMsg)
end;


	/*  ----  IPropertyPage2  ----  */


define open primary COM-interface <IPropertyPage2> ( <IPropertyPage> )
end <IPropertyPage2>;

define C-address IPropertyPage2_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPropertyPage2_DW_vtbl"; end;
define C-address $IID-IPropertyPage2 :: <REFIID>
		c-name: "IID_IPropertyPage2"; end;

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

define open generic IPropertyPage2/EditProperty (This, dispID)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPropertyPage2/EditProperty
  input parameter This :: <mapped-interface>;
  input parameter dispID :: <DISPID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyPage2_EditProperty",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyPage2_EditProperty
  input parameter This :: <C-interface>;
  input parameter dispID :: <DISPID>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyPage2_EditProperty";
end;

define method IPropertyPage2/EditProperty(This :: <C-interface>,
		dispID) => (status :: <HRESULT>)
  IPropertyPage2_EditProperty(This, dispID)
end;


	/*  ----  IPropertyPageSite  ----  */


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

define C-address IPropertyPageSite_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPropertyPageSite_DW_vtbl"; end;
define C-address $IID-IPropertyPageSite :: <REFIID>
		c-name: "IID_IPropertyPageSite"; end;

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

define open generic IPropertyPageSite/OnStatusChange (This,
		dwFlags) => (status :: <HRESULT>);

define C-callable-wrapper of IPropertyPageSite/OnStatusChange
  input parameter This :: <mapped-interface>;
  input parameter dwFlags :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyPageSite_OnStatusChange",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyPageSite_OnStatusChange
  input parameter This :: <C-interface>;
  input parameter dwFlags :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyPageSite_OnStatusChange";
end;

define method IPropertyPageSite/OnStatusChange(This :: <C-interface>,
		dwFlags) => (status :: <HRESULT>)
  IPropertyPageSite_OnStatusChange(This, dwFlags)
end;

define open generic IPropertyPageSite/GetLocaleID (This,
		pLocaleID) => (status :: <HRESULT>);

define C-callable-wrapper of IPropertyPageSite/GetLocaleID
  input parameter This :: <mapped-interface>;
  parameter pLocaleID :: <LPLCID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyPageSite_GetLocaleID",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyPageSite_GetLocaleID
  input parameter This :: <C-interface>;
  parameter pLocaleID :: <LPLCID>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyPageSite_GetLocaleID";
end;

define method IPropertyPageSite/GetLocaleID(This :: <C-interface>,
		pLocaleID :: <LPLCID>) => (status :: <HRESULT>)
  IPropertyPageSite_GetLocaleID(This, pLocaleID)
end;

define open generic IPropertyPageSite/GetPageContainer (This)
		=> (status :: <HRESULT>, pUnk :: <Interface>);

define C-callable-wrapper of IPropertyPageSite/GetPageContainer
  input parameter This :: <mapped-interface>;
  output parameter ppUnk :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyPageSite_GetPageContainer",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyPageSite_GetPageContainer
  input parameter This :: <C-interface>;
  output parameter ppUnk :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyPageSite_GetPageContainer";
end;

define method IPropertyPageSite/GetPageContainer(This :: <C-interface>)
		=> (status :: <HRESULT>, pUnk :: <Interface>)
  IPropertyPageSite_GetPageContainer(This)
end;

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

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

define inline-only C-function IPropertyPageSite_TranslateAccelerator
  input parameter This :: <C-interface>;
  input parameter pMsg :: <LPMSG>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyPageSite_TranslateAccelerator";
end;

define method IPropertyPageSite/TranslateAccelerator(This :: <C-interface>,
		pMsg :: <LPMSG>) => (status :: <HRESULT>)
  IPropertyPageSite_TranslateAccelerator(This, pMsg)
end;


	/*  ----  IPropertyNotifySink  ----  */


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

define C-address IPropertyNotifySink_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPropertyNotifySink_DW_vtbl"; end;
define C-address $IID-IPropertyNotifySink :: <REFIID>
		c-name: "IID_IPropertyNotifySink"; end;

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

define open generic IPropertyNotifySink/OnChanged (This, dispID)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPropertyNotifySink/OnChanged
  input parameter This :: <mapped-interface>;
  input parameter dispID :: <DISPID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyNotifySink_OnChanged",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyNotifySink_OnChanged
  input parameter This :: <C-interface>;
  input parameter dispID :: <DISPID>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyNotifySink_OnChanged";
end;

define method IPropertyNotifySink/OnChanged(This :: <C-interface>,
		dispID) => (status :: <HRESULT>)
  IPropertyNotifySink_OnChanged(This, dispID)
end;

define open generic IPropertyNotifySink/OnRequestEdit (This,
		dispID) => (status :: <HRESULT>);

define C-callable-wrapper of IPropertyNotifySink/OnRequestEdit
  input parameter This :: <mapped-interface>;
  input parameter dispID :: <DISPID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyNotifySink_OnRequestEdit",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyNotifySink_OnRequestEdit
  input parameter This :: <C-interface>;
  input parameter dispID :: <DISPID>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyNotifySink_OnRequestEdit";
end;

define method IPropertyNotifySink/OnRequestEdit(This :: <C-interface>,
		dispID) => (status :: <HRESULT>)
  IPropertyNotifySink_OnRequestEdit(This, dispID)
end;


	/*  ----  ISpecifyPropertyPages  ----  */


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

define C-address ISpecifyPropertyPages_DW_vtbl :: <C-COM-vtbl>
		c-name: "ISpecifyPropertyPages_DW_vtbl"; end;
define C-address $IID-ISpecifyPropertyPages :: <REFIID>
		c-name: "IID_ISpecifyPropertyPages"; end;

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

define open generic ISpecifyPropertyPages/GetPages (This, pPages)
		=> (status :: <HRESULT>);

define C-callable-wrapper of ISpecifyPropertyPages/GetPages
  input parameter This :: <mapped-interface>;
  parameter pPages :: <LPCAUUID>;
  result status :: <C-HRESULT>;
  c-name: "DW_ISpecifyPropertyPages_GetPages",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ISpecifyPropertyPages_GetPages
  input parameter This :: <C-interface>;
  parameter pPages :: <LPCAUUID>;
  result status :: <C-HRESULT>;
  c-name: "C_ISpecifyPropertyPages_GetPages";
end;

define method ISpecifyPropertyPages/GetPages(This :: <C-interface>,
		pPages :: <LPCAUUID>) => (status :: <HRESULT>)
  ISpecifyPropertyPages_GetPages(This, pPages)
end;


	/*  ----  IPersistMemory  ----  */


define open primary COM-interface <IPersistMemory> ( <IPersist> )
end <IPersistMemory>;

define C-address IPersistMemory_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPersistMemory_DW_vtbl"; end;
define C-address $IID-IPersistMemory :: <REFIID>
		c-name: "IID_IPersistMemory"; end;

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

define open generic IPersistMemory/IsDirty (This)
		=> (status :: <HRESULT>);

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

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

define method IPersistMemory/IsDirty(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IPersistMemory_IsDirty(This)
end;

define open generic IPersistMemory/Load (This, pMem, cbSize)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPersistMemory/Load
  input parameter This :: <mapped-interface>;
  input parameter pMem :: <LPVOID>;
  input parameter cbSize :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistMemory_Load", c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistMemory_Load
  input parameter This :: <C-interface>;
  input parameter pMem :: <LPVOID>;
  input parameter cbSize :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistMemory_Load";
end;

define method IPersistMemory/Load(This :: <C-interface>,
		pMem :: <C-pointer>, cbSize) => (status :: <HRESULT>)
  IPersistMemory_Load(This, pMem, cbSize)
end;

define open generic IPersistMemory/Save (This, pMem, fClearDirty,
		cbSize) => (status :: <HRESULT>);

define C-callable-wrapper of IPersistMemory/Save
  input parameter This :: <mapped-interface>;
   parameter pMem :: <LPVOID>;
  input parameter fClearDirty :: <BOOL>;
  input parameter cbSize :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistMemory_Save", c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistMemory_Save
  input parameter This :: <C-interface>;
   parameter pMem :: <LPVOID>;
  input parameter fClearDirty :: <BOOL>;
  input parameter cbSize :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistMemory_Save";
end;

define method IPersistMemory/Save(This :: <C-interface>,
		pMem :: <C-pointer>, fClearDirty :: <boolean>, cbSize)
		=> (status :: <HRESULT>)
  IPersistMemory_Save(This, pMem, fClearDirty, cbSize)
end;

define open generic IPersistMemory/GetSizeMax (This)
		=> (status :: <HRESULT>, CbSize);

define C-callable-wrapper of IPersistMemory/GetSizeMax
  input parameter This :: <mapped-interface>;
  output parameter pCbSize :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistMemory_GetSizeMax",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistMemory_GetSizeMax
  input parameter This :: <C-interface>;
  output parameter pCbSize :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistMemory_GetSizeMax";
end;

define method IPersistMemory/GetSizeMax(This :: <C-interface>)
		=> (status :: <HRESULT>, CbSize)
  IPersistMemory_GetSizeMax(This)
end;

define open generic IPersistMemory/InitNew (This)
		=> (status :: <HRESULT>);

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

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

define method IPersistMemory/InitNew(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IPersistMemory_InitNew(This)
end;


	/*  ----  IPersistStreamInit  ----  */


define open primary COM-interface <IPersistStreamInit> ( <IPersist> )
end <IPersistStreamInit>;

define C-address IPersistStreamInit_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPersistStreamInit_DW_vtbl"; end;
define C-address $IID-IPersistStreamInit :: <REFIID>
		c-name: "IID_IPersistStreamInit"; end;

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

define open generic IPersistStreamInit/IsDirty (This)
		=> (status :: <HRESULT>);

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

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

define method IPersistStreamInit/IsDirty(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IPersistStreamInit_IsDirty(This)
end;

define open generic IPersistStreamInit/Load (This, pStm)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPersistStreamInit/Load
  input parameter This :: <mapped-interface>;
  input parameter pStm :: <LPSTREAM>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistStreamInit_Load",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistStreamInit_Load
  input parameter This :: <C-interface>;
  input parameter pStm :: <LPSTREAM>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistStreamInit_Load";
end;

define method IPersistStreamInit/Load(This :: <C-interface>,
		pStm :: <LPSTREAM>) => (status :: <HRESULT>)
  IPersistStreamInit_Load(This, pStm)
end;

define open generic IPersistStreamInit/Save (This, pStm,
		fClearDirty) => (status :: <HRESULT>);

define C-callable-wrapper of IPersistStreamInit/Save
  input parameter This :: <mapped-interface>;
  input parameter pStm :: <LPSTREAM>;
  input parameter fClearDirty :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistStreamInit_Save",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistStreamInit_Save
  input parameter This :: <C-interface>;
  input parameter pStm :: <LPSTREAM>;
  input parameter fClearDirty :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistStreamInit_Save";
end;

define method IPersistStreamInit/Save(This :: <C-interface>,
		pStm :: <LPSTREAM>, fClearDirty :: <boolean>)
		=> (status :: <HRESULT>)
  IPersistStreamInit_Save(This, pStm, fClearDirty)
end;

define open generic IPersistStreamInit/GetSizeMax (This, pCbSize)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPersistStreamInit/GetSizeMax
  input parameter This :: <mapped-interface>;
  parameter pCbSize :: <PULARGE-INTEGER>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistStreamInit_GetSizeMax",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistStreamInit_GetSizeMax
  input parameter This :: <C-interface>;
  parameter pCbSize :: <PULARGE-INTEGER>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistStreamInit_GetSizeMax";
end;

define method IPersistStreamInit/GetSizeMax(This :: <C-interface>,
		pCbSize) => (status :: <HRESULT>)
  IPersistStreamInit_GetSizeMax(This, pCbSize)
end;

define open generic IPersistStreamInit/InitNew (This)
		=> (status :: <HRESULT>);

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

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

define method IPersistStreamInit/InitNew(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IPersistStreamInit_InitNew(This)
end;


	/*  ----  IPersistPropertyBag  ----  */


define open primary COM-interface <IPersistPropertyBag> ( <IPersist> )
end <IPersistPropertyBag>;

define C-address IPersistPropertyBag_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPersistPropertyBag_DW_vtbl"; end;
define C-address $IID-IPersistPropertyBag :: <REFIID>
		c-name: "IID_IPersistPropertyBag"; end;

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

define open generic IPersistPropertyBag/InitNew (This)
		=> (status :: <HRESULT>);

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

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

define method IPersistPropertyBag/InitNew(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IPersistPropertyBag_InitNew(This)
end;

define open generic IPersistPropertyBag/Load (This, pPropBag,
		pErrorLog) => (status :: <HRESULT>);

define C-callable-wrapper of IPersistPropertyBag/Load
  input parameter This :: <mapped-interface>;
  input parameter pPropBag :: <C-interface>;
  input parameter pErrorLog :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistPropertyBag_Load",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistPropertyBag_Load
  input parameter This :: <C-interface>;
  input parameter pPropBag :: <Interface>;
  input parameter pErrorLog :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistPropertyBag_Load";
end;

define method IPersistPropertyBag/Load(This :: <C-interface>,
		pPropBag :: <Interface>, pErrorLog :: <Interface>)
		=> (status :: <HRESULT>)
  IPersistPropertyBag_Load(This, pPropBag, pErrorLog)
end;

define open generic IPersistPropertyBag/Save (This, pPropBag,
		fClearDirty, fSaveAllProperties) => (status :: <HRESULT>);

define C-callable-wrapper of IPersistPropertyBag/Save
  input parameter This :: <mapped-interface>;
  input parameter pPropBag :: <C-interface>;
  input parameter fClearDirty :: <BOOL>;
  input parameter fSaveAllProperties :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistPropertyBag_Save",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistPropertyBag_Save
  input parameter This :: <C-interface>;
  input parameter pPropBag :: <Interface>;
  input parameter fClearDirty :: <BOOL>;
  input parameter fSaveAllProperties :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistPropertyBag_Save";
end;

define method IPersistPropertyBag/Save(This :: <C-interface>,
		pPropBag :: <Interface>, fClearDirty :: <boolean>,
		fSaveAllProperties :: <boolean>) => (status :: <HRESULT>)
  IPersistPropertyBag_Save(This, pPropBag, fClearDirty,
		fSaveAllProperties)
end;


	/*  ----  ISimpleFrameSite  ----  */


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

define C-address ISimpleFrameSite_DW_vtbl :: <C-COM-vtbl>
		c-name: "ISimpleFrameSite_DW_vtbl"; end;
define C-address $IID-ISimpleFrameSite :: <REFIID>
		c-name: "IID_ISimpleFrameSite"; end;

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

define open generic ISimpleFrameSite/PreMessageFilter (This,
		hWnd, msg, wp, lp)
		=> (status :: <HRESULT>, lResult, dwCookie);

define C-callable-wrapper of ISimpleFrameSite/PreMessageFilter
  input parameter This :: <mapped-interface>;
  input parameter hWnd :: <HWND>;
  input parameter msg :: <UINT>;
  input parameter wp :: <WPARAM>;
  input parameter lp :: <LPARAM>;
  output parameter plResult :: <LPLRESULT>;
  output parameter pdwCookie :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_ISimpleFrameSite_PreMessageFilter",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ISimpleFrameSite_PreMessageFilter
  input parameter This :: <C-interface>;
  input parameter hWnd :: <HWND>;
  input parameter msg :: <UINT>;
  input parameter wp :: <WPARAM>;
  input parameter lp :: <LPARAM>;
  output parameter plResult :: <LPLRESULT>;
  output parameter pdwCookie :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_ISimpleFrameSite_PreMessageFilter";
end;

define method ISimpleFrameSite/PreMessageFilter(This :: <C-interface>,
		hWnd :: <HWND>, msg, wp, lp)
		=> (status :: <HRESULT>, lResult, dwCookie)
  ISimpleFrameSite_PreMessageFilter(This, hWnd, msg, wp, lp)
end;

define open generic ISimpleFrameSite/PostMessageFilter (This,
		hWnd, msg, wp, lp, dwCookie)
		=> (status :: <HRESULT>, lResult);

define C-callable-wrapper of ISimpleFrameSite/PostMessageFilter
  input parameter This :: <mapped-interface>;
  input parameter hWnd :: <HWND>;
  input parameter msg :: <UINT>;
  input parameter wp :: <WPARAM>;
  input parameter lp :: <LPARAM>;
  output parameter plResult :: <LPLRESULT>;
  input parameter dwCookie :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_ISimpleFrameSite_PostMessageFilter",
		c-modifiers: "__stdcall";
end;

define inline-only C-function ISimpleFrameSite_PostMessageFilter
  input parameter This :: <C-interface>;
  input parameter hWnd :: <HWND>;
  input parameter msg :: <UINT>;
  input parameter wp :: <WPARAM>;
  input parameter lp :: <LPARAM>;
  output parameter plResult :: <LPLRESULT>;
  input parameter dwCookie :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_ISimpleFrameSite_PostMessageFilter";
end;

define method ISimpleFrameSite/PostMessageFilter(This :: <C-interface>,
		hWnd :: <HWND>, msg, wp, lp, dwCookie)
		=> (status :: <HRESULT>, lResult)
  ISimpleFrameSite_PostMessageFilter(This, hWnd, msg, wp, lp,
		dwCookie)
end;


	/*  ----  IFont  ----  */


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

define C-address IFont_DW_vtbl :: <C-COM-vtbl>
		c-name: "IFont_DW_vtbl"; end;
define C-address $IID-IFont :: <REFIID>
		c-name: "IID_IFont"; end;

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

define open generic IFont/get-Name (This)
		=> (status :: <HRESULT>, Name :: <BSTR>);

define C-callable-wrapper of IFont/get-Name
  input parameter This :: <mapped-interface>;
  output parameter pName :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_get_Name", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_get_Name
  input parameter This :: <C-interface>;
  output parameter pName :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_get_Name";
end;

define method IFont/get-Name(This :: <C-interface>)
		=> (status :: <HRESULT>, Name :: <BSTR>)
  IFont_get_Name(This)
end;

define open generic IFont/put-Name (This, name)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IFont/put-Name
  input parameter This :: <mapped-interface>;
  input parameter name :: <BSTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_put_Name", c-modifiers: "__stdcall";
end;

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

define method IFont/put-Name(This :: <C-interface>, name)
		=> (status :: <HRESULT>)
  IFont_put_Name(This, name)
end;

define open generic IFont/get-Size (This, pSize)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IFont/get-Size
  input parameter This :: <mapped-interface>;
  parameter pSize :: <LPCY>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_get_Size", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_get_Size
  input parameter This :: <C-interface>;
  parameter pSize :: <LPCY>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_get_Size";
end;

define method IFont/get-Size(This :: <C-interface>,
		pSize :: <LPCY>) => (status :: <HRESULT>)
  IFont_get_Size(This, pSize)
end;

define open generic IFont/put-Size (This, size)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IFont/put-Size
  input parameter This :: <mapped-interface>;
  input parameter size :: <CY>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_put_Size", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_put_Size
  input parameter This :: <C-interface>;
  input parameter size :: <CY>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_put_Size";
end;

define method IFont/put-Size(This :: <C-interface>, size)
		=> (status :: <HRESULT>)
  IFont_put_Size(This, size)
end;

define open generic IFont/get-Bold (This)
		=> (status :: <HRESULT>, Bold :: <boolean>);

define C-callable-wrapper of IFont/get-Bold
  input parameter This :: <mapped-interface>;
  output parameter pBold :: <LPBOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_get_Bold", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_get_Bold
  input parameter This :: <C-interface>;
  output parameter pBold :: <LPBOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_get_Bold";
end;

define method IFont/get-Bold(This :: <C-interface>)
		=> (status :: <HRESULT>, Bold :: <boolean>)
  IFont_get_Bold(This)
end;

define open generic IFont/put-Bold (This, bold)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IFont/put-Bold
  input parameter This :: <mapped-interface>;
  input parameter bold :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_put_Bold", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_put_Bold
  input parameter This :: <C-interface>;
  input parameter bold :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_put_Bold";
end;

define method IFont/put-Bold(This :: <C-interface>,
		bold :: <boolean>) => (status :: <HRESULT>)
  IFont_put_Bold(This, bold)
end;

define open generic IFont/get-Italic (This)
		=> (status :: <HRESULT>, Italic :: <boolean>);

define C-callable-wrapper of IFont/get-Italic
  input parameter This :: <mapped-interface>;
  output parameter pItalic :: <LPBOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_get_Italic", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_get_Italic
  input parameter This :: <C-interface>;
  output parameter pItalic :: <LPBOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_get_Italic";
end;

define method IFont/get-Italic(This :: <C-interface>)
		=> (status :: <HRESULT>, Italic :: <boolean>)
  IFont_get_Italic(This)
end;

define open generic IFont/put-Italic (This, italic)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IFont/put-Italic
  input parameter This :: <mapped-interface>;
  input parameter italic :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_put_Italic", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_put_Italic
  input parameter This :: <C-interface>;
  input parameter italic :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_put_Italic";
end;

define method IFont/put-Italic(This :: <C-interface>,
		italic :: <boolean>) => (status :: <HRESULT>)
  IFont_put_Italic(This, italic)
end;

define open generic IFont/get-Underline (This)
		=> (status :: <HRESULT>, Underline :: <boolean>);

define C-callable-wrapper of IFont/get-Underline
  input parameter This :: <mapped-interface>;
  output parameter pUnderline :: <LPBOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_get_Underline", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_get_Underline
  input parameter This :: <C-interface>;
  output parameter pUnderline :: <LPBOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_get_Underline";
end;

define method IFont/get-Underline(This :: <C-interface>)
		=> (status :: <HRESULT>, Underline :: <boolean>)
  IFont_get_Underline(This)
end;

define open generic IFont/put-Underline (This, underline)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IFont/put-Underline
  input parameter This :: <mapped-interface>;
  input parameter underline :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_put_Underline", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_put_Underline
  input parameter This :: <C-interface>;
  input parameter underline :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_put_Underline";
end;

define method IFont/put-Underline(This :: <C-interface>,
		underline :: <boolean>) => (status :: <HRESULT>)
  IFont_put_Underline(This, underline)
end;

define open generic IFont/get-Strikethrough (This)
		=> (status :: <HRESULT>, Strikethrough :: <boolean>);

define C-callable-wrapper of IFont/get-Strikethrough
  input parameter This :: <mapped-interface>;
  output parameter pStrikethrough :: <LPBOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_get_Strikethrough",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_get_Strikethrough
  input parameter This :: <C-interface>;
  output parameter pStrikethrough :: <LPBOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_get_Strikethrough";
end;

define method IFont/get-Strikethrough(This :: <C-interface>)
		=> (status :: <HRESULT>, Strikethrough :: <boolean>)
  IFont_get_Strikethrough(This)
end;

define open generic IFont/put-Strikethrough (This, strikethrough)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IFont/put-Strikethrough
  input parameter This :: <mapped-interface>;
  input parameter strikethrough :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_put_Strikethrough",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_put_Strikethrough
  input parameter This :: <C-interface>;
  input parameter strikethrough :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_put_Strikethrough";
end;

define method IFont/put-Strikethrough(This :: <C-interface>,
		strikethrough :: <boolean>) => (status :: <HRESULT>)
  IFont_put_Strikethrough(This, strikethrough)
end;

define open generic IFont/get-Weight (This)
		=> (status :: <HRESULT>, Weight :: <integer>);

define C-callable-wrapper of IFont/get-Weight
  input parameter This :: <mapped-interface>;
  output parameter pWeight :: <LPSHORT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_get_Weight", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_get_Weight
  input parameter This :: <C-interface>;
  output parameter pWeight :: <LPSHORT>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_get_Weight";
end;

define method IFont/get-Weight(This :: <C-interface>)
		=> (status :: <HRESULT>, Weight :: <integer>)
  IFont_get_Weight(This)
end;

define open generic IFont/put-Weight (This, weight)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IFont/put-Weight
  input parameter This :: <mapped-interface>;
  input parameter weight :: <SHORT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_put_Weight", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_put_Weight
  input parameter This :: <C-interface>;
  input parameter weight :: <SHORT>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_put_Weight";
end;

define method IFont/put-Weight(This :: <C-interface>, weight)
		=> (status :: <HRESULT>)
  IFont_put_Weight(This, weight)
end;

define open generic IFont/get-Charset (This)
		=> (status :: <HRESULT>, Charset :: <integer>);

define C-callable-wrapper of IFont/get-Charset
  input parameter This :: <mapped-interface>;
  output parameter pCharset :: <LPSHORT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_get_Charset", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_get_Charset
  input parameter This :: <C-interface>;
  output parameter pCharset :: <LPSHORT>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_get_Charset";
end;

define method IFont/get-Charset(This :: <C-interface>)
		=> (status :: <HRESULT>, Charset :: <integer>)
  IFont_get_Charset(This)
end;

define open generic IFont/put-Charset (This, charset)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IFont/put-Charset
  input parameter This :: <mapped-interface>;
  input parameter charset :: <SHORT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_put_Charset", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_put_Charset
  input parameter This :: <C-interface>;
  input parameter charset :: <SHORT>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_put_Charset";
end;

define method IFont/put-Charset(This :: <C-interface>, charset)
		=> (status :: <HRESULT>)
  IFont_put_Charset(This, charset)
end;

define open generic IFont/get-hFont (This)
		=> (status :: <HRESULT>, hFont);

define C-callable-wrapper of IFont/get-hFont
  input parameter This :: <mapped-interface>;
  output parameter phFont :: <LPHFONT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_get_hFont", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_get_hFont
  input parameter This :: <C-interface>;
  output parameter phFont :: <LPHFONT>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_get_hFont";
end;

define method IFont/get-hFont(This :: <C-interface>)
		=> (status :: <HRESULT>, hFont)
  IFont_get_hFont(This)
end;

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

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

define inline-only C-function IFont_Clone
  input parameter This :: <C-interface>;
  output parameter ppFont :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_Clone";
end;

define method IFont/Clone(This :: <C-interface>)
		=> (status :: <HRESULT>, pFont :: <Interface>)
  IFont_Clone(This)
end;

define open generic IFont/IsEqual (This, pFontOther)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IFont/IsEqual
  input parameter This :: <mapped-interface>;
  input parameter pFontOther :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_IsEqual", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_IsEqual
  input parameter This :: <C-interface>;
  input parameter pFontOther :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_IsEqual";
end;

define method IFont/IsEqual(This :: <C-interface>,
		pFontOther :: <Interface>) => (status :: <HRESULT>)
  IFont_IsEqual(This, pFontOther)
end;

define open generic IFont/SetRatio (This, cyLogical, cyHimetric)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IFont/SetRatio
  input parameter This :: <mapped-interface>;
  input parameter cyLogical :: <LONG>;
  input parameter cyHimetric :: <LONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_SetRatio", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_SetRatio
  input parameter This :: <C-interface>;
  input parameter cyLogical :: <LONG>;
  input parameter cyHimetric :: <LONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_SetRatio";
end;

define method IFont/SetRatio(This :: <C-interface>, cyLogical,
		cyHimetric) => (status :: <HRESULT>)
  IFont_SetRatio(This, cyLogical, cyHimetric)
end;

define open generic IFont/QueryTextMetrics (This, pTM)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IFont/QueryTextMetrics
  input parameter This :: <mapped-interface>;
  parameter pTM :: <LPTEXTMETRICOLE>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_QueryTextMetrics", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_QueryTextMetrics
  input parameter This :: <C-interface>;
  parameter pTM :: <LPTEXTMETRICOLE>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_QueryTextMetrics";
end;

define method IFont/QueryTextMetrics(This :: <C-interface>,
		pTM :: <LPTEXTMETRICOLE>) => (status :: <HRESULT>)
  IFont_QueryTextMetrics(This, pTM)
end;

define open generic IFont/AddRefHfont (This, hFont)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IFont/AddRefHfont
  input parameter This :: <mapped-interface>;
  input parameter hFont :: <HFONT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_AddRefHfont", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_AddRefHfont
  input parameter This :: <C-interface>;
  input parameter hFont :: <HFONT>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_AddRefHfont";
end;

define method IFont/AddRefHfont(This :: <C-interface>,
		hFont :: <HFONT>) => (status :: <HRESULT>)
  IFont_AddRefHfont(This, hFont)
end;

define open generic IFont/ReleaseHfont (This, hFont)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IFont/ReleaseHfont
  input parameter This :: <mapped-interface>;
  input parameter hFont :: <HFONT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_ReleaseHfont", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_ReleaseHfont
  input parameter This :: <C-interface>;
  input parameter hFont :: <HFONT>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_ReleaseHfont";
end;

define method IFont/ReleaseHfont(This :: <C-interface>,
		hFont :: <HFONT>) => (status :: <HRESULT>)
  IFont_ReleaseHfont(This, hFont)
end;

define open generic IFont/SetHdc (This, hDC)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IFont/SetHdc
  input parameter This :: <mapped-interface>;
  input parameter hDC :: <HDC>;
  result status :: <C-HRESULT>;
  c-name: "DW_IFont_SetHdc", c-modifiers: "__stdcall";
end;

define inline-only C-function IFont_SetHdc
  input parameter This :: <C-interface>;
  input parameter hDC :: <HDC>;
  result status :: <C-HRESULT>;
  c-name: "C_IFont_SetHdc";
end;

define method IFont/SetHdc(This :: <C-interface>, hDC :: <HDC>)
		=> (status :: <HRESULT>)
  IFont_SetHdc(This, hDC)
end;


	/*  ----  IPicture  ----  */


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

define C-address IPicture_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPicture_DW_vtbl"; end;
define C-address $IID-IPicture :: <REFIID>
		c-name: "IID_IPicture"; end;

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

define open generic IPicture/get-Handle (This)
		=> (status :: <HRESULT>, Handle);

define C-callable-wrapper of IPicture/get-Handle
  input parameter This :: <mapped-interface>;
  output parameter pHandle :: <LPOLE-HANDLE>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPicture_get_Handle", c-modifiers: "__stdcall";
end;

define inline-only C-function IPicture_get_Handle
  input parameter This :: <C-interface>;
  output parameter pHandle :: <LPOLE-HANDLE>;
  result status :: <C-HRESULT>;
  c-name: "C_IPicture_get_Handle";
end;

define method IPicture/get-Handle(This :: <C-interface>)
		=> (status :: <HRESULT>, Handle)
  IPicture_get_Handle(This)
end;

define open generic IPicture/get-hPal (This)
		=> (status :: <HRESULT>, hPal);

define C-callable-wrapper of IPicture/get-hPal
  input parameter This :: <mapped-interface>;
  output parameter phPal :: <LPOLE-HANDLE>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPicture_get_hPal", c-modifiers: "__stdcall";
end;

define inline-only C-function IPicture_get_hPal
  input parameter This :: <C-interface>;
  output parameter phPal :: <LPOLE-HANDLE>;
  result status :: <C-HRESULT>;
  c-name: "C_IPicture_get_hPal";
end;

define method IPicture/get-hPal(This :: <C-interface>)
		=> (status :: <HRESULT>, hPal)
  IPicture_get_hPal(This)
end;

define open generic IPicture/get-Type (This)
		=> (status :: <HRESULT>, Type :: <integer>);

define C-callable-wrapper of IPicture/get-Type
  input parameter This :: <mapped-interface>;
  output parameter pType :: <LPSHORT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPicture_get_Type", c-modifiers: "__stdcall";
end;

define inline-only C-function IPicture_get_Type
  input parameter This :: <C-interface>;
  output parameter pType :: <LPSHORT>;
  result status :: <C-HRESULT>;
  c-name: "C_IPicture_get_Type";
end;

define method IPicture/get-Type(This :: <C-interface>)
		=> (status :: <HRESULT>, Type :: <integer>)
  IPicture_get_Type(This)
end;

define open generic IPicture/get-Width (This)
		=> (status :: <HRESULT>, Width);

define C-callable-wrapper of IPicture/get-Width
  input parameter This :: <mapped-interface>;
  output parameter pWidth :: <LPOLE-XSIZE-HIMETRIC>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPicture_get_Width", c-modifiers: "__stdcall";
end;

define inline-only C-function IPicture_get_Width
  input parameter This :: <C-interface>;
  output parameter pWidth :: <LPOLE-XSIZE-HIMETRIC>;
  result status :: <C-HRESULT>;
  c-name: "C_IPicture_get_Width";
end;

define method IPicture/get-Width(This :: <C-interface>)
		=> (status :: <HRESULT>, Width)
  IPicture_get_Width(This)
end;

define open generic IPicture/get-Height (This)
		=> (status :: <HRESULT>, Height);

define C-callable-wrapper of IPicture/get-Height
  input parameter This :: <mapped-interface>;
  output parameter pHeight :: <LPOLE-YSIZE-HIMETRIC>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPicture_get_Height", c-modifiers: "__stdcall";
end;

define inline-only C-function IPicture_get_Height
  input parameter This :: <C-interface>;
  output parameter pHeight :: <LPOLE-YSIZE-HIMETRIC>;
  result status :: <C-HRESULT>;
  c-name: "C_IPicture_get_Height";
end;

define method IPicture/get-Height(This :: <C-interface>)
		=> (status :: <HRESULT>, Height)
  IPicture_get_Height(This)
end;

define open generic IPicture/Render (This, hDC, x, y, cx, cy,
		xSrc, ySrc, cxSrc, cySrc, pRcWBounds)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPicture/Render
  input parameter This :: <mapped-interface>;
  input parameter hDC :: <HDC>;
  input parameter x :: <LONG>;
  input parameter y :: <LONG>;
  input parameter cx :: <LONG>;
  input parameter cy :: <LONG>;
  input parameter xSrc :: <OLE-XPOS-HIMETRIC>;
  input parameter ySrc :: <OLE-YPOS-HIMETRIC>;
  input parameter cxSrc :: <OLE-XSIZE-HIMETRIC>;
  input parameter cySrc :: <OLE-YSIZE-HIMETRIC>;
  input parameter pRcWBounds :: <LPCRECT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPicture_Render", c-modifiers: "__stdcall";
end;

define inline-only C-function IPicture_Render
  input parameter This :: <C-interface>;
  input parameter hDC :: <HDC>;
  input parameter x :: <LONG>;
  input parameter y :: <LONG>;
  input parameter cx :: <LONG>;
  input parameter cy :: <LONG>;
  input parameter xSrc :: <OLE-XPOS-HIMETRIC>;
  input parameter ySrc :: <OLE-YPOS-HIMETRIC>;
  input parameter cxSrc :: <OLE-XSIZE-HIMETRIC>;
  input parameter cySrc :: <OLE-YSIZE-HIMETRIC>;
  input parameter pRcWBounds :: <LPCRECT>;
  result status :: <C-HRESULT>;
  c-name: "C_IPicture_Render";
end;

define method IPicture/Render(This :: <C-interface>,
		hDC :: <HDC>, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc,
		pRcWBounds :: <LPCRECT>) => (status :: <HRESULT>)
  IPicture_Render(This, hDC, x, y, cx, cy, xSrc, ySrc, cxSrc,
		cySrc, pRcWBounds)
end;

define open generic IPicture/set-hPal (This, hPal)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPicture/set-hPal
  input parameter This :: <mapped-interface>;
  input parameter hPal :: <OLE-HANDLE>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPicture_set_hPal", c-modifiers: "__stdcall";
end;

define inline-only C-function IPicture_set_hPal
  input parameter This :: <C-interface>;
  input parameter hPal :: <OLE-HANDLE>;
  result status :: <C-HRESULT>;
  c-name: "C_IPicture_set_hPal";
end;

define method IPicture/set-hPal(This :: <C-interface>, hPal)
		=> (status :: <HRESULT>)
  IPicture_set_hPal(This, hPal)
end;

define open generic IPicture/get-CurDC (This)
		=> (status :: <HRESULT>, hDC);

define C-callable-wrapper of IPicture/get-CurDC
  input parameter This :: <mapped-interface>;
  output parameter phDC :: <LPHDC>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPicture_get_CurDC", c-modifiers: "__stdcall";
end;

define inline-only C-function IPicture_get_CurDC
  input parameter This :: <C-interface>;
  output parameter phDC :: <LPHDC>;
  result status :: <C-HRESULT>;
  c-name: "C_IPicture_get_CurDC";
end;

define method IPicture/get-CurDC(This :: <C-interface>)
		=> (status :: <HRESULT>, hDC)
  IPicture_get_CurDC(This)
end;

define open generic IPicture/SelectPicture (This, hDCIn)
		=> (status :: <HRESULT>, hDCOut, hBmpOut);

define C-callable-wrapper of IPicture/SelectPicture
  input parameter This :: <mapped-interface>;
  input parameter hDCIn :: <HDC>;
  output parameter phDCOut :: <LPHDC>;
  output parameter phBmpOut :: <LPOLE-HANDLE>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPicture_SelectPicture", c-modifiers: "__stdcall";
end;

define inline-only C-function IPicture_SelectPicture
  input parameter This :: <C-interface>;
  input parameter hDCIn :: <HDC>;
  output parameter phDCOut :: <LPHDC>;
  output parameter phBmpOut :: <LPOLE-HANDLE>;
  result status :: <C-HRESULT>;
  c-name: "C_IPicture_SelectPicture";
end;

define method IPicture/SelectPicture(This :: <C-interface>,
		hDCIn :: <HDC>) => (status :: <HRESULT>, hDCOut, hBmpOut)
  IPicture_SelectPicture(This, hDCIn)
end;

define open generic IPicture/get-KeepOriginalFormat (This)
		=> (status :: <HRESULT>, Keep :: <boolean>);

define C-callable-wrapper of IPicture/get-KeepOriginalFormat
  input parameter This :: <mapped-interface>;
  output parameter pKeep :: <LPBOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPicture_get_KeepOriginalFormat",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPicture_get_KeepOriginalFormat
  input parameter This :: <C-interface>;
  output parameter pKeep :: <LPBOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IPicture_get_KeepOriginalFormat";
end;

define method IPicture/get-KeepOriginalFormat(This :: <C-interface>)
		=> (status :: <HRESULT>, Keep :: <boolean>)
  IPicture_get_KeepOriginalFormat(This)
end;

define open generic IPicture/put-KeepOriginalFormat (This, keep)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPicture/put-KeepOriginalFormat
  input parameter This :: <mapped-interface>;
  input parameter keep :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPicture_put_KeepOriginalFormat",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPicture_put_KeepOriginalFormat
  input parameter This :: <C-interface>;
  input parameter keep :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IPicture_put_KeepOriginalFormat";
end;

define method IPicture/put-KeepOriginalFormat(This :: <C-interface>,
		keep :: <boolean>) => (status :: <HRESULT>)
  IPicture_put_KeepOriginalFormat(This, keep)
end;

define open generic IPicture/PictureChanged (This)
		=> (status :: <HRESULT>);

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

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

define method IPicture/PictureChanged(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IPicture_PictureChanged(This)
end;

define open generic IPicture/SaveAsFile (This, pStream,
		fSaveMemCopy) => (status :: <HRESULT>, CbSize);

define C-callable-wrapper of IPicture/SaveAsFile
  input parameter This :: <mapped-interface>;
  input parameter pStream :: <LPSTREAM>;
  input parameter fSaveMemCopy :: <BOOL>;
  output parameter pCbSize :: <LPLONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPicture_SaveAsFile", c-modifiers: "__stdcall";
end;

define inline-only C-function IPicture_SaveAsFile
  input parameter This :: <C-interface>;
  input parameter pStream :: <LPSTREAM>;
  input parameter fSaveMemCopy :: <BOOL>;
  output parameter pCbSize :: <LPLONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IPicture_SaveAsFile";
end;

define method IPicture/SaveAsFile(This :: <C-interface>,
		pStream :: <LPSTREAM>, fSaveMemCopy :: <boolean>)
		=> (status :: <HRESULT>, CbSize)
  IPicture_SaveAsFile(This, pStream, fSaveMemCopy)
end;

define open generic IPicture/get-Attributes (This)
		=> (status :: <HRESULT>, DwAttr);

define C-callable-wrapper of IPicture/get-Attributes
  input parameter This :: <mapped-interface>;
  output parameter pDwAttr :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPicture_get_Attributes",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPicture_get_Attributes
  input parameter This :: <C-interface>;
  output parameter pDwAttr :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IPicture_get_Attributes";
end;

define method IPicture/get-Attributes(This :: <C-interface>)
		=> (status :: <HRESULT>, DwAttr)
  IPicture_get_Attributes(This)
end;


	/*  ----  IFontEventsDisp  ----  */


define open primary COM-interface <IFontEventsDisp> ( <IDispatch> )
end <IFontEventsDisp>;

define C-address IFontEventsDisp_DW_vtbl :: <C-COM-vtbl>
		c-name: "IFontEventsDisp_DW_vtbl"; end;
define C-address $IID-IFontEventsDisp :: <REFIID>
		c-name: "IID_IFontEventsDisp"; end;

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


	/*  ----  IFontDisp  ----  */


define open primary COM-interface <IFontDisp> ( <IDispatch> )
end <IFontDisp>;

define C-address IFontDisp_DW_vtbl :: <C-COM-vtbl>
		c-name: "IFontDisp_DW_vtbl"; end;
define C-address $IID-IFontDisp :: <REFIID>
		c-name: "IID_IFontDisp"; end;

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


	/*  ----  IPictureDisp  ----  */


define open primary COM-interface <IPictureDisp> ( <IDispatch> )
end <IPictureDisp>;

define C-address IPictureDisp_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPictureDisp_DW_vtbl"; end;
define C-address $IID-IPictureDisp :: <REFIID>
		c-name: "IID_IPictureDisp"; end;

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


	/*  ----  IOleInPlaceObjectWindowless  ----  */


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

define C-address IOleInPlaceObjectWindowless_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleInPlaceObjectWindowless_DW_vtbl"; end;
define C-address $IID-IOleInPlaceObjectWindowless :: <REFIID>
		c-name: "IID_IOleInPlaceObjectWindowless"; end;

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

define open generic IOleInPlaceObjectWindowless/OnWindowMessage
		(This, msg, wParam, lParam) => (status :: <HRESULT>, lResult);

define C-callable-wrapper
		of IOleInPlaceObjectWindowless/OnWindowMessage
  input parameter This :: <mapped-interface>;
  input parameter msg :: <UINT>;
  input parameter wParam :: <WPARAM>;
  input parameter lParam :: <LPARAM>;
  output parameter plResult :: <LPLRESULT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceObjectWindowless_OnWindowMessage",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceObjectWindowless_OnWindowMessage
  input parameter This :: <C-interface>;
  input parameter msg :: <UINT>;
  input parameter wParam :: <WPARAM>;
  input parameter lParam :: <LPARAM>;
  output parameter plResult :: <LPLRESULT>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceObjectWindowless_OnWindowMessage";
end;

define method IOleInPlaceObjectWindowless/OnWindowMessage(This :: <C-interface>,
		msg, wParam, lParam) => (status :: <HRESULT>, lResult)
  IOleInPlaceObjectWindowless_OnWindowMessage(This, msg, wParam,
		lParam)
end;

define open generic IOleInPlaceObjectWindowless/GetDropTarget
		(This) => (status :: <HRESULT>, pDropTarget :: <Interface>);

define C-callable-wrapper
		of IOleInPlaceObjectWindowless/GetDropTarget
  input parameter This :: <mapped-interface>;
  output parameter ppDropTarget :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceObjectWindowless_GetDropTarget",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceObjectWindowless_GetDropTarget
  input parameter This :: <C-interface>;
  output parameter ppDropTarget :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceObjectWindowless_GetDropTarget";
end;

define method IOleInPlaceObjectWindowless/GetDropTarget(This :: <C-interface>)
		=> (status :: <HRESULT>, pDropTarget :: <Interface>)
  IOleInPlaceObjectWindowless_GetDropTarget(This)
end;


	/*  ----  IOleInPlaceSiteEx  ----  */


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

define C-address IOleInPlaceSiteEx_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleInPlaceSiteEx_DW_vtbl"; end;
define C-address $IID-IOleInPlaceSiteEx :: <REFIID>
		c-name: "IID_IOleInPlaceSiteEx"; end;

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

define open generic IOleInPlaceSiteEx/OnInPlaceActivateEx (This,
		dwFlags) => (status :: <HRESULT>, fNoRedraw :: <boolean>);

define C-callable-wrapper
		of IOleInPlaceSiteEx/OnInPlaceActivateEx
  input parameter This :: <mapped-interface>;
  output parameter pfNoRedraw :: <LPBOOL>;
  input parameter dwFlags :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceSiteEx_OnInPlaceActivateEx",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSiteEx_OnInPlaceActivateEx
  input parameter This :: <C-interface>;
  output parameter pfNoRedraw :: <LPBOOL>;
  input parameter dwFlags :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSiteEx_OnInPlaceActivateEx";
end;

define method IOleInPlaceSiteEx/OnInPlaceActivateEx(This :: <C-interface>,
		dwFlags) => (status :: <HRESULT>, fNoRedraw :: <boolean>)
  IOleInPlaceSiteEx_OnInPlaceActivateEx(This, dwFlags)
end;

define open generic IOleInPlaceSiteEx/OnInPlaceDeactivateEx
		(This, fNoRedraw) => (status :: <HRESULT>);

define C-callable-wrapper
		of IOleInPlaceSiteEx/OnInPlaceDeactivateEx
  input parameter This :: <mapped-interface>;
  input parameter fNoRedraw :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceSiteEx_OnInPlaceDeactivateEx",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSiteEx_OnInPlaceDeactivateEx
  input parameter This :: <C-interface>;
  input parameter fNoRedraw :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSiteEx_OnInPlaceDeactivateEx";
end;

define method IOleInPlaceSiteEx/OnInPlaceDeactivateEx(This :: <C-interface>,
		fNoRedraw :: <boolean>) => (status :: <HRESULT>)
  IOleInPlaceSiteEx_OnInPlaceDeactivateEx(This, fNoRedraw)
end;

define open generic IOleInPlaceSiteEx/RequestUIActivate (This)
		=> (status :: <HRESULT>);

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

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

define method IOleInPlaceSiteEx/RequestUIActivate(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleInPlaceSiteEx_RequestUIActivate(This)
end;


	/*  ----  IOleInPlaceSiteWindowless  ----  */


define open primary COM-interface <IOleInPlaceSiteWindowless> ( <IOleInPlaceSiteEx> )
end <IOleInPlaceSiteWindowless>;

define C-address IOleInPlaceSiteWindowless_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleInPlaceSiteWindowless_DW_vtbl"; end;
define C-address $IID-IOleInPlaceSiteWindowless :: <REFIID>
		c-name: "IID_IOleInPlaceSiteWindowless"; end;

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

define open generic IOleInPlaceSiteWindowless/CanWindowlessActivate
		(This) => (status :: <HRESULT>);

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

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

define method IOleInPlaceSiteWindowless/CanWindowlessActivate(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleInPlaceSiteWindowless_CanWindowlessActivate(This)
end;

define open generic IOleInPlaceSiteWindowless/GetCapture (This)
		=> (status :: <HRESULT>);

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

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

define method IOleInPlaceSiteWindowless/GetCapture(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleInPlaceSiteWindowless_GetCapture(This)
end;

define open generic IOleInPlaceSiteWindowless/SetCapture (This,
		fCapture) => (status :: <HRESULT>);

define C-callable-wrapper
		of IOleInPlaceSiteWindowless/SetCapture
  input parameter This :: <mapped-interface>;
  input parameter fCapture :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceSiteWindowless_SetCapture",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSiteWindowless_SetCapture
  input parameter This :: <C-interface>;
  input parameter fCapture :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSiteWindowless_SetCapture";
end;

define method IOleInPlaceSiteWindowless/SetCapture(This :: <C-interface>,
		fCapture :: <boolean>) => (status :: <HRESULT>)
  IOleInPlaceSiteWindowless_SetCapture(This, fCapture)
end;

define open generic IOleInPlaceSiteWindowless/GetFocus (This)
		=> (status :: <HRESULT>);

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

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

define method IOleInPlaceSiteWindowless/GetFocus(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleInPlaceSiteWindowless_GetFocus(This)
end;

define open generic IOleInPlaceSiteWindowless/SetFocus (This,
		fFocus) => (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceSiteWindowless/SetFocus
  input parameter This :: <mapped-interface>;
  input parameter fFocus :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceSiteWindowless_SetFocus",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSiteWindowless_SetFocus
  input parameter This :: <C-interface>;
  input parameter fFocus :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSiteWindowless_SetFocus";
end;

define method IOleInPlaceSiteWindowless/SetFocus(This :: <C-interface>,
		fFocus :: <boolean>) => (status :: <HRESULT>)
  IOleInPlaceSiteWindowless_SetFocus(This, fFocus)
end;

define open generic IOleInPlaceSiteWindowless/GetDC (This, pRect,
		grfFlags) => (status :: <HRESULT>, hDC);

define C-callable-wrapper of IOleInPlaceSiteWindowless/GetDC
  input parameter This :: <mapped-interface>;
  input parameter pRect :: <LPCRECT>;
  input parameter grfFlags :: <DWORD>;
  output parameter phDC :: <LPHDC>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceSiteWindowless_GetDC",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSiteWindowless_GetDC
  input parameter This :: <C-interface>;
  input parameter pRect :: <LPCRECT>;
  input parameter grfFlags :: <DWORD>;
  output parameter phDC :: <LPHDC>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSiteWindowless_GetDC";
end;

define method IOleInPlaceSiteWindowless/GetDC(This :: <C-interface>,
		pRect :: <LPCRECT>, grfFlags) => (status :: <HRESULT>, hDC)
  IOleInPlaceSiteWindowless_GetDC(This, pRect, grfFlags)
end;

define open generic IOleInPlaceSiteWindowless/ReleaseDC (This,
		hDC) => (status :: <HRESULT>);

define C-callable-wrapper of IOleInPlaceSiteWindowless/ReleaseDC
  input parameter This :: <mapped-interface>;
  input parameter hDC :: <HDC>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceSiteWindowless_ReleaseDC",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSiteWindowless_ReleaseDC
  input parameter This :: <C-interface>;
  input parameter hDC :: <HDC>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSiteWindowless_ReleaseDC";
end;

define method IOleInPlaceSiteWindowless/ReleaseDC(This :: <C-interface>,
		hDC :: <HDC>) => (status :: <HRESULT>)
  IOleInPlaceSiteWindowless_ReleaseDC(This, hDC)
end;

define open generic IOleInPlaceSiteWindowless/InvalidateRect
		(This, pRect, fErase) => (status :: <HRESULT>);

define C-callable-wrapper
		of IOleInPlaceSiteWindowless/InvalidateRect
  input parameter This :: <mapped-interface>;
  input parameter pRect :: <LPCRECT>;
  input parameter fErase :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceSiteWindowless_InvalidateRect",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSiteWindowless_InvalidateRect
  input parameter This :: <C-interface>;
  input parameter pRect :: <LPCRECT>;
  input parameter fErase :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSiteWindowless_InvalidateRect";
end;

define method IOleInPlaceSiteWindowless/InvalidateRect(This :: <C-interface>,
		pRect :: <LPCRECT>, fErase :: <boolean>)
		=> (status :: <HRESULT>)
  IOleInPlaceSiteWindowless_InvalidateRect(This, pRect, fErase)
end;

define open generic IOleInPlaceSiteWindowless/InvalidateRgn
		(This, hRGN, fErase) => (status :: <HRESULT>);

define C-callable-wrapper
		of IOleInPlaceSiteWindowless/InvalidateRgn
  input parameter This :: <mapped-interface>;
  input parameter hRGN :: <HRGN>;
  input parameter fErase :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceSiteWindowless_InvalidateRgn",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSiteWindowless_InvalidateRgn
  input parameter This :: <C-interface>;
  input parameter hRGN :: <HRGN>;
  input parameter fErase :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSiteWindowless_InvalidateRgn";
end;

define method IOleInPlaceSiteWindowless/InvalidateRgn(This :: <C-interface>,
		hRGN :: <HRGN>, fErase :: <boolean>) => (status :: <HRESULT>)
  IOleInPlaceSiteWindowless_InvalidateRgn(This, hRGN, fErase)
end;

define open generic IOleInPlaceSiteWindowless/ScrollRect (This,
		dx, dy, pRectScroll, pRectClip) => (status :: <HRESULT>);

define C-callable-wrapper
		of IOleInPlaceSiteWindowless/ScrollRect
  input parameter This :: <mapped-interface>;
  input parameter dx :: <INT>;
  input parameter dy :: <INT>;
  input parameter pRectScroll :: <LPCRECT>;
  input parameter pRectClip :: <LPCRECT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceSiteWindowless_ScrollRect",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSiteWindowless_ScrollRect
  input parameter This :: <C-interface>;
  input parameter dx :: <INT>;
  input parameter dy :: <INT>;
  input parameter pRectScroll :: <LPCRECT>;
  input parameter pRectClip :: <LPCRECT>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSiteWindowless_ScrollRect";
end;

define method IOleInPlaceSiteWindowless/ScrollRect(This :: <C-interface>,
		dx, dy, pRectScroll :: <LPCRECT>, pRectClip :: <LPCRECT>)
		=> (status :: <HRESULT>)
  IOleInPlaceSiteWindowless_ScrollRect(This, dx, dy, pRectScroll,
		pRectClip)
end;

define open generic IOleInPlaceSiteWindowless/AdjustRect (This,
		prc) => (status :: <HRESULT>);

define C-callable-wrapper
		of IOleInPlaceSiteWindowless/AdjustRect
  input parameter This :: <mapped-interface>;
   parameter prc :: <LPRECT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceSiteWindowless_AdjustRect",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSiteWindowless_AdjustRect
  input parameter This :: <C-interface>;
   parameter prc :: <LPRECT>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSiteWindowless_AdjustRect";
end;

define method IOleInPlaceSiteWindowless/AdjustRect(This :: <C-interface>,
		prc :: <LPRECT>) => (status :: <HRESULT>)
  IOleInPlaceSiteWindowless_AdjustRect(This, prc)
end;

define open generic IOleInPlaceSiteWindowless/OnDefWindowMessage
		(This, msg, wParam, lParam) => (status :: <HRESULT>, lResult);

define C-callable-wrapper
		of IOleInPlaceSiteWindowless/OnDefWindowMessage
  input parameter This :: <mapped-interface>;
  input parameter msg :: <UINT>;
  input parameter wParam :: <WPARAM>;
  input parameter lParam :: <LPARAM>;
  output parameter plResult :: <LPLRESULT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleInPlaceSiteWindowless_OnDefWindowMessage",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleInPlaceSiteWindowless_OnDefWindowMessage
  input parameter This :: <C-interface>;
  input parameter msg :: <UINT>;
  input parameter wParam :: <WPARAM>;
  input parameter lParam :: <LPARAM>;
  output parameter plResult :: <LPLRESULT>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleInPlaceSiteWindowless_OnDefWindowMessage";
end;

define method IOleInPlaceSiteWindowless/OnDefWindowMessage(This :: <C-interface>,
		msg, wParam, lParam) => (status :: <HRESULT>, lResult)
  IOleInPlaceSiteWindowless_OnDefWindowMessage(This, msg, wParam,
		lParam)
end;


	/*  ----  IViewObjectEx  ----  */


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

define C-address IViewObjectEx_DW_vtbl :: <C-COM-vtbl>
		c-name: "IViewObjectEx_DW_vtbl"; end;
define C-address $IID-IViewObjectEx :: <REFIID>
		c-name: "IID_IViewObjectEx"; end;

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

define open generic IViewObjectEx/GetRect (This, dwAspect, pRect)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IViewObjectEx/GetRect
  input parameter This :: <mapped-interface>;
  input parameter dwAspect :: <DWORD>;
  parameter pRect :: <LPRECTL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IViewObjectEx_GetRect", c-modifiers: "__stdcall";
end;

define inline-only C-function IViewObjectEx_GetRect
  input parameter This :: <C-interface>;
  input parameter dwAspect :: <DWORD>;
  parameter pRect :: <LPRECTL>;
  result status :: <C-HRESULT>;
  c-name: "C_IViewObjectEx_GetRect";
end;

define method IViewObjectEx/GetRect(This :: <C-interface>,
		dwAspect, pRect :: <LPRECTL>) => (status :: <HRESULT>)
  IViewObjectEx_GetRect(This, dwAspect, pRect)
end;

define open generic IViewObjectEx/GetViewStatus (This)
		=> (status :: <HRESULT>, dwStatus);

define C-callable-wrapper of IViewObjectEx/GetViewStatus
  input parameter This :: <mapped-interface>;
  output parameter pdwStatus :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IViewObjectEx_GetViewStatus",
		c-modifiers: "__stdcall";
end;

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

define method IViewObjectEx/GetViewStatus(This :: <C-interface>)
		=> (status :: <HRESULT>, dwStatus)
  IViewObjectEx_GetViewStatus(This)
end;

define open generic IViewObjectEx/QueryHitPoint (This, dwAspect,
		pRectBounds, ptlLoc, lCloseHint)
		=> (status :: <HRESULT>, HitResult);

define C-callable-wrapper of IViewObjectEx/QueryHitPoint
  input parameter This :: <mapped-interface>;
  input parameter dwAspect :: <DWORD>;
  input parameter pRectBounds :: <LPCRECT>;
  input parameter ptlLoc :: <POINT>;
  input parameter lCloseHint :: <LONG>;
  output parameter pHitResult :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IViewObjectEx_QueryHitPoint",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IViewObjectEx_QueryHitPoint
  input parameter This :: <C-interface>;
  input parameter dwAspect :: <DWORD>;
  input parameter pRectBounds :: <LPCRECT>;
  input parameter ptlLoc :: <POINT>;
  input parameter lCloseHint :: <LONG>;
  output parameter pHitResult :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IViewObjectEx_QueryHitPoint";
end;

define method IViewObjectEx/QueryHitPoint(This :: <C-interface>,
		dwAspect, pRectBounds :: <LPCRECT>, ptlLoc, lCloseHint)
		=> (status :: <HRESULT>, HitResult)
  IViewObjectEx_QueryHitPoint(This, dwAspect, pRectBounds,
		ptlLoc, lCloseHint)
end;

define open generic IViewObjectEx/QueryHitRect (This, dwAspect,
		pRectBounds, pRectLoc, lCloseHint)
		=> (status :: <HRESULT>, HitResult);

define C-callable-wrapper of IViewObjectEx/QueryHitRect
  input parameter This :: <mapped-interface>;
  input parameter dwAspect :: <DWORD>;
  input parameter pRectBounds :: <LPCRECT>;
  input parameter pRectLoc :: <LPCRECT>;
  input parameter lCloseHint :: <LONG>;
  output parameter pHitResult :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IViewObjectEx_QueryHitRect",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IViewObjectEx_QueryHitRect
  input parameter This :: <C-interface>;
  input parameter dwAspect :: <DWORD>;
  input parameter pRectBounds :: <LPCRECT>;
  input parameter pRectLoc :: <LPCRECT>;
  input parameter lCloseHint :: <LONG>;
  output parameter pHitResult :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IViewObjectEx_QueryHitRect";
end;

define method IViewObjectEx/QueryHitRect(This :: <C-interface>,
		dwAspect, pRectBounds :: <LPCRECT>, pRectLoc :: <LPCRECT>,
		lCloseHint) => (status :: <HRESULT>, HitResult)
  IViewObjectEx_QueryHitRect(This, dwAspect, pRectBounds,
		pRectLoc, lCloseHint)
end;

define open generic IViewObjectEx/GetNaturalExtent (This,
		dwAspect, lindex, ptd, hicTargetDev, pExtentInfo, pSizel)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IViewObjectEx/GetNaturalExtent
  input parameter This :: <mapped-interface>;
  input parameter dwAspect :: <DWORD>;
  input parameter lindex :: <LONG>;
  input parameter ptd :: <LPDVTARGETDEVICE>;
  input parameter hicTargetDev :: <HDC>;
  input parameter pExtentInfo :: <LPDVEXTENTINFO>;
  parameter pSizel :: <LPSIZEL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IViewObjectEx_GetNaturalExtent",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IViewObjectEx_GetNaturalExtent
  input parameter This :: <C-interface>;
  input parameter dwAspect :: <DWORD>;
  input parameter lindex :: <LONG>;
  input parameter ptd :: <LPDVTARGETDEVICE>;
  input parameter hicTargetDev :: <HDC>;
  input parameter pExtentInfo :: <LPDVEXTENTINFO>;
  parameter pSizel :: <LPSIZEL>;
  result status :: <C-HRESULT>;
  c-name: "C_IViewObjectEx_GetNaturalExtent";
end;

define method IViewObjectEx/GetNaturalExtent(This :: <C-interface>,
		dwAspect, lindex, ptd :: <LPDVTARGETDEVICE>,
		hicTargetDev :: <HDC>, pExtentInfo :: <LPDVEXTENTINFO>,
		pSizel :: <LPSIZEL>) => (status :: <HRESULT>)
  IViewObjectEx_GetNaturalExtent(This, dwAspect, lindex, ptd,
		hicTargetDev, pExtentInfo, pSizel)
end;


	/*  ----  IOleUndoUnit  ----  */


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

define C-address IOleUndoUnit_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleUndoUnit_DW_vtbl"; end;
define C-address $IID-IOleUndoUnit :: <REFIID>
		c-name: "IID_IOleUndoUnit"; end;

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

define open generic IOleUndoUnit/Do (This, pUndoManager)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleUndoUnit/Do
  input parameter This :: <mapped-interface>;
  input parameter pUndoManager :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleUndoUnit_Do", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleUndoUnit_Do
  input parameter This :: <C-interface>;
  input parameter pUndoManager :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleUndoUnit_Do";
end;

define method IOleUndoUnit/Do(This :: <C-interface>,
		pUndoManager :: <Interface>) => (status :: <HRESULT>)
  IOleUndoUnit_Do(This, pUndoManager)
end;

define open generic IOleUndoUnit/GetDescription (This)
		=> (status :: <HRESULT>, Bstr :: <BSTR>);

define C-callable-wrapper of IOleUndoUnit/GetDescription
  input parameter This :: <mapped-interface>;
  output parameter pBstr :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleUndoUnit_GetDescription",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleUndoUnit_GetDescription
  input parameter This :: <C-interface>;
  output parameter pBstr :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleUndoUnit_GetDescription";
end;

define method IOleUndoUnit/GetDescription(This :: <C-interface>)
		=> (status :: <HRESULT>, Bstr :: <BSTR>)
  IOleUndoUnit_GetDescription(This)
end;

define open generic IOleUndoUnit/GetUnitType (This, pClsid)
		=> (status :: <HRESULT>, lID);

define C-callable-wrapper of IOleUndoUnit/GetUnitType
  input parameter This :: <mapped-interface>;
  parameter pClsid :: <LPCLSID>;
  output parameter plID :: <LPLONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleUndoUnit_GetUnitType",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleUndoUnit_GetUnitType
  input parameter This :: <C-interface>;
  parameter pClsid :: <LPCLSID>;
  output parameter plID :: <LPLONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleUndoUnit_GetUnitType";
end;

define method IOleUndoUnit/GetUnitType(This :: <C-interface>,
		pClsid :: <LPCLSID>) => (status :: <HRESULT>, lID)
  IOleUndoUnit_GetUnitType(This, pClsid)
end;

define open generic IOleUndoUnit/OnNextAdd (This)
		=> (status :: <HRESULT>);

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

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

define method IOleUndoUnit/OnNextAdd(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IOleUndoUnit_OnNextAdd(This)
end;


	/*  ----  IOleParentUndoUnit  ----  */


define open primary COM-interface <IOleParentUndoUnit> ( <IOleUndoUnit> )
end <IOleParentUndoUnit>;

define C-address IOleParentUndoUnit_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleParentUndoUnit_DW_vtbl"; end;
define C-address $IID-IOleParentUndoUnit :: <REFIID>
		c-name: "IID_IOleParentUndoUnit"; end;

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

define open generic IOleParentUndoUnit/Open (This, pPUU)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleParentUndoUnit/Open
  input parameter This :: <mapped-interface>;
  input parameter pPUU :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleParentUndoUnit_Open",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleParentUndoUnit_Open
  input parameter This :: <C-interface>;
  input parameter pPUU :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleParentUndoUnit_Open";
end;

define method IOleParentUndoUnit/Open(This :: <C-interface>,
		pPUU :: <Interface>) => (status :: <HRESULT>)
  IOleParentUndoUnit_Open(This, pPUU)
end;

define open generic IOleParentUndoUnit/Close (This, pPUU,
		fCommit) => (status :: <HRESULT>);

define C-callable-wrapper of IOleParentUndoUnit/Close
  input parameter This :: <mapped-interface>;
  input parameter pPUU :: <C-interface>;
  input parameter fCommit :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleParentUndoUnit_Close",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleParentUndoUnit_Close
  input parameter This :: <C-interface>;
  input parameter pPUU :: <Interface>;
  input parameter fCommit :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleParentUndoUnit_Close";
end;

define method IOleParentUndoUnit/Close(This :: <C-interface>,
		pPUU :: <Interface>, fCommit :: <boolean>)
		=> (status :: <HRESULT>)
  IOleParentUndoUnit_Close(This, pPUU, fCommit)
end;

define open generic IOleParentUndoUnit/Add (This, pUU)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleParentUndoUnit/Add
  input parameter This :: <mapped-interface>;
  input parameter pUU :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleParentUndoUnit_Add", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleParentUndoUnit_Add
  input parameter This :: <C-interface>;
  input parameter pUU :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleParentUndoUnit_Add";
end;

define method IOleParentUndoUnit/Add(This :: <C-interface>,
		pUU :: <Interface>) => (status :: <HRESULT>)
  IOleParentUndoUnit_Add(This, pUU)
end;

define open generic IOleParentUndoUnit/FindUnit (This, pUU)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleParentUndoUnit/FindUnit
  input parameter This :: <mapped-interface>;
  input parameter pUU :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleParentUndoUnit_FindUnit",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleParentUndoUnit_FindUnit
  input parameter This :: <C-interface>;
  input parameter pUU :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleParentUndoUnit_FindUnit";
end;

define method IOleParentUndoUnit/FindUnit(This :: <C-interface>,
		pUU :: <Interface>) => (status :: <HRESULT>)
  IOleParentUndoUnit_FindUnit(This, pUU)
end;

define open generic IOleParentUndoUnit/GetParentState (This)
		=> (status :: <HRESULT>, dwState);

define C-callable-wrapper of IOleParentUndoUnit/GetParentState
  input parameter This :: <mapped-interface>;
  output parameter pdwState :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleParentUndoUnit_GetParentState",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleParentUndoUnit_GetParentState
  input parameter This :: <C-interface>;
  output parameter pdwState :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleParentUndoUnit_GetParentState";
end;

define method IOleParentUndoUnit/GetParentState(This :: <C-interface>)
		=> (status :: <HRESULT>, dwState)
  IOleParentUndoUnit_GetParentState(This)
end;


	/*  ----  IEnumOleUndoUnits  ----  */


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

define C-address IEnumOleUndoUnits_DW_vtbl :: <C-COM-vtbl>
		c-name: "IEnumOleUndoUnits_DW_vtbl"; end;
define C-address $IID-IEnumOleUndoUnits :: <REFIID>
		c-name: "IID_IEnumOleUndoUnits"; end;

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

define open generic IEnumOleUndoUnits/Next (This, cElt, rgElt)
		=> (status :: <HRESULT>, cEltFetched);

define C-callable-wrapper of IEnumOleUndoUnits/Next
  input parameter This :: <mapped-interface>;
  input parameter cElt :: <ULONG>;
   parameter rgElt :: <Interface*>;
  output parameter pcEltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IEnumOleUndoUnits_Next", c-modifiers: "__stdcall";
end;

define inline-only C-function IEnumOleUndoUnits_Next
  input parameter This :: <C-interface>;
  input parameter cElt :: <ULONG>;
   parameter rgElt :: <Interface*>;
  output parameter pcEltFetched :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumOleUndoUnits_Next";
end;

define method IEnumOleUndoUnits/Next(This :: <C-interface>, cElt,
		rgElt) => (status :: <HRESULT>, cEltFetched)
  IEnumOleUndoUnits_Next(This, cElt, rgElt)
end;

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

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

define inline-only C-function IEnumOleUndoUnits_Skip
  input parameter This :: <C-interface>;
  input parameter cElt :: <ULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumOleUndoUnits_Skip";
end;

define method IEnumOleUndoUnits/Skip(This :: <C-interface>, cElt)
		=> (status :: <HRESULT>)
  IEnumOleUndoUnits_Skip(This, cElt)
end;

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

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

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

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

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

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

define inline-only C-function IEnumOleUndoUnits_Clone
  input parameter This :: <C-interface>;
  output parameter ppEnum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IEnumOleUndoUnits_Clone";
end;

define method IEnumOleUndoUnits/Clone(This :: <C-interface>)
		=> (status :: <HRESULT>, pEnum :: <Interface>)
  IEnumOleUndoUnits_Clone(This)
end;


	/*  ----  IOleUndoManager  ----  */


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

define C-address IOleUndoManager_DW_vtbl :: <C-COM-vtbl>
		c-name: "IOleUndoManager_DW_vtbl"; end;
define C-address $IID-IOleUndoManager :: <REFIID>
		c-name: "IID_IOleUndoManager"; end;

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

define open generic IOleUndoManager/Open (This, pPUU)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleUndoManager/Open
  input parameter This :: <mapped-interface>;
  input parameter pPUU :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleUndoManager_Open", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleUndoManager_Open
  input parameter This :: <C-interface>;
  input parameter pPUU :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleUndoManager_Open";
end;

define method IOleUndoManager/Open(This :: <C-interface>,
		pPUU :: <Interface>) => (status :: <HRESULT>)
  IOleUndoManager_Open(This, pPUU)
end;

define open generic IOleUndoManager/Close (This, pPUU, fCommit)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleUndoManager/Close
  input parameter This :: <mapped-interface>;
  input parameter pPUU :: <C-interface>;
  input parameter fCommit :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleUndoManager_Close", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleUndoManager_Close
  input parameter This :: <C-interface>;
  input parameter pPUU :: <Interface>;
  input parameter fCommit :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleUndoManager_Close";
end;

define method IOleUndoManager/Close(This :: <C-interface>,
		pPUU :: <Interface>, fCommit :: <boolean>)
		=> (status :: <HRESULT>)
  IOleUndoManager_Close(This, pPUU, fCommit)
end;

define open generic IOleUndoManager/Add (This, pUU)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleUndoManager/Add
  input parameter This :: <mapped-interface>;
  input parameter pUU :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleUndoManager_Add", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleUndoManager_Add
  input parameter This :: <C-interface>;
  input parameter pUU :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleUndoManager_Add";
end;

define method IOleUndoManager/Add(This :: <C-interface>,
		pUU :: <Interface>) => (status :: <HRESULT>)
  IOleUndoManager_Add(This, pUU)
end;

define open generic IOleUndoManager/GetOpenParentState (This)
		=> (status :: <HRESULT>, dwState);

define C-callable-wrapper of IOleUndoManager/GetOpenParentState
  input parameter This :: <mapped-interface>;
  output parameter pdwState :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleUndoManager_GetOpenParentState",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleUndoManager_GetOpenParentState
  input parameter This :: <C-interface>;
  output parameter pdwState :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleUndoManager_GetOpenParentState";
end;

define method IOleUndoManager/GetOpenParentState(This :: <C-interface>)
		=> (status :: <HRESULT>, dwState)
  IOleUndoManager_GetOpenParentState(This)
end;

define open generic IOleUndoManager/DiscardFrom (This, pUU)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleUndoManager/DiscardFrom
  input parameter This :: <mapped-interface>;
  input parameter pUU :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleUndoManager_DiscardFrom",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleUndoManager_DiscardFrom
  input parameter This :: <C-interface>;
  input parameter pUU :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleUndoManager_DiscardFrom";
end;

define method IOleUndoManager/DiscardFrom(This :: <C-interface>,
		pUU :: <Interface>) => (status :: <HRESULT>)
  IOleUndoManager_DiscardFrom(This, pUU)
end;

define open generic IOleUndoManager/UndoTo (This, pUU)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleUndoManager/UndoTo
  input parameter This :: <mapped-interface>;
  input parameter pUU :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleUndoManager_UndoTo", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleUndoManager_UndoTo
  input parameter This :: <C-interface>;
  input parameter pUU :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleUndoManager_UndoTo";
end;

define method IOleUndoManager/UndoTo(This :: <C-interface>,
		pUU :: <Interface>) => (status :: <HRESULT>)
  IOleUndoManager_UndoTo(This, pUU)
end;

define open generic IOleUndoManager/RedoTo (This, pUU)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IOleUndoManager/RedoTo
  input parameter This :: <mapped-interface>;
  input parameter pUU :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleUndoManager_RedoTo", c-modifiers: "__stdcall";
end;

define inline-only C-function IOleUndoManager_RedoTo
  input parameter This :: <C-interface>;
  input parameter pUU :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleUndoManager_RedoTo";
end;

define method IOleUndoManager/RedoTo(This :: <C-interface>,
		pUU :: <Interface>) => (status :: <HRESULT>)
  IOleUndoManager_RedoTo(This, pUU)
end;

define open generic IOleUndoManager/EnumUndoable (This)
		=> (status :: <HRESULT>, pEnum :: <Interface>);

define C-callable-wrapper of IOleUndoManager/EnumUndoable
  input parameter This :: <mapped-interface>;
  output parameter ppEnum :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleUndoManager_EnumUndoable",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleUndoManager_EnumUndoable
  input parameter This :: <C-interface>;
  output parameter ppEnum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleUndoManager_EnumUndoable";
end;

define method IOleUndoManager/EnumUndoable(This :: <C-interface>)
		=> (status :: <HRESULT>, pEnum :: <Interface>)
  IOleUndoManager_EnumUndoable(This)
end;

define open generic IOleUndoManager/EnumRedoable (This)
		=> (status :: <HRESULT>, pEnum :: <Interface>);

define C-callable-wrapper of IOleUndoManager/EnumRedoable
  input parameter This :: <mapped-interface>;
  output parameter ppEnum :: <Interface*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleUndoManager_EnumRedoable",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleUndoManager_EnumRedoable
  input parameter This :: <C-interface>;
  output parameter ppEnum :: <C-interface*>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleUndoManager_EnumRedoable";
end;

define method IOleUndoManager/EnumRedoable(This :: <C-interface>)
		=> (status :: <HRESULT>, pEnum :: <Interface>)
  IOleUndoManager_EnumRedoable(This)
end;

define open generic IOleUndoManager/GetLastUndoDescription (This)
		=> (status :: <HRESULT>, Bstr :: <BSTR>);

define C-callable-wrapper
		of IOleUndoManager/GetLastUndoDescription
  input parameter This :: <mapped-interface>;
  output parameter pBstr :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleUndoManager_GetLastUndoDescription",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleUndoManager_GetLastUndoDescription
  input parameter This :: <C-interface>;
  output parameter pBstr :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleUndoManager_GetLastUndoDescription";
end;

define method IOleUndoManager/GetLastUndoDescription(This :: <C-interface>)
		=> (status :: <HRESULT>, Bstr :: <BSTR>)
  IOleUndoManager_GetLastUndoDescription(This)
end;

define open generic IOleUndoManager/GetLastRedoDescription (This)
		=> (status :: <HRESULT>, Bstr :: <BSTR>);

define C-callable-wrapper
		of IOleUndoManager/GetLastRedoDescription
  input parameter This :: <mapped-interface>;
  output parameter pBstr :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IOleUndoManager_GetLastRedoDescription",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IOleUndoManager_GetLastRedoDescription
  input parameter This :: <C-interface>;
  output parameter pBstr :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IOleUndoManager_GetLastRedoDescription";
end;

define method IOleUndoManager/GetLastRedoDescription(This :: <C-interface>)
		=> (status :: <HRESULT>, Bstr :: <BSTR>)
  IOleUndoManager_GetLastRedoDescription(This)
end;

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

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

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

define method IOleUndoManager/Enable(This :: <C-interface>,
		fEnable :: <boolean>) => (status :: <HRESULT>)
  IOleUndoManager_Enable(This, fEnable)
end;


	/*  ----  IPointerInactive  ----  */


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

define C-address IPointerInactive_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPointerInactive_DW_vtbl"; end;
define C-address $IID-IPointerInactive :: <REFIID>
		c-name: "IID_IPointerInactive"; end;

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

define open generic IPointerInactive/GetActivationPolicy (This)
		=> (status :: <HRESULT>, dwPolicy);

define C-callable-wrapper
		of IPointerInactive/GetActivationPolicy
  input parameter This :: <mapped-interface>;
  output parameter pdwPolicy :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPointerInactive_GetActivationPolicy",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPointerInactive_GetActivationPolicy
  input parameter This :: <C-interface>;
  output parameter pdwPolicy :: <LPDWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IPointerInactive_GetActivationPolicy";
end;

define method IPointerInactive/GetActivationPolicy(This :: <C-interface>)
		=> (status :: <HRESULT>, dwPolicy)
  IPointerInactive_GetActivationPolicy(This)
end;

define open generic IPointerInactive/OnInactiveMouseMove (This,
		pRectBounds, x, y, grfKeyState) => (status :: <HRESULT>);

define C-callable-wrapper
		of IPointerInactive/OnInactiveMouseMove
  input parameter This :: <mapped-interface>;
  input parameter pRectBounds :: <LPCRECT>;
  input parameter x :: <LONG>;
  input parameter y :: <LONG>;
  input parameter grfKeyState :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPointerInactive_OnInactiveMouseMove",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPointerInactive_OnInactiveMouseMove
  input parameter This :: <C-interface>;
  input parameter pRectBounds :: <LPCRECT>;
  input parameter x :: <LONG>;
  input parameter y :: <LONG>;
  input parameter grfKeyState :: <DWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IPointerInactive_OnInactiveMouseMove";
end;

define method IPointerInactive/OnInactiveMouseMove(This :: <C-interface>,
		pRectBounds :: <LPCRECT>, x, y, grfKeyState)
		=> (status :: <HRESULT>)
  IPointerInactive_OnInactiveMouseMove(This, pRectBounds, x, y,
		grfKeyState)
end;

define open generic IPointerInactive/OnInactiveSetCursor (This,
		pRectBounds, x, y, dwMouseMsg, fSetAlways)
		=> (status :: <HRESULT>);

define C-callable-wrapper
		of IPointerInactive/OnInactiveSetCursor
  input parameter This :: <mapped-interface>;
  input parameter pRectBounds :: <LPCRECT>;
  input parameter x :: <LONG>;
  input parameter y :: <LONG>;
  input parameter dwMouseMsg :: <DWORD>;
  input parameter fSetAlways :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPointerInactive_OnInactiveSetCursor",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPointerInactive_OnInactiveSetCursor
  input parameter This :: <C-interface>;
  input parameter pRectBounds :: <LPCRECT>;
  input parameter x :: <LONG>;
  input parameter y :: <LONG>;
  input parameter dwMouseMsg :: <DWORD>;
  input parameter fSetAlways :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IPointerInactive_OnInactiveSetCursor";
end;

define method IPointerInactive/OnInactiveSetCursor(This :: <C-interface>,
		pRectBounds :: <LPCRECT>, x, y, dwMouseMsg,
		fSetAlways :: <boolean>) => (status :: <HRESULT>)
  IPointerInactive_OnInactiveSetCursor(This, pRectBounds, x, y,
		dwMouseMsg, fSetAlways)
end;


	/*  ----  IObjectWithSite  ----  */


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

define C-address IObjectWithSite_DW_vtbl :: <C-COM-vtbl>
		c-name: "IObjectWithSite_DW_vtbl"; end;
define C-address $IID-IObjectWithSite :: <REFIID>
		c-name: "IID_IObjectWithSite"; end;

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

define open generic IObjectWithSite/SetSite (This, pUnkSite)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IObjectWithSite/SetSite
  input parameter This :: <mapped-interface>;
  input parameter pUnkSite :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IObjectWithSite_SetSite",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IObjectWithSite_SetSite
  input parameter This :: <C-interface>;
  input parameter pUnkSite :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IObjectWithSite_SetSite";
end;

define method IObjectWithSite/SetSite(This :: <C-interface>,
		pUnkSite :: <Interface>) => (status :: <HRESULT>)
  IObjectWithSite_SetSite(This, pUnkSite)
end;

define open generic IObjectWithSite/GetSite (This, riid)
		=> (status :: <HRESULT>, pvSite :: <C-void*>);

define C-callable-wrapper of IObjectWithSite/GetSite
  input parameter This :: <mapped-interface>;
  input parameter riid :: <REFIID>;
  output parameter ppvSite :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "DW_IObjectWithSite_GetSite",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IObjectWithSite_GetSite
  input parameter This :: <C-interface>;
  input parameter riid :: <REFIID>;
  output parameter ppvSite :: <C-void**>;
  result status :: <C-HRESULT>;
  c-name: "C_IObjectWithSite_GetSite";
end;

define method IObjectWithSite/GetSite(This :: <C-interface>,
		riid :: <REFIID>)
		=> (status :: <HRESULT>, pvSite :: <C-void*>)
  IObjectWithSite_GetSite(This, riid)
end;


	/*  ----  IErrorLog  ----  */


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

define C-address IErrorLog_DW_vtbl :: <C-COM-vtbl>
		c-name: "IErrorLog_DW_vtbl"; end;
define C-address $IID-IErrorLog :: <REFIID>
		c-name: "IID_IErrorLog"; end;

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

define open generic IErrorLog/AddError (This, pszPropName,
		pExcepInfo) => (status :: <HRESULT>);

define C-callable-wrapper of IErrorLog/AddError
  input parameter This :: <mapped-interface>;
  input parameter pszPropName :: <LPCOLESTR>;
  input parameter pExcepInfo :: <LPEXCEPINFO>;
  result status :: <C-HRESULT>;
  c-name: "DW_IErrorLog_AddError", c-modifiers: "__stdcall";
end;

define inline-only C-function IErrorLog_AddError
  input parameter This :: <C-interface>;
  input parameter pszPropName :: <LPCOLESTR>;
  input parameter pExcepInfo :: <LPEXCEPINFO>;
  result status :: <C-HRESULT>;
  c-name: "C_IErrorLog_AddError";
end;

define method IErrorLog/AddError(This :: <C-interface>,
		pszPropName :: <string>, pExcepInfo :: <LPEXCEPINFO>)
		=> (status :: <HRESULT>)
  IErrorLog_AddError(This, pszPropName, pExcepInfo)
end;


	/*  ----  IPropertyBag  ----  */


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

define C-address IPropertyBag_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPropertyBag_DW_vtbl"; end;
define C-address $IID-IPropertyBag :: <REFIID>
		c-name: "IID_IPropertyBag"; end;

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

define open generic IPropertyBag/Read (This, pszPropName, pVar,
		pErrorLog) => (status :: <HRESULT>);

define C-callable-wrapper of IPropertyBag/Read
  input parameter This :: <mapped-interface>;
  input parameter pszPropName :: <LPCOLESTR>;
   parameter pVar :: <LPVARIANT>;
  input parameter pErrorLog :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyBag_Read", c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyBag_Read
  input parameter This :: <C-interface>;
  input parameter pszPropName :: <LPCOLESTR>;
   parameter pVar :: <LPVARIANT>;
  input parameter pErrorLog :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyBag_Read";
end;

define method IPropertyBag/Read(This :: <C-interface>,
		pszPropName :: <string>, pVar :: <LPVARIANT>,
		pErrorLog :: <Interface>) => (status :: <HRESULT>)
  IPropertyBag_Read(This, pszPropName, pVar, pErrorLog)
end;

define open generic IPropertyBag/Write (This, pszPropName, pVar)
		=> (status :: <HRESULT>);

define C-callable-wrapper of IPropertyBag/Write
  input parameter This :: <mapped-interface>;
  input parameter pszPropName :: <LPCOLESTR>;
  input parameter pVar :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyBag_Write", c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyBag_Write
  input parameter This :: <C-interface>;
  input parameter pszPropName :: <LPCOLESTR>;
  input parameter pVar :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyBag_Write";
end;

define method IPropertyBag/Write(This :: <C-interface>,
		pszPropName :: <string>, pVar :: <LPVARIANT>)
		=> (status :: <HRESULT>)
  IPropertyBag_Write(This, pszPropName, pVar)
end;


	/*  ----  IPerPropertyBrowsing  ----  */


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

define C-address IPerPropertyBrowsing_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPerPropertyBrowsing_DW_vtbl"; end;
define C-address $IID-IPerPropertyBrowsing :: <REFIID>
		c-name: "IID_IPerPropertyBrowsing"; end;

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

define open generic IPerPropertyBrowsing/GetDisplayString (This,
		dispID) => (status :: <HRESULT>, Bstr :: <BSTR>);

define C-callable-wrapper
		of IPerPropertyBrowsing/GetDisplayString
  input parameter This :: <mapped-interface>;
  input parameter dispID :: <DISPID>;
  output parameter pBstr :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPerPropertyBrowsing_GetDisplayString",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPerPropertyBrowsing_GetDisplayString
  input parameter This :: <C-interface>;
  input parameter dispID :: <DISPID>;
  output parameter pBstr :: <LPBSTR>;
  result status :: <C-HRESULT>;
  c-name: "C_IPerPropertyBrowsing_GetDisplayString";
end;

define method IPerPropertyBrowsing/GetDisplayString(This :: <C-interface>,
		dispID) => (status :: <HRESULT>, Bstr :: <BSTR>)
  IPerPropertyBrowsing_GetDisplayString(This, dispID)
end;

define open generic IPerPropertyBrowsing/MapPropertyToPage (This,
		dispID, pClsid) => (status :: <HRESULT>);

define C-callable-wrapper
		of IPerPropertyBrowsing/MapPropertyToPage
  input parameter This :: <mapped-interface>;
  input parameter dispID :: <DISPID>;
  parameter pClsid :: <LPCLSID>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPerPropertyBrowsing_MapPropertyToPage",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPerPropertyBrowsing_MapPropertyToPage
  input parameter This :: <C-interface>;
  input parameter dispID :: <DISPID>;
  parameter pClsid :: <LPCLSID>;
  result status :: <C-HRESULT>;
  c-name: "C_IPerPropertyBrowsing_MapPropertyToPage";
end;

define method IPerPropertyBrowsing/MapPropertyToPage(This :: <C-interface>,
		dispID, pClsid :: <LPCLSID>) => (status :: <HRESULT>)
  IPerPropertyBrowsing_MapPropertyToPage(This, dispID, pClsid)
end;

define open generic IPerPropertyBrowsing/GetPredefinedStrings
		(This, dispID, pCaStringsOut, pCaCookiesOut)
		=> (status :: <HRESULT>);

define C-callable-wrapper
		of IPerPropertyBrowsing/GetPredefinedStrings
  input parameter This :: <mapped-interface>;
  input parameter dispID :: <DISPID>;
  parameter pCaStringsOut :: <LPCALPOLESTR>;
  parameter pCaCookiesOut :: <LPCADWORD>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPerPropertyBrowsing_GetPredefinedStrings",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPerPropertyBrowsing_GetPredefinedStrings
  input parameter This :: <C-interface>;
  input parameter dispID :: <DISPID>;
  parameter pCaStringsOut :: <LPCALPOLESTR>;
  parameter pCaCookiesOut :: <LPCADWORD>;
  result status :: <C-HRESULT>;
  c-name: "C_IPerPropertyBrowsing_GetPredefinedStrings";
end;

define method IPerPropertyBrowsing/GetPredefinedStrings(This :: <C-interface>,
		dispID, pCaStringsOut :: <LPCALPOLESTR>,
		pCaCookiesOut :: <LPCADWORD>) => (status :: <HRESULT>)
  IPerPropertyBrowsing_GetPredefinedStrings(This, dispID,
		pCaStringsOut, pCaCookiesOut)
end;

define open generic IPerPropertyBrowsing/GetPredefinedValue
		(This, dispID, dwCookie, pVarOut) => (status :: <HRESULT>);

define C-callable-wrapper
		of IPerPropertyBrowsing/GetPredefinedValue
  input parameter This :: <mapped-interface>;
  input parameter dispID :: <DISPID>;
  input parameter dwCookie :: <DWORD>;
  parameter pVarOut :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPerPropertyBrowsing_GetPredefinedValue",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPerPropertyBrowsing_GetPredefinedValue
  input parameter This :: <C-interface>;
  input parameter dispID :: <DISPID>;
  input parameter dwCookie :: <DWORD>;
  parameter pVarOut :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_IPerPropertyBrowsing_GetPredefinedValue";
end;

define method IPerPropertyBrowsing/GetPredefinedValue(This :: <C-interface>,
		dispID, dwCookie, pVarOut :: <LPVARIANT>)
		=> (status :: <HRESULT>)
  IPerPropertyBrowsing_GetPredefinedValue(This, dispID, dwCookie,
		pVarOut)
end;


	/*  ----  IPropertyBag2  ----  */


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

define C-address IPropertyBag2_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPropertyBag2_DW_vtbl"; end;
define C-address $IID-IPropertyBag2 :: <REFIID>
		c-name: "IID_IPropertyBag2"; end;

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

define open generic IPropertyBag2/Read (This, cProperties,
		pPropBag, pErrLog, pvarValue)
		=> (status :: <HRESULT>, hrError);

define C-callable-wrapper of IPropertyBag2/Read
  input parameter This :: <mapped-interface>;
  input parameter cProperties :: <ULONG>;
  input parameter pPropBag :: <LPPROPBAG2>;
  input parameter pErrLog :: <C-interface>;
  parameter pvarValue :: <LPVARIANT>;
  output parameter phrError :: <C-HRESULT*>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyBag2_Read", c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyBag2_Read
  input parameter This :: <C-interface>;
  input parameter cProperties :: <ULONG>;
  input parameter pPropBag :: <LPPROPBAG2>;
  input parameter pErrLog :: <Interface>;
  parameter pvarValue :: <LPVARIANT>;
  output parameter phrError :: <C-HRESULT*>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyBag2_Read";
end;

define method IPropertyBag2/Read(This :: <C-interface>,
		cProperties, pPropBag :: <LPPROPBAG2>, pErrLog :: <Interface>,
		pvarValue :: <LPVARIANT>) => (status :: <HRESULT>, hrError)
  IPropertyBag2_Read(This, cProperties, pPropBag, pErrLog,
		pvarValue)
end;

define open generic IPropertyBag2/Write (This, cProperties,
		pPropBag, pvarValue) => (status :: <HRESULT>);

define C-callable-wrapper of IPropertyBag2/Write
  input parameter This :: <mapped-interface>;
  input parameter cProperties :: <ULONG>;
  input parameter pPropBag :: <LPPROPBAG2>;
  input parameter pvarValue :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyBag2_Write", c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyBag2_Write
  input parameter This :: <C-interface>;
  input parameter cProperties :: <ULONG>;
  input parameter pPropBag :: <LPPROPBAG2>;
  input parameter pvarValue :: <LPVARIANT>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyBag2_Write";
end;

define method IPropertyBag2/Write(This :: <C-interface>,
		cProperties, pPropBag :: <LPPROPBAG2>,
		pvarValue :: <LPVARIANT>) => (status :: <HRESULT>)
  IPropertyBag2_Write(This, cProperties, pPropBag, pvarValue)
end;

define open generic IPropertyBag2/CountProperties (This)
		=> (status :: <HRESULT>, cProperties);

define C-callable-wrapper of IPropertyBag2/CountProperties
  input parameter This :: <mapped-interface>;
  output parameter pcProperties :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyBag2_CountProperties",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyBag2_CountProperties
  input parameter This :: <C-interface>;
  output parameter pcProperties :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyBag2_CountProperties";
end;

define method IPropertyBag2/CountProperties(This :: <C-interface>)
		=> (status :: <HRESULT>, cProperties)
  IPropertyBag2_CountProperties(This)
end;

define open generic IPropertyBag2/GetPropertyInfo (This,
		iProperty, cProperties, pPropBag)
		=> (status :: <HRESULT>, cProperties);

define C-callable-wrapper of IPropertyBag2/GetPropertyInfo
  input parameter This :: <mapped-interface>;
  input parameter iProperty :: <ULONG>;
  input parameter cProperties :: <ULONG>;
  parameter pPropBag :: <LPPROPBAG2>;
  output parameter pcProperties :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyBag2_GetPropertyInfo",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyBag2_GetPropertyInfo
  input parameter This :: <C-interface>;
  input parameter iProperty :: <ULONG>;
  input parameter cProperties :: <ULONG>;
  parameter pPropBag :: <LPPROPBAG2>;
  output parameter pcProperties :: <LPULONG>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyBag2_GetPropertyInfo";
end;

define method IPropertyBag2/GetPropertyInfo(This :: <C-interface>,
		iProperty, cProperties, pPropBag :: <LPPROPBAG2>)
		=> (status :: <HRESULT>, cProperties)
  IPropertyBag2_GetPropertyInfo(This, iProperty, cProperties,
		pPropBag)
end;

define open generic IPropertyBag2/LoadObject (This, pstrName,
		dwHint, pUnkObject, pErrLog) => (status :: <HRESULT>);

define C-callable-wrapper of IPropertyBag2/LoadObject
  input parameter This :: <mapped-interface>;
  input parameter pstrName :: <LPCOLESTR>;
  input parameter dwHint :: <DWORD>;
  input parameter pUnkObject :: <C-interface>;
  input parameter pErrLog :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPropertyBag2_LoadObject",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPropertyBag2_LoadObject
  input parameter This :: <C-interface>;
  input parameter pstrName :: <LPCOLESTR>;
  input parameter dwHint :: <DWORD>;
  input parameter pUnkObject :: <Interface>;
  input parameter pErrLog :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IPropertyBag2_LoadObject";
end;

define method IPropertyBag2/LoadObject(This :: <C-interface>,
		pstrName :: <string>, dwHint, pUnkObject :: <Interface>,
		pErrLog :: <Interface>) => (status :: <HRESULT>)
  IPropertyBag2_LoadObject(This, pstrName, dwHint, pUnkObject,
		pErrLog)
end;


	/*  ----  IPersistPropertyBag2  ----  */


define open primary COM-interface <IPersistPropertyBag2> ( <IPersist> )
end <IPersistPropertyBag2>;

define C-address IPersistPropertyBag2_DW_vtbl :: <C-COM-vtbl>
		c-name: "IPersistPropertyBag2_DW_vtbl"; end;
define C-address $IID-IPersistPropertyBag2 :: <REFIID>
		c-name: "IID_IPersistPropertyBag2"; end;

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

define open generic IPersistPropertyBag2/InitNew (This)
		=> (status :: <HRESULT>);

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

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

define method IPersistPropertyBag2/InitNew(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IPersistPropertyBag2_InitNew(This)
end;

define open generic IPersistPropertyBag2/Load (This, pPropBag,
		pErrLog) => (status :: <HRESULT>);

define C-callable-wrapper of IPersistPropertyBag2/Load
  input parameter This :: <mapped-interface>;
  input parameter pPropBag :: <C-interface>;
  input parameter pErrLog :: <C-interface>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistPropertyBag2_Load",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistPropertyBag2_Load
  input parameter This :: <C-interface>;
  input parameter pPropBag :: <Interface>;
  input parameter pErrLog :: <Interface>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistPropertyBag2_Load";
end;

define method IPersistPropertyBag2/Load(This :: <C-interface>,
		pPropBag :: <Interface>, pErrLog :: <Interface>)
		=> (status :: <HRESULT>)
  IPersistPropertyBag2_Load(This, pPropBag, pErrLog)
end;

define open generic IPersistPropertyBag2/Save (This, pPropBag,
		fClearDirty, fSaveAllProperties) => (status :: <HRESULT>);

define C-callable-wrapper of IPersistPropertyBag2/Save
  input parameter This :: <mapped-interface>;
  input parameter pPropBag :: <C-interface>;
  input parameter fClearDirty :: <BOOL>;
  input parameter fSaveAllProperties :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IPersistPropertyBag2_Save",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IPersistPropertyBag2_Save
  input parameter This :: <C-interface>;
  input parameter pPropBag :: <Interface>;
  input parameter fClearDirty :: <BOOL>;
  input parameter fSaveAllProperties :: <BOOL>;
  result status :: <C-HRESULT>;
  c-name: "C_IPersistPropertyBag2_Save";
end;

define method IPersistPropertyBag2/Save(This :: <C-interface>,
		pPropBag :: <Interface>, fClearDirty :: <boolean>,
		fSaveAllProperties :: <boolean>) => (status :: <HRESULT>)
  IPersistPropertyBag2_Save(This, pPropBag, fClearDirty,
		fSaveAllProperties)
end;

define open generic IPersistPropertyBag2/IsDirty (This)
		=> (status :: <HRESULT>);

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

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

define method IPersistPropertyBag2/IsDirty(This :: <C-interface>)
		=> (status :: <HRESULT>)
  IPersistPropertyBag2_IsDirty(This)
end;


	/*  ----  IAdviseSinkEx  ----  */


define open primary COM-interface <IAdviseSinkEx> ( <IAdviseSink> )
end <IAdviseSinkEx>;

define C-address IAdviseSinkEx_DW_vtbl :: <C-COM-vtbl>
		c-name: "IAdviseSinkEx_DW_vtbl"; end;
define C-address $IID-IAdviseSinkEx :: <REFIID>
		c-name: "IID_IAdviseSinkEx"; end;

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

define open generic IAdviseSinkEx/OnViewStatusChange (This,
		dwViewStatus) => ();

define C-callable-wrapper of IAdviseSinkEx/OnViewStatusChange
  input parameter This :: <mapped-interface>;
  input parameter dwViewStatus :: <DWORD>;
  c-name: "DW_IAdviseSinkEx_OnViewStatusChange",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IAdviseSinkEx_OnViewStatusChange
  input parameter This :: <C-interface>;
  input parameter dwViewStatus :: <DWORD>;
  c-name: "C_IAdviseSinkEx_OnViewStatusChange";
end;

define method IAdviseSinkEx/OnViewStatusChange(This :: <C-interface>,
		dwViewStatus) => ()
  IAdviseSinkEx_OnViewStatusChange(This, dwViewStatus)
end;


	/*  ----  IQuickActivate  ----  */


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

define C-address IQuickActivate_DW_vtbl :: <C-COM-vtbl>
		c-name: "IQuickActivate_DW_vtbl"; end;
define C-address $IID-IQuickActivate :: <REFIID>
		c-name: "IID_IQuickActivate"; end;

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

define open generic IQuickActivate/QuickActivate (This,
		pQaContainer, pQaControl) => (status :: <HRESULT>);

define C-callable-wrapper of IQuickActivate/QuickActivate
  input parameter This :: <mapped-interface>;
  input parameter pQaContainer :: <LPQACONTAINER>;
   parameter pQaControl :: <LPQACONTROL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IQuickActivate_QuickActivate",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IQuickActivate_QuickActivate
  input parameter This :: <C-interface>;
  input parameter pQaContainer :: <LPQACONTAINER>;
   parameter pQaControl :: <LPQACONTROL>;
  result status :: <C-HRESULT>;
  c-name: "C_IQuickActivate_QuickActivate";
end;

define method IQuickActivate/QuickActivate(This :: <C-interface>,
		pQaContainer :: <LPQACONTAINER>, pQaControl :: <LPQACONTROL>)
		=> (status :: <HRESULT>)
  IQuickActivate_QuickActivate(This, pQaContainer, pQaControl)
end;

define open generic IQuickActivate/SetContentExtent (This,
		pSizel) => (status :: <HRESULT>);

define C-callable-wrapper of IQuickActivate/SetContentExtent
  input parameter This :: <mapped-interface>;
  input parameter pSizel :: <LPSIZEL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IQuickActivate_SetContentExtent",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IQuickActivate_SetContentExtent
  input parameter This :: <C-interface>;
  input parameter pSizel :: <LPSIZEL>;
  result status :: <C-HRESULT>;
  c-name: "C_IQuickActivate_SetContentExtent";
end;

define method IQuickActivate/SetContentExtent(This :: <C-interface>,
		pSizel :: <LPSIZEL>) => (status :: <HRESULT>)
  IQuickActivate_SetContentExtent(This, pSizel)
end;

define open generic IQuickActivate/GetContentExtent (This,
		pSizel) => (status :: <HRESULT>);

define C-callable-wrapper of IQuickActivate/GetContentExtent
  input parameter This :: <mapped-interface>;
  parameter pSizel :: <LPSIZEL>;
  result status :: <C-HRESULT>;
  c-name: "DW_IQuickActivate_GetContentExtent",
		c-modifiers: "__stdcall";
end;

define inline-only C-function IQuickActivate_GetContentExtent
  input parameter This :: <C-interface>;
  parameter pSizel :: <LPSIZEL>;
  result status :: <C-HRESULT>;
  c-name: "C_IQuickActivate_GetContentExtent";
end;

define method IQuickActivate/GetContentExtent(This :: <C-interface>,
		pSizel :: <LPSIZEL>) => (status :: <HRESULT>)
  IQuickActivate_GetContentExtent(This, pSizel)
end;
