oleauto.odl

The code for this article was written for version 1.0 of the Active Template Library (ATL). The cu

[
uuid(5467404A-3A82-101B-8181-00AA003743D3),
helpstring("OLE Automation Functions"),
#ifdef WIN32
dllname("OLEAUT32.DLL")
#else
dllname("OLE2DISP.DLL")
#endif
]
module OleAuto {

    //----------
    // BSTR API
    //----------

    [
    usesgetlasterror,
    entry("SysAllocString"),
    helpstring("Allocates and returns a BSTR for a given LPSTR"),
    ]
    BSTR WINAPI SysAllocString([in] LPSTR sz);

    [
    usesgetlasterror,
    entry("SysReAllocString"),
    helpstring("Reallocates a BSTR, assigning it the value of a given BSTR and freeing the old data (returns true or false)"),
    ]
    BOOL WINAPI SysReAllocString([in] BSTR pbstr,
                                 [in] LPSTR sz);

    [
    usesgetlasterror,
    entry("SysAllocStringLen"),
    helpstring("Allocates and returns a BSTR using the given number of characters from a given LPSTR"),
    ]
    BSTR WINAPI SysAllocStringLen([in] LPSTR sz, [in] UINT len);

    [
    usesgetlasterror,
    entry("SysReAllocStringLen"),
    helpstring("Reallocates a BSTR, assigning it a given number of characters from a given BSTR and freeing the old data (returns true or false)"),
    ]
    int  WINAPI SysReAllocStringLen([in] BSTR pbstr,
                                    [in] LPSTR pch,
                                    [in] UINT cch);

    [
    usesgetlasterror,
    entry("SysFreeString"),
    helpstring("Frees a BSTR"),
    ]
    void WINAPI SysFreeString([in] BSTR bstr);

    [
    usesgetlasterror,
    entry("SysStringLen"),
    helpstring("Returns the length in characters of a BSTR"),
    ]
    UINT WINAPI SysStringLen([in] BSTR bstr);

    #ifdef WIN32
    [
    usesgetlasterror,
    entry("SysStringByteLen"),
    helpstring("Returns the length in bytes of a BSTR"),
    ]
    UINT WINAPI SysStringByteLen([in] BSTR bstr);

    [
    usesgetlasterror,
    entry("SysAllocStringByteLen"),
    helpstring("Allocates and returns a BSTR using the given number of bytes from a given LPSTR"),
    ]
    BSTR WINAPI SysAllocStringByteLen([in] LPSTR psz,
                                      [in] UINT len);
    #endif

    //----------
    // Time API
    //----------

    [
    usesgetlasterror,
    entry("DosDateTimeToVariantTime"),
    helpstring("Converts a DOS packed date and time to the floating point format stored in variants"),
    ]
    int WINAPI DosDateTimeToVariantTime(
        [in] unsigned short wDosDate,
        [in] unsigned short wDosTime,
        [out] double FAR* pvtime);

    [
    usesgetlasterror,
    entry("VariantTimeToDosDateTime"),
    helpstring("Converts the floating point format stored in variants to a DOS packed date and time"),
    ]
    int WINAPI VariantTimeToDosDateTime(
        [in] double vtime,
        [out] unsigned short FAR* pwDosDate,
        [out] unsigned short FAR* pwDosTime);


    //---------------
    // SafeArray API
    //---------------

    /* SafeArray omitted

    STDAPI
    SafeArrayAllocDescriptor(unsigned int cDims, SAFEARRAY FAR* FAR* ppsaOut);

    STDAPI SafeArrayAllocData(SAFEARRAY FAR* psa);

    STDAPI_(SAFEARRAY FAR*)
    SafeArrayCreate(
        VARTYPE vt,
        unsigned int cDims,
        SAFEARRAYBOUND FAR* rgsabound);

    STDAPI SafeArrayDestroyDescriptor(SAFEARRAY FAR* psa);

    STDAPI SafeArrayDestroyData(SAFEARRAY FAR* psa);

    STDAPI SafeArrayDestroy(SAFEARRAY FAR* psa);

    STDAPI SafeArrayRedim(SAFEARRAY FAR* psa, SAFEARRAYBOUND FAR* psaboundNew);

    STDAPI_(unsigned int) SafeArrayGetDim(SAFEARRAY FAR* psa);

    STDAPI_(unsigned int) SafeArrayGetElemsize(SAFEARRAY FAR* psa);

    STDAPI
    SafeArrayGetUBound(SAFEARRAY FAR* psa, unsigned int nDim, long FAR* plUbound);

    STDAPI
    SafeArrayGetLBound(SAFEARRAY FAR* psa, unsigned int nDim, long FAR* plLbound);

    STDAPI SafeArrayLock(SAFEARRAY FAR* psa);

    STDAPI SafeArrayUnlock(SAFEARRAY FAR* psa);

    STDAPI SafeArrayAccessData(SAFEARRAY FAR* psa, void HUGEP* FAR* ppvData);

    STDAPI SafeArrayUnaccessData(SAFEARRAY FAR* psa);

    STDAPI
    SafeArrayGetElement(
        SAFEARRAY FAR* psa,
        long FAR* rgIndices,
        void FAR* pv);

    STDAPI
    SafeArrayPutElement(
        SAFEARRAY FAR* psa,
        long FAR* rgIndices,
        void FAR* pv);

    STDAPI
    SafeArrayCopy(
        SAFEARRAY FAR* psa,
        SAFEARRAY FAR* FAR* ppsaOut);
    */

