home *** CD-ROM | disk | FTP | other *** search
/ PC Format Collection 48 / SENT14D.ISO / tech / delphi / disk14 / doc.pak / DISPATCH.INT < prev    next >
Encoding:
Text File  |  1995-08-24  |  40.3 KB  |  907 lines
  1.  
  2. {*******************************************************}
  3. {                                                       }
  4. {       Delphi Runtime Library                          }
  5. {       Windows 3.1 API Interface Unit                  }
  6. {                                                       }
  7. {       Copyright (c) 1992,93 Borland International     }
  8. {                                                       }
  9. {*******************************************************}
  10.  
  11. unit Dispatch;
  12.  
  13. interface
  14.  
  15. uses WinTypes, OLE2;
  16.  
  17. const
  18.  
  19.   FADF_AUTO      = $0001;  { array is allocated on the stack }
  20.   FADF_STATIC    = $0002;  { array is staticly allocated }
  21.   FADF_EMBEDDED  = $0004;  { array is embedded in a structure }
  22.   FADF_FIXEDSIZE = $0010;  { array may not be resized or reallocated }
  23.   FADF_BSTR      = $0100;  { an array of BSTRs }
  24.   FADF_UNKNOWN   = $0200;  { an array of IUnknown }
  25.   FADF_DISPATCH  = $0400;  { an array of IDispatch }
  26.   FADF_VARIANT   = $0800;  { an array of VARIANTs }
  27.   FADF_RESERVED  = $F0E8;  { bits reserved for future use }
  28.  
  29. { VARENUM usage key,
  30.  
  31.     [V] - may appear in a VARIANT
  32.     [T] - may appear in a TYPEDESC
  33.     [P] - may appear in an OLE property set
  34.     [S] - may appear in a Safe Array }
  35.  
  36.   VT_EMPTY           = 0;   { [V]   [P]  nothing                     }
  37.   VT_NULL            = 1;   { [V]        SQL style Null              }
  38.   VT_I2              = 2;   { [V][T][P]  2 byte signed int           }
  39.   VT_I4              = 3;   { [V][T][P]  4 byte signed int           }
  40.   VT_R4              = 4;   { [V][T][P]  4 byte real                 }
  41.   VT_R8              = 5;   { [V][T][P]  8 byte real                 }
  42.   VT_CY              = 6;   { [V][T][P]  currency                    }
  43.   VT_DATE            = 7;   { [V][T][P]  date                        }
  44.   VT_BSTR            = 8;   { [V][T][P]  binary string               }
  45.   VT_DISPATCH        = 9;   { [V][T]     IDispatch FAR*              }
  46.   VT_ERROR           = 10;  { [V][T]     SCODE                       }
  47.   VT_BOOL            = 11;  { [V][T][P]  True=-1, False=0            }
  48.   VT_VARIANT         = 12;  { [V][T][P]  VARIANT FAR*                }
  49.   VT_UNKNOWN         = 13;  { [V][T]     IUnknown FAR*               }
  50.  
  51.   VT_I1              = 16;  {    [T]     signed char                 }
  52.   VT_UI1             = 17;  {    [T]     unsigned char               }
  53.   VT_UI2             = 18;  {    [T]     unsigned short              }
  54.   VT_UI4             = 19;  {    [T]     unsigned short              }
  55.   VT_I8              = 20;  {    [T][P]  signed 64-bit int           }
  56.   VT_UI8             = 21;  {    [T]     unsigned 64-bit int         }
  57.   VT_INT             = 22;  {    [T]     signed machine int          }
  58.   VT_UINT            = 23;  {    [T]     unsigned machine int        }
  59.   VT_VOID            = 24;  {    [T]     C style void                }
  60.   VT_HRESULT         = 25;  {    [T]                                 }
  61.   VT_PTR             = 26;  {    [T]     pointer type                }
  62.   VT_SAFEARRAY       = 27;  {    [T]     (use VT_ARRAY in VARIANT)   }
  63.   VT_CARRAY          = 28;  {    [T]     C style array               }
  64.   VT_USERDEFINED     = 29;  {    [T]     user defined type          }
  65.   VT_LPSTR           = 30;  {    [T][P]  null terminated string      }
  66.   VT_LPWSTR          = 31;  {    [T][P]  wide null terminated string }
  67.  
  68.   VT_FILETIME        = 64;  {       [P]  FILETIME                    }
  69.   VT_BLOB            = 65;  {       [P]  Length prefixed bytes       }
  70.   VT_STREAM          = 66;  {       [P]  Name of the stream follows  }
  71.   VT_STORAGE         = 67;  {       [P]  Name of the storage follows }
  72.   VT_STREAMED_OBJECT = 68;  {       [P]  Stream contains an object   }
  73.   VT_STORED_OBJECT   = 69;  {       [P]  Storage contains an object  }
  74.   VT_BLOB_OBJECT     = 70;  {       [P]  Blob contains an object     }
  75.   VT_CF              = 71;  {       [P]  Clipboard format            }
  76.   VT_CLSID           = 72;  {       [P]  A Class ID                  }
  77.  
  78.   VT_VECTOR          = $1000; {       [P]  simple counted array        }
  79.   VT_ARRAY           = $2000; { [V]        SAFEARRAY*                  }
  80.   VT_BYREF           = $4000; { [V]                                    }
  81.   VT_RESERVED        = $8000;
  82.  
  83.   STDOLE_MAJORVERNUM = 1;
  84.   STDOLE_MINORVERNUM = 0;
  85.   STDOLE_LCID = 0;
  86.  
  87. { OLE Automation error codes }
  88.  
  89.   DISP_E_UNKNOWNINTERFACE = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (1);
  90.   DISP_E_MEMBERNOTFOUND = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (3);
  91.   DISP_E_PARAMNOTFOUND = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (4);
  92.   DISP_E_TYPEMISMATCH = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (5);
  93.   DISP_E_UNKNOWNNAME = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (6);
  94.   DISP_E_NONAMEDARGS = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (7);
  95.   DISP_E_BADVARTYPE = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (8);
  96.   DISP_E_EXCEPTION = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (9);
  97.   DISP_E_OVERFLOW = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (10);
  98.   DISP_E_BADINDEX = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (11);
  99.   DISP_E_UNKNOWNLCID = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (12);
  100.   DISP_E_ARRAYISLOCKED = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (13);
  101.   DISP_E_BADPARAMCOUNT = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (14);
  102.   DISP_E_PARAMNOTOPTIONAL = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (15);
  103.   DISP_E_BADCALLEE = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (16);
  104.   DISP_E_NOTACOLLECTION = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (17);
  105.  
  106.   TYPE_E_BUFFERTOOSMALL = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32790);
  107.   TYPE_E_INVDATAREAD = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32792);
  108.   TYPE_E_UNSUPFORMAT = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32793);
  109.   TYPE_E_REGISTRYACCESS = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32796);
  110.   TYPE_E_LIBNOTREGISTERED = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32797);
  111.   TYPE_E_UNDEFINEDTYPE = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32807);
  112.   TYPE_E_QUALIFIEDNAMEDISALLOWED = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32808);
  113.   TYPE_E_INVALIDSTATE = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32809);
  114.   TYPE_E_WRONGTYPEKIND = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32810);
  115.   TYPE_E_ELEMENTNOTFOUND = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32811);
  116.   TYPE_E_AMBIGUOUSNAME = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32812);
  117.   TYPE_E_NAMECONFLICT = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32813);
  118.   TYPE_E_UNKNOWNLCID = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32814);
  119.   TYPE_E_DLLFUNCTIONNOTFOUND = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32815);
  120.   TYPE_E_BADMODULEKIND = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (35005);
  121.   TYPE_E_SIZETOOBIG = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (35013);
  122.   TYPE_E_DUPLICATEID = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (35014);
  123.   TYPE_E_INVALIDID = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (35023);
  124.   TYPE_E_TYPEMISMATCH = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (36000);
  125.   TYPE_E_OUTOFBOUNDS = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (36001);
  126.   TYPE_E_IOERROR = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (36002);
  127.   TYPE_E_CANTCREATETMPFILE = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (36003);
  128.   TYPE_E_CANTLOADLIBRARY = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (40010);
  129.   TYPE_E_INCONSISTENTPROPFUNCS = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (40067);
  130.   TYPE_E_CIRCULARTYPE = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (40068);
  131.  
  132.   VARIANT_NOVALUEPROP = 1;
  133.   VAR_TIMEVALUEONLY = 1; { return time value }
  134.   VAR_DATEVALUEONLY = 2; { return date value }
  135.  
  136. { DISPID reserved for the standard "value" property }
  137.  
  138.   DISPID_VALUE = 0;
  139.  
  140. { DISPID reserved to indicate an "unknown" name }
  141.  
  142.   DISPID_UNKNOWN =  -1;
  143.  
  144. { The following DISPID is reserved to indicate the param
  145.   that is the right-hand-side (or "put" value) of a PropertyPut }
  146.  
  147.   DISPID_PROPERTYPUT = -3;
  148.  
  149. { DISPID reserved for the standard "NewEnum" method }
  150.  
  151.   DISPID_NEWENUM  = -4;
  152.  
  153. { DISPID reserved for the standard "Evaluate" method }
  154.  
  155.   DISPID_EVALUATE  = -5;
  156.   DISPID_CONSTRUCTOR = -6;
  157.   DISPID_DESTRUCTOR = -7;
  158.  
  159.   MEMBERID_NIL = DISPID_UNKNOWN;
  160.   ID_DEFAULTINST = -2;
  161.  
  162.   IDLFLAG_NONE = 0;
  163.   IDLFLAG_FIN = 1;
  164.   IDLFLAG_FOUT = 2;
  165.   IDLFLAG_FLCID = 4;
  166.   IDLFLAG_FRETVAL = 8;
  167.  
  168. { Flags for IDispatch::Invoke }
  169.  
  170.   DISPATCH_METHOD = 1;
  171.   DISPATCH_PROPERTYGET = 2;
  172.   DISPATCH_PROPERTYPUT = 4;
  173.   DISPATCH_PROPERTYPUTREF = 8;
  174.  
  175.   TYPEFLAG_FOLEAUTOMATION = $100;
  176.   TYPEFLAG_FNONEXTENSIBLE = $80;
  177.   TYPEFLAG_FDUAL = $40;
  178.   TYPEFLAG_FCONTROL = $20;
  179.   TYPEFLAG_FHIDDEN = $10;
  180.   TYPEFLAG_FPREDECLID = 8;
  181.   TYPEFLAG_FLICENSED = 4;
  182.   TYPEFLAG_FCANCREATE = 2;
  183.   TYPEFLAG_FAPPOBJECT = 1;
  184.  
  185.   FUNCFLAG_FHIDDEN = $40;
  186.   FUNCFLAG_FDEFAULTBIND = $20;
  187.   FUNCFLAG_FDISPLAYBIND = $10;
  188.   FUNCFLAG_FREQUESTEDIT = 8;
  189.   FUNCFLAG_FBINDABLE = 4;
  190.   FUNCFLAG_FSOURCE = 2;
  191.   FUNCFLAG_FRESTRICTED = 1;
  192.  
  193.   VARFLAG_FHIDDEN = $40;
  194.   VARFLAG_FDEFAULTBIND = $20;
  195.   VARFLAG_FDISPLAYBIND = $10;
  196.   VARFLAG_FREQUESTEDIT = 8;
  197.   VARFLAG_FBINDABLE = 4;
  198.   VARFLAG_FSOURCE = 2;
  199.   VARFLAG_FREADONLY = 1;
  200.  
  201.   IMPLTYPEFLAG_FDEFAULT = 1;
  202.   IMPLTYPEFLAG_FSOURCE = 2;
  203.   IMPLTYPEFLAG_FRESTRICTED = 4;
  204.  
  205. { flags for RegisterActiveObject }
  206.  
  207.   ACTIVEOBJECT_STRONG = 0;
  208.   ACTIVEOBJECT_WEAK = 1;
  209.  
  210.   INVOKE_FUNC = 1;
  211.   INVOKE_PROPERTYGET = 2;
  212.   INVOKE_PROPERTYPUT = 4;
  213.   INVOKE_PROPERTYPUTREF = 8;
  214.  
  215.   SYS_WIN16 = 0;
  216.   SYS_WIN32 = 1;
  217.   SYS_MAC = 2;
  218.  
  219.   LIBFLAG_FRESTRICTED = 1;
  220.   LIBFLAG_FCONTROL = 2;
  221.   LIBFLAG_FHIDDEN = 4;
  222.  
  223.   TKIND_ENUM = 0;
  224.   TKIND_RECORD = 1;
  225.   TKIND_MODULE = 2;
  226.   TKIND_INTERFACE = 3;
  227.   TKIND_DISPATCH = 4;
  228.   TKIND_COCLASS = 5;
  229.   TKIND_ALIAS = 6;
  230.   TKIND_UNION = 7;
  231.   TKIND_MAX = 8;
  232.  
  233.   CC_CDECL = 1;
  234.   CC_PASCAL = 2;
  235.   CC_MACPASCAL = 3;
  236.   CC_STDCALL = 4;
  237.   CC_RESERVED = 5;
  238.   CC_SYSCALL = 6;
  239.   CC_MPWCDECL = 7;
  240.   CC_MPWPASCAL = 8;
  241.   CC_MAX = 9;
  242.  
  243.   FUNC_VIRTUAL = 0;
  244.   FUNC_PUREVIRTUAL = 1;
  245.   FUNC_NONVIRTUAL = 2;
  246.   FUNC_STATIC = 3;
  247.   FUNC_DISPATCH = 4;
  248.  
  249.   VAR_PERINSTANCE = 0;
  250.   VAR_STATIC = 1;
  251.   VAR_CONST = 2;
  252.   VAR_DISPATCH = 3;
  253.  
  254.   DESCKIND_NONE = 0;
  255.   DESCKIND_FUNCDESC = 1;
  256.   DESCKIND_VARDESC = 2;
  257.   DESCKIND_TYPECOMP = 3;
  258.   DESCKIND_IMPLICITAPPOBJ = 4;
  259.   DESCKIND_MAX = 5;
  260.  
  261. type
  262.  
  263.   IDispatch = class;
  264.   ITypeInfo = class;
  265.   ITypeComp = class;
  266.  
  267.   BSTR = PChar;
  268.  
  269.   PSAFEARRAYBOUND = ^SAFEARRAYBOUND;
  270.   SAFEARRAYBOUND = record
  271.     cElements: Longint;
  272.     lLbound: Longint;
  273.   end;
  274.  
  275.   PSAFEARRAY = ^SAFEARRAY;
  276.   SAFEARRAY = record
  277.     cDims: Longint;
  278.     fFeatures: Longint;
  279.     cbElements: Longint;
  280.     cLocks: Longint;
  281.     handle: Longint;
  282.     pvData: Pointer;
  283.     rgsabound: array[0..0] of SAFEARRAYBOUND;
  284.   end;
  285.  
  286.   VARIANT_BOOL = WordBool;
  287.  
  288.   DATE = Double;
  289.  
  290. { This is a helper record for use in handling currency }
  291.  
  292.   CY = record
  293.     Lo: Longint;
  294.     Hi: Longint;
  295.   end;
  296.  
  297.   VARTYPE = Word;
  298.  
  299.   PVARIANT = ^VARIANT;
  300.   VARIANT = record
  301.     vt: VARTYPE;
  302.     wReserved1: Word;
  303.     wReserved2: Word;
  304.     wReserved3: Word;
  305.     case Integer of
  306.       VT_UI1:                  (bVal: Byte);
  307.       VT_I2:                   (iVal: Smallint);
  308.       VT_I4:                   (lVal: Longint);
  309.       VT_R4:                   (fltVal: Single);
  310.       VT_R8:                   (dblVal: Double);
  311.       VT_BOOL:                 (vbool: BOOL);
  312.       VT_ERROR:                (scode: SCODE);
  313.       VT_CY:                   (cyVal: CY);
  314.       VT_DATE:                 (date: DATE);
  315.       VT_BSTR:                 (bstrVal: BSTR);
  316.       VT_UNKNOWN:              (punkVal: IUnknown);
  317.       VT_DISPATCH:             (pdispVal: IDispatch);
  318.       VT_ARRAY:                (parray: PSAFEARRAY);
  319.       VT_BYREF or VT_UI1:      (pbVal: ^Byte);
  320.       VT_BYREF or VT_I2:       (piVal: ^Smallint);
  321.       VT_BYREF or VT_I4:       (plVal: ^Longint);
  322.       VT_BYREF or VT_R4:       (pfltVal: ^Single);
  323.       VT_BYREF or VT_R8:       (pdblVal: ^Double);
  324.       VT_BYREF or VT_BOOL:     (pbool: ^BOOL);
  325.       VT_BYREF or VT_ERROR:    (pscode: ^SCODE);
  326.       VT_BYREF or VT_CY:       (pcyVal: ^CY);
  327.       VT_BYREF or VT_DATE:     (pdate: ^DATE);
  328.       VT_BYREF or VT_BSTR:     (pbstrVal: ^BSTR);
  329.       VT_BYREF or VT_UNKNOWN:  (ppunkVal: ^IUnknown);
  330.       VT_BYREF or VT_DISPATCH: (ppdispVal: ^IDispatch);
  331.       VT_BYREF or VT_ARRAY:    (pparray: ^PSAFEARRAY);
  332.       VT_BYREF or VT_VARIANT:  (pvarVal: PVARIANT);
  333.       VT_BYREF:                (byRef: Pointer);
  334.   end;
  335.  
  336.   VARIANTARG = VARIANT;
  337.   PVARIANTARG = PVARIANT;
  338.  
  339.   LCID = Longint;
  340.  
  341. { ITypeLib }
  342.  
  343.   DISPID = Longint;
  344.   MEMBERID = DISPID;
  345.  
  346.   PTLIBATTR = ^TLIBATTR;
  347.   TLIBATTR = record
  348.     guid: GUID; { globally unique library id }
  349.     lcid: LCID; { locale of the TypeLibrary }
  350.     syskind: Word;
  351.     wMajorVerNum: Word;
  352.     wMinorVerNum: Word;
  353.     wLibFlags: Word;
  354.   end;
  355.  
  356.   ITypeLib = class(IUnknown)
  357.     function GetTypeInfoCount: Integer; virtual; cdecl; export; abstract;
  358.     function GetTypeInfo(index: Integer; var pptinfo: ITypeInfo): HResult; virtual; cdecl; export; abstract;
  359.     function GetTypeInfoType(index: Integer; var ptypekind: Word): HResult;
  360.       virtual; cdecl; export; abstract;
  361.     function GetTypeInfoOfGuid(const guid: IID; var pptinfo: ITypeInfo): HResult;
  362.       virtual; cdecl; export; abstract;
  363.     function GetLibAttr(var pptlibattr: PTLIBATTR): HResult; virtual; cdecl; export; abstract;
  364.     function GetTypeComp(var pptcomp: ITypeComp): HResult; virtual; cdecl; export; abstract;
  365.     function GetDocumentation(index: Integer; var pbstrName: BSTR;
  366.       var pbstrDocString: BSTR; var pdwHelpContext: Longint;
  367.       var pbstrHelpFile: BSTR): HResult; virtual; cdecl; export; abstract;
  368.     function IsName(szNameBuf: PChar; lHashVal: Longint; var lpfName: Integer): HResult;
  369.       virtual; cdecl; export; abstract;
  370.     function FindName(szNameBuf: PChar; lHashVal: Longint; var rgptinfo: ITypeInfo;
  371.       var rgmemid: MEMBERID; var pcFound: Word): HResult; virtual; cdecl; export; abstract;
  372.     procedure ReleaseTLibAttr(ptlibattr: PTLIBATTR); virtual; cdecl; export; abstract;
  373.   end;
  374.  
  375. { ITypeInfo }
  376.  
  377.   HREFTYPE = Longint;
  378.  
  379.   PARRAYDESC = ^ARRAYDESC;
  380.  
  381.   PTYPEDESC = ^TYPEDESC;
  382.   TYPEDESC = record
  383.     case Integer of
  384.       VT_PTR:         (ptdesc: PTYPEDESC; vt: VARTYPE);
  385.       VT_CARRAY:      (padesc: PARRAYDESC);
  386.       VT_USERDEFINED: (hreftype: HREFTYPE);
  387.   end;
  388.  
  389.   ARRAYDESC = record
  390.     tdescElem: TYPEDESC;                     { element type }
  391.     cDims: Word;                             { dimension count }
  392.     rgbounds: array[0..0] of SAFEARRAYBOUND; { variable length array of bounds }
  393.   end;
  394.  
  395.   PIDLDESC = ^IDLDESC;
  396.   IDLDESC = record
  397.     bstrIDLInfo: BSTR; { reserved, but original name retained for compatibilty }
  398.     wIDLFlags: Word;   { IN, OUT, etc }
  399.   end;
  400.  
  401.   PELEMDESC = ^ELEMDESC;
  402.   ELEMDESC = record
  403.     tdesc: TYPEDESC;  { the type of the element }
  404.     idldesc: IDLDESC; { info for remoting the element }
  405.   end;
  406.  
  407.   PTYPEATTR = ^TYPEATTR;
  408.   TYPEATTR = record
  409.     guid: GUID;                 { the GUID of the TypeInfo }
  410.     lcid: LCID;                 { locale of member names and doc strings }
  411.     dwReserved: Longint;
  412.     memidConstructor: MEMBERID; { ID of constructor, MEMBERID_NIL if none }
  413.     memidDestructor: MEMBERID;  { ID of destructor, MEMBERID_NIL if none }
  414.     lpstrSchema: PChar;         { reserved for future use }
  415.     cbSizeInstance: Longint;    { the size of an instance of this type }
  416.     typekind: Word;             { the kind of type this typeinfo describes }
  417.     cFuncs: Word;               { number of functions }
  418.     cVars: Word;                { number of variables / data members }
  419.     cImplTypes: Word;           { number of implemented interfaces }
  420.     cbSizeVft: Word;            { the size of this types virtual func table }
  421.     cbAlignment: Word;          { the alignment for an instance of this type }
  422.     wTypeFlags: Word;
  423.     wMajorVerNum: Word;         { major version number }
  424.     wMinorVerNum: Word;         { minor version number }
  425.     tdescAlias: TYPEDESC;       { if typekind == TKIND_ALIAS this specifies
  426.                                   the type for which this type is an alias }
  427.     idldescType: IDLDESC;       { IDL attributes of the described type }
  428.   end;
  429.  
  430.   PDISPPARAMS = ^DISPPARAMS;
  431.   DISPPARAMS = record
  432.     rgvarg: PVARIANTARG;
  433.     rgdispidNamedArgs: ^DISPID;
  434.     cArgs: Word;
  435.     cNamedArgs: Word;
  436.   end;
  437.  
  438.   PEXEPINFO = ^EXCEPINFO;
  439.  
  440.   TFNDeferredFillIn = function(ExInfo: PEXEPINFO): HResult;
  441.  
  442.   EXCEPINFO = record
  443.     { An error code describing the error. Either (but not both) the
  444.       wCode or scode fields must be set }
  445.     wCode: Word;
  446.     wReserved: Word;
  447.     { A textual, human readable name of the source of the exception.
  448.       It is up to the IDispatch implementor to fill this in.
  449.       Typically this will be an application name. }
  450.     bstrSource: BSTR;
  451.     { A textual, human readable description of the error.
  452.       If no description is available, NULL should be used. }
  453.     bstrDescription: BSTR;
  454.     { Fully qualified drive, path, and file name of a help file with more
  455.       information about the error.  If no help is available, NULL should
  456.       be used. }
  457.     bstrHelpFile: BSTR;
  458.     { help context of topic within the help file. }
  459.     dwHelpContext: Longint;
  460.     pvReserved: Pointer;
  461.     { Use of this field allows an application to defer filling in
  462.       the bstrDescription, bstrHelpFile, and dwHelpContext fields
  463.       until they are needed.  This field might be used, for example,
  464.       if loading the string for the error is a time-consuming
  465.       operation. If deferred fill-in is not desired, this field should
  466.       be set to NULL. }
  467.     pfnDeferredFillIn: TFNDeferredFillIn;
  468.     { An SCODE describing the error. }
  469.     scode: SCODE;
  470.   end;
  471.  
  472.   PFUNCDESC = ^FUNCDESC;
  473.   FUNCDESC = record
  474.      memid: MEMBERID;
  475.      lprgscode: ^SCODE;
  476.      lprgelemdescParam: PELEMDESC;  { array of parameter types }
  477.      fkind: Word;
  478.      ikind: Word;
  479.      cconv: Word;
  480.      cParams: Smallint;
  481.      cParamsOpt: Smallint;
  482.      oVft: Smallint;
  483.      cScodes: Smallint;
  484.      elemdescFunc: ELEMDESC;
  485.      wFuncFlags: Word;
  486.   end;
  487.  
  488.   PVARDESC = ^VARDESC;
  489.   VARDESC = record
  490.     memid: MEMBERID;
  491.     lpstrSchema: PChar;
  492.     case Integer of
  493.       VAR_PERINSTANCE: (
  494.         oInst: Longint;
  495.         elemdescVar: ELEMDESC;
  496.         wVarFlags: Word;
  497.         vk: Word);
  498.       VAR_CONST: (
  499.         lpvarValue: PVARIANT);
  500.   end;
  501.  
  502.   ITypeInfo = class(IUnknown)
  503.     function GetTypeAttr(var pptypeattr: PTYPEATTR): HResult; virtual; cdecl; export; abstract;
  504.     function GetTypeComp(var pptcomp: ITypeComp): HResult; virtual; cdecl; export; abstract;
  505.     function GetFuncDesc(index: Integer; var ppfuncdesc: PFUNCDESC): HResult;
  506.       virtual; cdecl; export; abstract;
  507.     function GetVarDesc(index: Integer; var ppvardesc: PVARDESC): HResult;
  508.       virtual; cdecl; export; abstract;
  509.     function GetNames(memid: MEMBERID; var rgbstrNames: BSTR; cMaxNames: Integer;
  510.       var pcNames: Integer): HResult; virtual; cdecl; export; abstract;
  511.     function GetRefTypeOfImplType(index: Integer; var phreftype: HREFTYPE): HResult;
  512.       virtual; cdecl; export; abstract;
  513.     function GetImplTypeFlags(index: Integer; var pimpltypeflags: Integer): HResult;
  514.       virtual; cdecl; export; abstract;
  515.     function GetIDsOfNames(var rgszNames: PChar; cNames: Integer;
  516.       var rgmemid: MEMBERID): HResult; virtual; cdecl; export; abstract;
  517.     function Invoke(pvInstance: Pointer; memid: MEMBERID; wFlags: Word;
  518.       var pdispparams: DISPPARAMS; var pvarResult: VARIANT;
  519.       var pexcepinfo: EXCEPINFO; var puArgErr: Integer): HResult; virtual; cdecl; export; abstract;
  520.     function GetDocumentation(memid: MEMBERID; var pbstrName: BSTR;
  521.       var pbstrDocString: BSTR; var pdwHelpContext: Longint;
  522.       var pbstrHelpFile: BSTR): HResult; virtual; cdecl; export; abstract;
  523.     function GetDllEntry(memid: MEMBERID; invkind: Word;
  524.       var pbstrDllName: BSTR; var pbstrName: BSTR; var pwOrdinal: Word): HResult;
  525.       virtual; cdecl; export; abstract;
  526.     function GetRefTypeInfo(hreftype: HREFTYPE; var pptinfo: ITypeInfo): HResult;
  527.       virtual; cdecl; export; abstract;
  528.     function AddressOfMember(memid: MEMBERID; invkind: Word;
  529.       var ppv: Pointer): HResult; virtual; cdecl; export; abstract;
  530.     function CreateInstance(punkOuter: IUnknown; const riid: IID;
  531.       var ppvObj: Pointer): HResult; virtual; cdecl; export; abstract;
  532.     function GetMops(memid: MEMBERID; var pbstrMops: BSTR): HResult;
  533.       virtual; cdecl; export; abstract;
  534.     function GetContainingTypeLib(var pptlib: ITypeLib; var pindex: Integer): HResult;
  535.       virtual; cdecl; export; abstract;
  536.     procedure ReleaseTypeAttr(ptypeattr: PTYPEATTR); virtual; cdecl; export; abstract;
  537.     procedure ReleaseFuncDesc(pfuncdesc: PFUNCDESC); virtual; cdecl; export; abstract;
  538.     procedure ReleaseVarDesc(pvardesc: PVARDESC); virtual; cdecl; export; abstract;
  539.   end;
  540.  
  541. { ITypeComp }
  542.  
  543.   BINDPTR = record
  544.     case Integer of
  545.       1: (lpfuncdesc: PFUNCDESC);
  546.       2: (lpvardesc: PVARDESC);
  547.       3: (lptcomp: ITypeComp);
  548.   end;
  549.  
  550. { ITypeComp methods }
  551.  
  552.   ITypeComp = class(IUnknown)
  553.     function Bind(szName: PChar; lHashVal: Longint; wflags: Word;
  554.       var pptinfo: ITypeInfo; var pdesckind: Word;
  555.       var pbindptr: BINDPTR): HResult; virtual; cdecl; export; abstract;
  556.     function BindType(szName: PChar; lHashVal: Longint; var pptinfo: ITypeInfo;
  557.       var pptcomp: ITypeComp): HResult; virtual; cdecl; export; abstract;
  558.   end;
  559.  
  560. { ICreateTypeLib }
  561.  
  562.   ICreateTypeInfo = class;
  563.   ICreateTypeLib = class(IUnknown)
  564.     function CreateTypeInfo(szName: PChar; tkind: Word;
  565.       var lplpictinfo: ICreateTypeInfo): HResult; virtual; cdecl; export; abstract;
  566.     function SetName(szName: PChar): HResult; virtual; cdecl; export; abstract;
  567.     function SetVersion(wMajorVerNum: Word; wMinorVerNum: Word): HResult; virtual; cdecl; export; abstract;
  568.     function SetGuid(const guid: IID): HResult; virtual; cdecl; export; abstract;
  569.     function SetDocString(szDoc: PChar): HResult; virtual; cdecl; export; abstract;
  570.     function SetHelpFileName(szHelpFileName: PChar): HResult; virtual; cdecl; export; abstract;
  571.     function SetHelpContext(dwHelpContext: Longint): HResult; virtual; cdecl; export; abstract;
  572.     function SetLcid(lcid: LCID): HResult; virtual; cdecl; export; abstract;
  573.     function SetLibFlags(uLibFlags: Integer): HResult; virtual; cdecl; export; abstract;
  574.     function SaveAllChanges: HResult; virtual; cdecl; export; abstract;
  575.   end;
  576.  
  577. { ICreateTypeInfo }
  578.  
  579.   ICreateTypeInfo = class(IUnknown)
  580.     function SetGuid(const guid: IID): HResult; virtual; cdecl; export; abstract;
  581.     function SetTypeFlags(uTypeFlags: Integer): HResult; virtual; cdecl; export; abstract;
  582.     function SetDocString(pstrDoc: PChar): HResult; virtual; cdecl; export; abstract;
  583.     function SetHelpContext(dwHelpContext: Longint): HResult; virtual; cdecl; export; abstract;
  584.     function SetVersion(wMajorVerNum: Word; wMinorVerNum: Word): HResult;
  585.       virtual; cdecl; export; abstract;
  586.     function AddRefTypeInfo(ptinfo: ITypeInfo; var phreftype: HREFTYPE): HResult;
  587.       virtual; cdecl; export; abstract;
  588.     function AddFuncDesc(index: Integer; var pfuncdesc: FUNCDESC): HResult;
  589.       virtual; cdecl; export; abstract;
  590.     function AddImplType(index: Integer; hreftype: HREFTYPE): HResult;
  591.       virtual; cdecl; export; abstract;
  592.     function SetImplTypeFlags(index: Integer; impltypeflags: Integer): HResult;
  593.       virtual; cdecl; export; abstract;
  594.     function SetAlignment(cbAlignment: Word): HResult; virtual; cdecl; export; abstract;
  595.     function SetSchema(lpstrSchema: PChar): HResult; virtual; cdecl; export; abstract;
  596.     function AddVarDesc(index: Integer; var pvardesc: VARDESC): HResult;
  597.       virtual; cdecl; export; abstract;
  598.     function SetFuncAndParamNames(index: Integer; var rgszNames: PChar;
  599.       cNames: Integer): HResult; virtual; cdecl; export; abstract;
  600.     function SetVarName(index: Integer; szName: PChar): HResult; virtual; cdecl; export; abstract;
  601.     function SetTypeDescAlias(var ptdescAlias: TYPEDESC): HResult; virtual; cdecl; export; abstract;
  602.     function DefineFuncAsDllEntry(index: Integer; szDllName: PChar;
  603.       szProcName: PChar): HResult; virtual; cdecl; export; abstract;
  604.     function SetFuncDocString(index: Integer; szDocString: PChar): HResult;
  605.       virtual; cdecl; export; abstract;
  606.     function SetVarDocString(index: Integer; szDocString: PChar): HResult;
  607.       virtual; cdecl; export; abstract;
  608.     function SetFuncHelpContext(index: Integer; dwHelpContext: Longint): HResult;
  609.       virtual; cdecl; export; abstract;
  610.     function SetVarHelpContext(index: Integer; dwHelpContext: Longint): HResult;
  611.       virtual; cdecl; export; abstract;
  612.     function SetMops(index: Integer; bstrMops: BSTR): HResult; virtual; cdecl; export; abstract;
  613.     function SetTypeIdldesc(var pidldesc: IDLDESC): HResult; virtual; cdecl; export; abstract;
  614.     function LayOut: HResult; virtual; cdecl; export; abstract;
  615.   end;
  616.  
  617. { IEnumVARIANT }
  618.  
  619.   IEnumVARIANT = class(IUnknown)
  620.     function Next(celt: Longint; var rgvar: VARIANT;
  621.       var pceltFetched: Longint): HResult; virtual; cdecl; export; abstract;
  622.     function Skip(celt: Longint): HResult; virtual; cdecl; export; abstract;
  623.     function Reset: HResult; virtual; cdecl; export; abstract;
  624.     function Clone(var ppenum: IEnumVARIANT): HResult; virtual; cdecl; export; abstract;
  625.   end;
  626.  
  627. { IDispatch }
  628.  
  629.   IDispatch = class(IUnknown)
  630.     function GetTypeInfoCount(var pctinfo: Integer): HResult; virtual; cdecl; export; abstract;
  631.     function GetTypeInfo(itinfo: Integer; lcid: LCID; var pptinfo: ITypeInfo): HResult; virtual; cdecl; export; abstract;
  632.     function GetIDsOfNames(const riid: IID; var rgszNames: PChar;
  633.       cNames: Integer; lcid: LCID; var rgdispid: DISPID): HResult; virtual; cdecl; export; abstract;
  634.     function Invoke(dispidMember: DISPID; const riid: IID; lcid: LCID;
  635.       wFlags: Word; var pdispparams: DISPPARAMS; var pvarResult: VARIANT;
  636.       var pexcepinfo: EXCEPINFO; var puArgErr: Integer): HResult; virtual; cdecl; export; abstract;
  637.   end;
  638.  
  639. { IErrorInfo }
  640.  
  641.   IErrorInfo = class(IUnknown)
  642.     function GetGUID(var pguid: GUID): HResult; virtual; cdecl; export; abstract;
  643.     function GetSource(var pbstrSource: BSTR): HResult; virtual; cdecl; export; abstract;
  644.     function GetDescription(var pbstrDescription: BSTR): HResult; virtual; cdecl; export; abstract;
  645.     function GetHelpFile(var pbstrHelpFile: BSTR): HResult; virtual; cdecl; export; abstract;
  646.     function GetHelpContext(var pdwHelpContext: Longint): HResult; virtual; cdecl; export; abstract;
  647.   end;
  648.  
  649. { ICreateErrorInfo methods }
  650.  
  651.   ICreateErrorInfo = class(IUnknown)
  652.     function SetGUID(const rguid: IID): HResult; virtual; cdecl; export; abstract;
  653.     function SetSource(szSource: PChar): HResult; virtual; cdecl; export; abstract;
  654.     function SetDescription(szDescription: PChar): HResult; virtual; cdecl; export; abstract;
  655.     function SetHelpFile(szHelpFile: PChar): HResult; virtual; cdecl; export; abstract;
  656.     function SetHelpContext(dwHelpContext: Longint): HResult; virtual; cdecl; export; abstract;
  657.   end;
  658.  
  659. { ISupportErrorInfo methods }
  660.  
  661.   ISupportErrorInfo = class(IUnknown)
  662.     function InterfaceSupportsErrorInfo(const riid: IID): HResult; virtual; cdecl; export; abstract;
  663.   end;
  664.  
  665. { IDispatch implementation support }
  666.  
  667.   PPARAMDATA = ^PARAMDATA;
  668.   PARAMDATA = record
  669.     szName: PChar; { parameter name }
  670.     vt: VARTYPE; { parameter type }
  671.   end;
  672.  
  673.   PMETHODDATA = ^METHODDATA;
  674.   METHODDATA = record
  675.     szName: PChar; { method name }
  676.     ppdata: PPARAMDATA; { pointer to an array of PARAMDATAs }
  677.     dispid: DISPID; { method ID }
  678.     iMeth: Integer; { method index }
  679.     cc: Word; { calling convention }
  680.     cArgs: Integer; { count of arguments }
  681.     wFlags: Word; { same wFlags as on IDispatch::Invoke() }
  682.     vtReturn: VARTYPE;
  683.   end;
  684.  
  685.   PINTERFACEDATA = ^INTERFACEDATA;
  686.   INTERFACEDATA = record
  687.     pmethdata: PMETHODDATA; { pointer to an array of METHODDATAs }
  688.     cMembers: Integer; { count of members }
  689.   end;
  690.  
  691. { IIDs }
  692.  
  693. function IID_IDispatch: GUID;
  694. function IID_ITypeInfo: GUID;
  695. function PIID_IDispatch: REFGUID;
  696. function PIID_ITypeInfo: REFGUID;
  697.  
  698. { BSTR API }
  699.  
  700. function SysAllocString(const p1: PChar): BSTR;
  701. function SysReAllocString(var p1: BSTR; const p2: PChar): Integer;
  702. function SysAllocStringLen(const p1: PChar; p2: Cardinal): BSTR;
  703. function SysReAllocStringLen(var p1: BSTR; const p2: PChar; p3: Cardinal): Integer;
  704. procedure SysFreeString(bstr: BSTR);
  705. function SysStringLen(p1: BSTR): Cardinal;
  706.  
  707. {$IFDEF WIN32}
  708. function SysStringByteLen(p1: BSTR): Word;
  709. function SysAllocStringByteLen(psz: PChar; len: Word): BSTR;
  710. {$ENDIF}
  711.  
  712. { Time API }
  713.  
  714. function DosDateTimeToVariantTime(wDosDate, wDosTime: Word; var pvtime: DATE): Integer;
  715. function VariantTimeToDosDateTime(vtime: DATE; var pwDosDate, pwDosTime: Word): Integer;
  716.  
  717. { SafeArray API }
  718.  
  719. function SafeArrayAllocDescriptor(cDims: Cardinal; var ppsaOut: PSAFEARRAY): HResult;
  720. function SafeArrayAllocData(psa: PSAFEARRAY): HResult;
  721. function SafeArrayCreate(vt: VARTYPE; cDims: Cardinal; rgsabound: PSAFEARRAYBOUND): PSAFEARRAY;
  722. function SafeArrayDestroyDescriptor(psa: PSAFEARRAY): HResult;
  723. function SafeArrayDestroyData(psa: PSAFEARRAY): HResult;
  724. function SafeArrayDestroy(psa: PSAFEARRAY): HResult;
  725. function SafeArrayRedim(psa: PSAFEARRAY; psaboundNew: PSAFEARRAYBOUND): HResult;
  726. function SafeArrayGetDim(psa: PSAFEARRAY): Cardinal;
  727. function SafeArrayGetElemsize(psa: PSAFEARRAY): Cardinal;
  728. function SafeArrayGetUBound(psa: PSAFEARRAY; nDim: Cardinal; var plUbound: Longint): HResult;
  729. function SafeArrayGetLBound(psa: PSAFEARRAY; nDim: Cardinal; var plLbound: Longint): HResult;
  730. function SafeArrayLock(psa: PSAFEARRAY): HResult;
  731. function SafeArrayUnlock(psa: PSAFEARRAY): HResult;
  732. function SafeArrayAccessData(psa: PSAFEARRAY; var ppvData: Pointer): HResult;
  733. function SafeArrayUnaccessData(psa: PSAFEARRAY): HResult;
  734. function SafeArrayGetElement(psa: PSAFEARRAY; var rgIndices; var pv): HResult;
  735. function SafeArrayPutElement(psa: PSAFEARRAY; var rgIndices; var pv): HResult;
  736. function SafeArrayCopy(psa: PSAFEARRAY; var ppsaOut: PSAFEARRAY): HResult;
  737. function SafeArrayPtrOfIndex(psa: PSAFEARRAY; var rgIndices; var ppvData: Pointer): HResult;
  738.  
  739. { VARIANT API }
  740.  
  741. procedure VariantInit(var pvarg: VARIANTARG);
  742. function VariantClear(var pvarg: VARIANTARG): HResult;
  743. function VariantCopy(var pvargDest, pvargSrc: VARIANTARG): HResult;
  744. function VariantCopyInd(var pvarDest: VARIANT; var pvargSrc: VARIANTARG): HResult;
  745. function VariantChangeType(var pvargDest: VARIANTARG; var pvarSrc: VARIANTARG;
  746.   wFlags: Word; vt: VARTYPE): HResult;
  747. function VariantChangeTypeEx(var pvargDest, pvarSrc: VARIANTARG; lcid: LCID;
  748.   wFlags: Word; vt: VARTYPE): HResult;
  749.  
  750. { VARTYPE Coercion API }
  751.  
  752. { Note: The routines that convert from a string are defined
  753.   to take a OLECHAR rather than a BSTR because no allocation is
  754.   required, and this makes the routines a bit more generic.
  755.   They may of course still be passed a BSTR as the strIn param. }
  756.  
  757. { Any of the coersion functions that converts either from or to a string
  758.   takes an additional lcid and dwFlags arguments. The lcid argument allows
  759.   locale specific parsing to occur.  The dwFlags allow additional function
  760.   specific condition to occur.  All function that accept the dwFlags argument
  761.   can include either 0 or LOCALE_NOUSEROVERRIDE flag. In addition, the
  762.   VarDateFromStr functions also accepts the VAR_TIMEVALUEONLY and
  763.   VAR_DATEVALUEONLY flags }
  764.  
  765. function VarUI1FromI2(sIn: Smallint; var pbOut: Byte): HResult;
  766. function VarUI1FromI4(lIn: Longint; var pbOut: Byte): HResult;
  767. function VarUI1FromR4(fltIn: Single; var pbOut: Byte): HResult;
  768. function VarUI1FromR8(dblIn: Double; var pbOut: Byte): HResult;
  769. function VarUI1FromCy(cyIn: CY; var pbOut: Byte): HResult;
  770. function VarUI1FromDate(dateIn: DATE; var pbOut: Byte): HResult;
  771. function VarUI1FromStr(strIn: BSTR; lcid: LCID; dwFlags: Longint; var pbOut: Byte): HResult;
  772. function VarUI1FromDisp(pdispIn: IDispatch; lcid: LCID; var pbOut: Byte): HResult;
  773. function VarUI1FromBool(boolIn: VARIANT_BOOL; var pbOut: Byte): HResult;
  774.  
  775. function VarI2FromUI1(bIn: Byte; var psOut: Smallint): HResult;
  776. function VarI2FromI4(lIn: Longint; var psOut: Smallint): HResult;
  777. function VarI2FromR4(fltIn: Single; var psOut: Smallint): HResult;
  778. function VarI2FromR8(dblIn: Double; var psOut: Smallint): HResult;
  779. function VarI2FromCy(cyIn: CY; var psOut: Smallint): HResult;
  780. function VarI2FromDate(dateIn: DATE; var psOut: Smallint): HResult;
  781. function VarI2FromStr(strIn: BSTR; lcid: LCID; dwFlags: Longint; var psOut: Smallint): HResult;
  782. function VarI2FromDisp(pdispIn: IDispatch; lcid: LCID; var psOut: Smallint): HResult;
  783. function VarI2FromBool(boolIn: VARIANT_BOOL; var psOut: Smallint): HResult;
  784.  
  785. function VarI4FromUI1(bIn: Byte; var plOut: Longint): HResult;
  786. function VarI4FromI2(sIn: Smallint; var plOut: Longint): HResult;
  787. function VarI4FromR4(fltIn: Single; var plOut: Longint): HResult;
  788. function VarI4FromR8(dblIn: Double; var plOut: Longint): HResult;
  789. function VarI4FromCy(cyIn: CY; var plOut: Longint): HResult;
  790. function VarI4FromDate(dateIn: DATE; var plOut: Longint): HResult;
  791. function VarI4FromStr(strIn: BSTR; lcid: LCID; dwFlags: Longint; var plOut: Longint): HResult;
  792. function VarI4FromDisp(pdispIn: IDispatch; lcid: LCID; var plOut: Longint): HResult;
  793. function VarI4FromBool(boolIn: VARIANT_BOOL; var plOut: Longint): HResult;
  794.  
  795. function VarR4FromUI1(bIn: Byte; var pfltOut: Single): HResult;
  796. function VarR4FromI2(sIn: Smallint; var pfltOut: Single): HResult;
  797. function VarR4FromI4(lIn: Longint; var pfltOut: Single): HResult;
  798. function VarR4FromR8(dblIn: Double; var pfltOut: Single): HResult;
  799. function VarR4FromCy(cyIn: CY; var pfltOut: Single): HResult;
  800. function VarR4FromDate(dateIn: DATE; var pfltOut: Single): HResult;
  801. function VarR4FromStr(strIn: BSTR; lcid: LCID; dwFlags: Longint; var pfltOut: Single): HResult;
  802. function VarR4FromDisp(pdispIn: IDispatch; lcid: LCID; var pfltOut: Single): HResult;
  803. function VarR4FromBool(boolIn: VARIANT_BOOL; var pfltOut: Single): HResult;
  804.  
  805. function VarR8FromUI1(bIn: Byte; var pdblOut: Double): HResult;
  806. function VarR8FromI2(sIn: Smallint; var pdblOut: Double): HResult;
  807. function VarR8FromI4(lIn: Longint; var pdblOut: Double): HResult;
  808. function VarR8FromR4(fltIn: Single; var pdblOut: Double): HResult;
  809. function VarR8FromCy(cyIn: CY; var pdblOut: Double): HResult;
  810. function VarR8FromDate(dateIn: DATE; var pdblOut: Double): HResult;
  811. function VarR8FromStr(strIn: BSTR; lcid: LCID; dwFlags: Longint; var pdblOut: Double): HResult;
  812. function VarR8FromDisp(pdispIn: IDispatch; lcid: LCID; var pdblOut: Double): HResult;
  813. function VarR8FromBool(boolIn: VARIANT_BOOL; var pdblOut: Double): HResult;
  814.  
  815. function VarDateFromUI1(bIn: Byte; var pdateOut: DATE): HResult;
  816. function VarDateFromI2(sIn: Smallint; var pdateOut: DATE): HResult;
  817. function VarDateFromI4(lIn: Longint; var pdateOut: DATE): HResult;
  818. function VarDateFromR4(fltIn: Single; var pdateOut: DATE): HResult;
  819. function VarDateFromR8(dblIn: Double; var pdateOut: DATE): HResult;
  820. function VarDateFromCy(cyIn: CY; var pdateOut: DATE): HResult;
  821. function VarDateFromStr(strIn: BSTR; lcid: LCID; dwFlags: Longint; var pdateOut: DATE): HResult;
  822. function VarDateFromDisp(pdispIn: IDispatch; lcid: LCID; var pdateOut: DATE): HResult;
  823. function VarDateFromBool(boolIn: VARIANT_BOOL; var pdateOut: DATE): HResult;
  824.  
  825. function VarCyFromUI1(bIn: Byte; var pcyOut: CY): HResult;
  826. function VarCyFromI2(sIn: Smallint; var pcyOut: CY): HResult;
  827. function VarCyFromI4(lIn: Longint; var pcyOut: CY): HResult;
  828. function VarCyFromR4(fltIn: Single; var pcyOut: CY): HResult;
  829. function VarCyFromR8(dblIn: Double; var pcyOut: CY): HResult;
  830. function VarCyFromDate(dateIn: DATE; var pcyOut: CY): HResult;
  831. function VarCyFromStr(strIn: BSTR; lcid: LCID; dwFlags: Longint; var pcyOut: CY): HResult;
  832. function VarCyFromDisp(pdispIn: IDispatch; lcid: LCID; var pcyOut: CY): HResult;
  833. function VarCyFromBool(boolIn: VARIANT_BOOL; var pcyOut: CY): HResult;
  834.  
  835. function VarBstrFromUI1(bVal: Byte; lcid: LCID; dwFlags: Longint; var pbstrOut: BSTR): HResult;
  836. function VarBstrFromI2(iVal: Smallint; lcid: LCID; dwFlags: Longint; var pbstrOut: BSTR): HResult;
  837. function VarBstrFromI4(lIn: Longint; lcid: LCID; dwFlags: Longint; var pbstrOut: BSTR): HResult;
  838. function VarBstrFromR4(fltIn: Single; lcid: LCID; dwFlags: Longint; var pbstrOut: BSTR): HResult;
  839. function VarBstrFromR8(dblIn: Double; lcid: LCID; dwFlags: Longint; var pbstrOut: BSTR): HResult;
  840. function VarBstrFromCy(cyIn: CY; lcid: LCID; dwFlags: Longint; var pbstrOut: BSTR): HResult;
  841. function VarBstrFromDate(dateIn: DATE; lcid: LCID; dwFlags: Longint; var pbstrOut: BSTR): HResult;
  842. function VarBstrFromDisp(pdispIn: IDispatch; lcid: LCID; dwFlags: Longint; var pbstrOut: BSTR): HResult;
  843. function VarBstrFromBool(boolIn: VARIANT_BOOL; lcid: LCID; dwFlags: Longint; var pbstrOut: BSTR): HResult;
  844.  
  845. function VarBoolFromUI1(bIn: Byte; var pboolOut: VARIANT_BOOL): HResult;
  846. function VarBoolFromI2(sIn: Smallint; var pboolOut: VARIANT_BOOL): HResult;
  847. function VarBoolFromI4(lIn: Longint; var pboolOut: VARIANT_BOOL): HResult;
  848. function VarBoolFromR4(fltIn: Single; var pboolOut: VARIANT_BOOL): HResult;
  849. function VarBoolFromR8(dblIn: Double; var pboolOut: VARIANT_BOOL): HResult;
  850. function VarBoolFromDate(dateIn: DATE; var pboolOut: VARIANT_BOOL): HResult;
  851. function VarBoolFromCy(cyIn: CY; var pboolOut: VARIANT_BOOL): HResult;
  852. function VarBoolFromStr(strIn: BSTR; lcid: LCID; dwFlags: Longint; var pboolOut: VARIANT_BOOL): HResult;
  853. function VarBoolFromDisp(pdispIn: IDispatch; lcid: LCID; var pboolOut: VARIANT_BOOL): HResult;
  854.  
  855. { TypeInfo APIs }
  856.  
  857. { compute a 32bit hash value for the given name  based on the lcid and system kind }
  858. { Macro to compute a 32bit hash value for the given name based on the LCID }
  859. function LHashValOfName(lcid: LCID; const szName: PChar): Longint;
  860.  
  861. { compute a 16bit hash value from 32 bit hash value }
  862. function WHashValOfLHashVal(lhashval: LongInt): Word;
  863.  
  864. { Check if the hash values are compatible. }
  865. function IsHashValCompatible(lhashval1: LongInt; lhashval2: LongInt): Boolean;
  866.  
  867.  
  868. function LHashValOfNameSys(syskind: Word; lcid: LCID; const szName: PChar): Longint;
  869. function LoadTypeLib(const szFile: PChar; var pptlib: ITypeLib): HResult;
  870. function LoadRegTypeLib(const rguid: IID; wVerMajor: Word; wVerMinor: Word;
  871.   lcid: LCID; var pptlib: ITypeLib): HResult;
  872. function QueryPathOfRegTypeLib(const guid: IID; wMaj: Word; wMin: Word; lcid: LCID;
  873.   var lpbstrPathName: BSTR): HResult;
  874. function RegisterTypeLib(ptlib: ITypeLib; szFullPath, szHelpDir: PChar): HResult;
  875. function CreateTypeLib(syskind: Word; const szFile: PChar; var ppctlib: ICreateTypeLib): HResult;
  876.  
  877. { ISupportErrorInfo methods }
  878. function SetErrorInfo(dwReserved: Longint; perrinfo: IErrorInfo): HResult;
  879. function GetErrorInfo(dwReserved: Longint; var pperrinfo: IErrorInfo): HResult;
  880. function CreateErrorInfo(var pperrinfo: ICreateErrorInfo): HResult;
  881.  
  882. { IDispatch implementation support }
  883. function DispGetParam(var pdispparams: DISPPARAMS; position: Integer; vtTarg:
  884.   VARTYPE; var pvarResult: VARIANT; var puArgErr: Integer): HResult;
  885. function DispGetIDsOfNames(ptinfo: ITypeInfo; var rgszNames: PChar;
  886.   cNames: Integer; var rgdispid: DISPID): HResult;
  887. function DispInvoke(_this: Pointer; ptinfo: ITypeInfo; dispidMember: DISPID;
  888.   wFlags: Word; var pparams: DISPPARAMS; var pvarResult: VARIANT;
  889.   var pexcepinfo: EXCEPINFO; var puArgErr: Integer): HResult;
  890. function CreateDispTypeInfo(var pidata: INTERFACEDATA; lcid: LCID;
  891.   var pptinfo: ITypeInfo): HResult;
  892. function CreateStdDispatch(var punkOuter: IUnknown; pvThis: Pointer;
  893.   ptinfo: ITypeInfo; var ppunkStdDisp: IUnknown): HResult;
  894.  
  895. { Active Object Registration API }
  896.  
  897. function RegisterActiveObject(punk: IUnknown; const rclsid: IID;
  898.   dwFlags: Longint; var pdwRegister: Longint): HResult;
  899. function RevokeActiveObject(dwRegister: Longint; pvReserved: HResult): HResult;
  900. function GetActiveObject(const rclsid: IID; pvReserved: HResult; var ppunk: IUnknown): HResult;
  901.  
  902. { MISC API }
  903.  
  904. function OaBuildVersion: Longint;
  905.  
  906. implementation
  907.