    //-------------
    // VARIANT API
    //-------------

    /* Variant omitted
    STDAPI_(void)
    VariantInit(VARIANTARG FAR* pvarg);

    STDAPI
    VariantClear(VARIANTARG FAR* pvarg);

    STDAPI
    VariantCopy(
        VARIANTARG FAR* pvargDest,
        VARIANTARG FAR* pvargSrc);

    STDAPI
    VariantCopyInd(
        VARIANT FAR* pvarDest,
        VARIANTARG FAR* pvargSrc);

    STDAPI
    VariantChangeType(
        VARIANTARG FAR* pvargDest,
        VARIANTARG FAR* pvarSrc,
        unsigned short wFlags,
        VARTYPE vt);

    STDAPI
    VariantChangeTypeEx(
        VARIANTARG FAR* pvargDest,
        VARIANTARG FAR* pvarSrc,
        LCID lcid,
        unsigned short wFlags,
        VARTYPE vt);

    //define VARIANT_NOVALUEPROP 1
    */

    //----------------------
    // VARTYPE Coercion API
    //----------------------

    // Note: The routines that convert *from* a string are defined
    // to take a char* rather than a BSTR because no allocation is
    // required, and this makes the routines a bit more generic.
    // They may of course still be passed a BSTR as the strIn param.

    // Any of the coersion functions that converts either from or to a string
    // takes an additional lcid and dwFlags arguments. The lcid argument allows
    // locale specific parsing to occur.  The dwFlags allow additional function
    // specific condition to occur.  All function that accept the dwFlags argument
    // can include either 0 or LOCALE_NOUSEROVERRIDE flag. In addition, the
    // VarDateFromStr functions also accepts the VAR_TIMEVALUEONLY and
    // VAR_DATEVALUEONLY flags

    /*
    //define VAR_TIMEVALUEONLY           0x0001    // return time value
    //define VAR_DATEVALUEONLY           0x0002    // return date value

    STDAPI VarI2FromI4(long lIn, short FAR* psOut);
    STDAPI VarI2FromR4(float fltIn, short FAR* psOut);
    STDAPI VarI2FromR8(double dblIn, short FAR* psOut);
    STDAPI VarI2FromCy(CY cyIn, short FAR* psOut);
    STDAPI VarI2FromDate(DATE dateIn, short FAR* psOut);
    STDAPI VarI2FromStr(TCHAR FAR* strIn, LCID lcid, unsigned long dwFlags, short FAR* psOut);
    STDAPI VarI2FromDisp(IDispatch FAR* pdispIn, LCID lcid, short FAR* psOut);
    STDAPI VarI2FromBool(VARIANT_BOOL boolIn, short FAR* psOut);

    STDAPI VarI4FromI2(short sIn, long FAR* plOut);
    STDAPI VarI4FromR4(float fltIn, long FAR* plOut);
    STDAPI VarI4FromR8(double dblIn, long FAR* plOut);
    STDAPI VarI4FromCy(CY cyIn, long FAR* plOut);
    STDAPI VarI4FromDate(DATE dateIn, long FAR* plOut);
    STDAPI VarI4FromStr(TCHAR FAR* strIn, LCID lcid, unsigned long dwFlags, long FAR* plOut);
    STDAPI VarI4FromDisp(IDispatch FAR* pdispIn, LCID lcid, long FAR* plOut);
    STDAPI VarI4FromBool(VARIANT_BOOL boolIn, long FAR* plOut);

    STDAPI VarR4FromI2(short sIn, float FAR* pfltOut);
    STDAPI VarR4FromI4(long lIn, float FAR* pfltOut);
    STDAPI VarR4FromR8(double dblIn, float FAR* pfltOut);
    STDAPI VarR4FromCy(CY cyIn, float FAR* pfltOut);
    STDAPI VarR4FromDate(DATE dateIn, float FAR* pfltOut);
    STDAPI VarR4FromStr(TCHAR FAR* strIn, LCID lcid, unsigned long dwFlags, float FAR* pfltOut);
    STDAPI VarR4FromDisp(IDispatch FAR* pdispIn, LCID lcid, float FAR* pfltOut);
    STDAPI VarR4FromBool(VARIANT_BOOL boolIn, float FAR* pfltOut);

    STDAPI VarR8FromI2(short sIn, double FAR* pdblOut);
    STDAPI VarR8FromI4(long lIn, double FAR* pdblOut);
    STDAPI VarR8FromR4(float fltIn, double FAR* pdblOut);
    STDAPI VarR8FromCy(CY cyIn, double FAR* pdblOut);
    STDAPI VarR8FromDate(DATE dateIn, double FAR* pdblOut);
    STDAPI VarR8FromStr(TCHAR FAR* strIn, LCID lcid, unsigned long dwFlags, double FAR* pdblOut);
    STDAPI VarR8FromDisp(IDispatch FAR* pdispIn, LCID lcid, double FAR* pdblOut);
    STDAPI VarR8FromBool(VARIANT_BOOL boolIn, double FAR* pdblOut);

    STDAPI VarDateFromI2(short sIn, DATE FAR* pdateOut);
    STDAPI VarDateFromI4(long lIn, DATE FAR* pdateOut);
    STDAPI VarDateFromR4(float fltIn, DATE FAR* pdateOut);
    STDAPI VarDateFromR8(double dblIn, DATE FAR* pdateOut);
    STDAPI VarDateFromCy(CY cyIn, DATE FAR* pdateOut);
    STDAPI VarDateFromStr(TCHAR FAR* strIn, LCID lcid, unsigned long dwFlags, DATE FAR* pdateOut);
    STDAPI VarDateFromDisp(IDispatch FAR* pdispIn, LCID lcid, DATE FAR* pdateOut);
    STDAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE FAR* pdateOut);

    STDAPI VarCyFromI2(short sIn, CY FAR* pcyOut);
    STDAPI VarCyFromI4(long lIn, CY FAR* pcyOut);
    STDAPI VarCyFromR4(float fltIn, CY FAR* pcyOut);
    STDAPI VarCyFromR8(double dblIn, CY FAR* pcyOut);
    STDAPI VarCyFromDate(DATE dateIn, CY FAR* pcyOut);
    STDAPI VarCyFromStr(TCHAR FAR* strIn, LCID lcid, unsigned long dwFlags, CY FAR* pcyOut);
    STDAPI VarCyFromDisp(IDispatch FAR* pdispIn, LCID lcid, CY FAR* pcyOut);
    STDAPI VarCyFromBool(VARIANT_BOOL boolIn, CY FAR* pcyOut);

    STDAPI VarBstrFromI2(short iVal, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
    STDAPI VarBstrFromI4(long lIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
    STDAPI VarBstrFromR4(float fltIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
    STDAPI VarBstrFromR8(double dblIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
    STDAPI VarBstrFromCy(CY cyIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
    STDAPI VarBstrFromDate(DATE dateIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
    STDAPI VarBstrFromDisp(IDispatch FAR* pdispIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
    STDAPI VarBstrFromBool(VARIANT_BOOL boolIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);

    STDAPI VarBoolFromI2(short sIn, VARIANT_BOOL FAR* pboolOut);
    STDAPI VarBoolFromI4(long lIn, VARIANT_BOOL FAR* pboolOut);
    STDAPI VarBoolFromR4(float fltIn, VARIANT_BOOL FAR* pboolOut);
    STDAPI VarBoolFromR8(double dblIn, VARIANT_BOOL FAR* pboolOut);
    STDAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL FAR* pboolOut);
    STDAPI VarBoolFromCy(CY cyIn, VARIANT_BOOL FAR* pboolOut);
    STDAPI VarBoolFromStr(TCHAR FAR* strIn, LCID lcid, unsigned long dwFlags, VARIANT_BOOL FAR* pboolOut);
    STDAPI VarBoolFromDisp(IDispatch FAR* pdispIn, LCID lcid, VARIANT_BOOL FAR* pboolOut);
    */
}