File Index Symbol Index

#include <winapifamily.h>
#if _MSC_VER >= 1200
#pragma warning(push)
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// File: oleauto.h
//
// Contents: Defines Ole Automation support function prototypes, constants
//
//----------------------------------------------------------------------------
#if !defined( _OLEAUTO_H_ )
#define _OLEAUTO_H_
#if _MSC_VER > 1000
#pragma once
#endif
// Set packing to 8 for ISV, and Win95 support
#ifndef RC_INVOKED #include <pshpack8.h> #endif // RC_INVOKED
// Definition of the OLE Automation APIs, and macros.
#ifdef _OLEAUT32_
#define WINOLEAUTAPI STDAPI
#define WINOLEAUTAPI_(type) STDAPI_(type)
#else
#define WINOLEAUTAPI EXTERN_C DECLSPEC_IMPORT HRESULT STDAPICALLTYPE
#define WINOLEAUTAPI_(type) EXTERN_C DECLSPEC_IMPORT type STDAPICALLTYPE #endif
#define STDOLE_MAJORVERNUM 0x1
#define STDOLE_MINORVERNUM 0x0
#define STDOLE_LCID 0x0000
// Version # of stdole2.tlb
#define STDOLE2_MAJORVERNUM 0x2
#define STDOLE2_MINORVERNUM 0x0
#define STDOLE2_LCID 0x0000
/* if not already picked up from olenls.h */
#ifndef _LCID_DEFINED
typedef DWORD LCID;
# define _LCID_DEFINED
#endif /* _LCID_DEFINED */
#ifndef BEGIN_INTERFACE
#define BEGIN_INTERFACE
#define END_INTERFACE
#endif
/* pull in the MIDL generated header */
#include <oaidl.h>
/*---------------------------------------------------------------------*/
/* BSTR API */
/*---------------------------------------------------------------------*/
#pragma region Application Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
#if (defined (_WIN32) || defined (_WIN64))
#endif /* (defined (_WIN32) || defined (_WIN64)) */
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion
/*---------------------------------------------------------------------*/
/* Time API */
/*---------------------------------------------------------------------*/
#pragma region Desktop Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM)
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion
#if (defined (_WIN32) || defined (_WIN64))
#pragma region Application Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion
#endif /* (defined (_WIN32) || defined (_WIN64)) */
/*---------------------------------------------------------------------*/
/* SafeArray API */
/*---------------------------------------------------------------------*/
#pragma region Application Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
_Check_return_
_Check_return_
_Check_return_
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion
/*---------------------------------------------------------------------*/
/* VARIANT API */
/*---------------------------------------------------------------------*/
#pragma region Application Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
_Check_return_
_Check_return_
_Check_return_
_Check_return_
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion
// Flags for VariantChangeType/VariantChangeTypeEx
#define VARIANT_NOVALUEPROP 0x01
#define VARIANT_ALPHABOOL 0x02 // For VT_BOOL to VT_BSTR conversions,
// convert to "True"/"False" instead of
// "-1"/"0"
#define VARIANT_NOUSEROVERRIDE 0x04 // For conversions to/from VT_BSTR,
// passes LOCALE_NOUSEROVERRIDE
// to core coercion routines
#define VARIANT_CALENDAR_HIJRI 0x08
#define VARIANT_LOCALBOOL 0x10 // For VT_BOOL to VT_BSTR and back,
// convert to local language rather than
// English
#define VARIANT_CALENDAR_THAI 0x20 // SOUTHASIA calendar support
#define VARIANT_CALENDAR_GREGORIAN 0x40 // SOUTHASIA calendar support
#define VARIANT_USE_NLS 0x80 // NLS function call support
/*---------------------------------------------------------------------*/
/* Vector <-> Bstr conversion APIs */
/*---------------------------------------------------------------------*/
#pragma region Desktop Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM)
_Check_return_
_Check_return_
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion
/*---------------------------------------------------------------------*/
/* Variant API Flags */
/*---------------------------------------------------------------------*/
/* 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. */
/* The VarDateFromStr and VarBstrFromDate functions also accept the * VAR_TIMEVALUEONLY and VAR_DATEVALUEONLY flags */
#define VAR_TIMEVALUEONLY ((DWORD)0x00000001) /* return time value */
#define VAR_DATEVALUEONLY ((DWORD)0x00000002) /* return date value */
/* VarDateFromUdate() only */
#define VAR_VALIDDATE ((DWORD)0x00000004)
/* Accepted by all date & format APIs */
#define VAR_CALENDAR_HIJRI ((DWORD)0x00000008) /* use Hijri calender */
/* Booleans can optionally be accepted in localized form. Pass VAR_LOCALBOOL * into VarBoolFromStr and VarBstrFromBool to use localized boolean names */
#define VAR_LOCALBOOL ((DWORD)0x00000010)
/* When passed into VarFormat and VarFormatFromTokens, prevents substitution * of formats in the case where a string is passed in that can not be * coverted into the desired type. (for ex, 'Format("Hello", "General Number")') */
#define VAR_FORMAT_NOSUBSTITUTE ((DWORD)0x00000020)
/* * For VarBstrFromDate only - forces years to be 4 digits rather than shortening * to 2-digits when the years is in the date window. */
#define VAR_FOURDIGITYEARS ((DWORD)0x00000040)
/* * Use NLS functions to format date, currency, time, and number. */
#ifndef LOCALE_USE_NLS
#define LOCALE_USE_NLS 0x10000000 #endif
// SOUTHASIA START
/* SOUTHASIA * For VarBstrFromDate only - forces years to be 4 digits rather than shortening * to 2-digits when the years is in the date window. */
#define VAR_CALENDAR_THAI ((DWORD)0x00000080)
#define VAR_CALENDAR_GREGORIAN ((DWORD)0x00000100)
//SOUTHASIA END
#define VTDATEGRE_MAX 2958465 /* Dec 31, 9999, 0:0:0 in Gregorain Calendar */
#define VTDATEGRE_MIN -657434 /* Jan 1, 100, 0:0:0 in Gregorain Calendar */
/*---------------------------------------------------------------------*/
/* VARTYPE Coercion API */
/*---------------------------------------------------------------------*/
/* Note: The routines that convert *from* a string are defined * to take a OLECHAR* 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. */
#pragma region Application Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
/******************************************/
/*********************/
VarI1FromUI1
( );
VarI1FromI2
( );
VarI1FromI4
( );
VarI1FromI8
( );
VarI1FromR4
( );
VarI1FromR8
( );
VarI1FromDate
( );
VarI1FromCy
( );
VarI1FromStr
( );
VarI1FromDisp
( );
VarI1FromBool
( );
VarI1FromUI2
( );
VarI1FromUI4
( );
VarI1FromUI8
( );
VarI1FromDec
( );
/******************************************/
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion #pragma region Desktop Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */
#pragma endregion #pragma region Application Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
/*********************/
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion
#define VarUI4FromUI4(in, pOut) (*(pOut) = (in))
#define VarI4FromI4(in, pOut) (*(pOut) = (in))
#pragma region Application Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion
#define VarUI8FromUI8(in, pOut) (*(pOut) = (in))
#define VarI8FromI8(in, pOut) (*(pOut) = (in))
#define VarUI1FromInt VarUI1FromI4
#define VarUI1FromUint VarUI1FromUI4
#define VarI2FromInt VarI2FromI4
#define VarI2FromUint VarI2FromUI4
#pragma region Desktop Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
#define VarI4FromInt VarI4FromI4
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */
#pragma endregion
#define VarI4FromUint VarI4FromUI4
#define VarI8FromUint VarI8FromUI4
#define VarR4FromInt VarR4FromI4
#define VarR4FromUint VarR4FromUI4
#define VarR8FromInt VarR8FromI4
#define VarR8FromUint VarR8FromUI4
#define VarDateFromInt VarDateFromI4
#define VarDateFromUint VarDateFromUI4
#define VarCyFromInt VarCyFromI4
#define VarCyFromUint VarCyFromUI4
#define VarBstrFromInt VarBstrFromI4
#define VarBstrFromUint VarBstrFromUI4
#define VarBoolFromInt VarBoolFromI4
#define VarBoolFromUint VarBoolFromUI4
#define VarI1FromInt VarI1FromI4
#define VarI1FromUint VarI1FromUI4
#define VarUI2FromInt VarUI2FromI4
#define VarUI2FromUint VarUI2FromUI4
#define VarUI4FromInt VarUI4FromI4
#define VarUI4FromUint VarUI4FromUI4
#define VarDecFromInt VarDecFromI4
#define VarDecFromUint VarDecFromUI4
#define VarIntFromUI1 VarI4FromUI1
#define VarIntFromI2 VarI4FromI2
#define VarIntFromI4 VarI4FromI4
#define VarIntFromI8 VarI4FromI8
#define VarIntFromR4 VarI4FromR4
#define VarIntFromR8 VarI4FromR8
#define VarIntFromDate VarI4FromDate
#define VarIntFromCy VarI4FromCy
#define VarIntFromStr VarI4FromStr
#define VarIntFromDisp VarI4FromDisp
#define VarIntFromBool VarI4FromBool
#define VarIntFromI1 VarI4FromI1
#define VarIntFromUI2 VarI4FromUI2
#define VarIntFromUI4 VarI4FromUI4
#define VarIntFromUI8 VarI4FromUI8
#define VarIntFromDec VarI4FromDec
#define VarIntFromUint VarI4FromUI4
#define VarUintFromUI1 VarUI4FromUI1
#define VarUintFromI2 VarUI4FromI2
#define VarUintFromI4 VarUI4FromI4
#define VarUintFromI8 VarUI4FromI8
#define VarUintFromR4 VarUI4FromR4
#define VarUintFromR8 VarUI4FromR8
#define VarUintFromDate VarUI4FromDate
#define VarUintFromCy VarUI4FromCy
#define VarUintFromStr VarUI4FromStr
#define VarUintFromDisp VarUI4FromDisp
#define VarUintFromBool VarUI4FromBool
#define VarUintFromI1 VarUI4FromI1
#define VarUintFromUI2 VarUI4FromUI2
#define VarUintFromUI4 VarUI4FromUI4
#define VarUintFromUI8 VarUI4FromUI8
#define VarUintFromDec VarUI4FromDec
#define VarUintFromInt VarUI4FromI4
/* Mac Note: On the Mac, the coersion functions support the * Symantec C++ calling convention for float/double. To support * float/double arguments compiled with the MPW C compiler, * use the following APIs to move MPW float/double values into * a VARIANT. */
/*---------------------------------------------------------------------*/
/* New VARIANT <-> string parsing functions */
/*---------------------------------------------------------------------*/
typedef
struct
{
INT
cDig
;
ULONG
dwInFlags
;
ULONG
dwOutFlags
;
INT
cchUsed
;
INT
nBaseShift
;
INT
nPwr10
; }
NUMPARSE
;
/* flags used by both dwInFlags and dwOutFlags: */
#define NUMPRS_LEADING_WHITE 0x0001
#define NUMPRS_TRAILING_WHITE 0x0002
#define NUMPRS_LEADING_PLUS 0x0004
#define NUMPRS_TRAILING_PLUS 0x0008
#define NUMPRS_LEADING_MINUS 0x0010
#define NUMPRS_TRAILING_MINUS 0x0020
#define NUMPRS_HEX_OCT 0x0040
#define NUMPRS_PARENS 0x0080
#define NUMPRS_DECIMAL 0x0100
#define NUMPRS_THOUSANDS 0x0200
#define NUMPRS_CURRENCY 0x0400
#define NUMPRS_EXPONENT 0x0800
#define NUMPRS_USE_ALL 0x1000
#define NUMPRS_STD 0x1FFF
/* flags used by dwOutFlags only: */
#define NUMPRS_NEG 0x10000
#define NUMPRS_INEXACT 0x20000
/* flags used by VarNumFromParseNum to indicate acceptable result types: */
#define VTBIT_I1 (1 << VT_I1)
#define VTBIT_UI1 (1 << VT_UI1)
#define VTBIT_I2 (1 << VT_I2)
#define VTBIT_UI2 (1 << VT_UI2)
#define VTBIT_I4 (1 << VT_I4)
#define VTBIT_UI4 (1 << VT_UI4)
#define VTBIT_I8 (1 << VT_I8)
#define VTBIT_UI8 (1 << VT_UI8)
#define VTBIT_R4 (1 << VT_R4)
#define VTBIT_R8 (1 << VT_R8)
#define VTBIT_CY (1 << VT_CY)
#define VTBIT_DECIMAL (1 << VT_DECIMAL)
#pragma region Application Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
_Check_return_
_Check_return_
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion
/*---------------------------------------------------------------------*/
/* VARTYPE Math API */
/*---------------------------------------------------------------------*/
#pragma region Application Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
// dwFlags passed to CompareString if a string compare
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion
#ifdef __cplusplus
extern
"C++"
{ #pragma region Application Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
// Add wrapper for old ATL headers to call
__inline
HRESULT
#if !defined(_M_CEE_PURE)
VarCmp
(
LPVARIANT
pvarLeft
,
LPVARIANT
pvarRight
,
LCID
lcid
) {
return
VarCmp
(
pvarLeft
,
pvarRight
,
lcid
,
0
); }
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion }
// extern "C++"
#endif /* __cplusplus */
// Decimal math
//
#pragma region Application Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
// Currency math
//
// Misc support functions
//
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion
// Compare results. These are returned as a SUCCESS HResult. Subtracting
// one gives the usual values of -1 for Less Than, 0 for Equal To, +1 for
// Greater Than.
//
#define VARCMP_LT 0
#define VARCMP_EQ 1
#define VARCMP_GT 2
#define VARCMP_NULL 3
// VT_HARDTYPE tells the compare routine that the argument is a literal or
// otherwise declared of that specific type. It causes comparison rules to
// change. For example, if a hard-type string is compared to a variant (not hard
// -type) number, the number is converted to string. If a hard-type number is
// compared to a variant string, the string is converted to number. If they're
// both variant, then number < string.
#define VT_HARDTYPE VT_RESERVED
/*---------------------------------------------------------------------*/
/* New date functions */
/*---------------------------------------------------------------------*/
/* The UDATE structure is used with VarDateFromUdate() and VarUdateFromDate(). * It represents an "unpacked date". */
typedef
struct
{
SYSTEMTIME
st
;
USHORT
wDayOfYear
; }
UDATE
;
/* APIs to "pack" and "unpack" dates. * NOTE: Ex version of VarDateFromUdate obeys 2 digit year setting in * control panel. */
#pragma region Application Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
_Check_return_
_Check_return_
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion #pragma region Desktop Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM)
/* API to retrieve the secondary(altername) month names Useful for Hijri, Polish and Russian alternate month names */
_Check_return_
/*---------------------------------------------------------------------*/
/* Format */
/*---------------------------------------------------------------------*/
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion #pragma region Application Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
int
iFirstDay
,
int
iFirstWeek
,
ULONG
dwFlags
, );
int
iNamedFormat
,
ULONG
dwFlags
, );
int
iNumDig
,
int
iIncLead
,
int
iUseParens
,
int
iGroup
,
ULONG
dwFlags
, );
int
iNumDig
,
int
iIncLead
,
int
iUseParens
,
int
iGroup
,
ULONG
dwFlags
, );
int
iNumDig
,
int
iIncLead
,
int
iUseParens
,
int
iGroup
,
ULONG
dwFlags
, );
int
iWeekday
,
int
fAbbrev
,
int
iFirstDay
,
ULONG
dwFlags
, );
int
iMonth
,
int
fAbbrev
,
ULONG
dwFlags
, );
ULONG
dwFlags
,
LCID
lcid
);
int
cbTok
,
int
iFirstDay
,
int
iFirstWeek
,
LCID
lcid
, );
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion #pragma region Desktop Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM)
/*---------------------------------------------------------------------*/
/* ITypeLib */
/*---------------------------------------------------------------------*/
/*---------------------------------------------------------------------*/
/* ITypeInfo */
/*---------------------------------------------------------------------*/
typedef
LONG
DISPID
;
typedef
DISPID
MEMBERID
;
#define MEMBERID_NIL DISPID_UNKNOWN
#define ID_DEFAULTINST -2
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion #pragma region Application Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
/* Flags for IDispatch::Invoke */
#define DISPATCH_METHOD 0x1
#define DISPATCH_PROPERTYGET 0x2
#define DISPATCH_PROPERTYPUT 0x4
#define DISPATCH_PROPERTYPUTREF 0x8
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion #pragma region Desktop Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM)
/*---------------------------------------------------------------------*/
/* ITypeComp */
/*---------------------------------------------------------------------*/
/*---------------------------------------------------------------------*/
/* ICreateTypeLib */
/*---------------------------------------------------------------------*/
typedef
ICreateTypeLib
*
LPCREATETYPELIB
;
typedef
ICreateTypeInfo
*
LPCREATETYPEINFO
;
/*---------------------------------------------------------------------*/
/* TypeInfo API */
/*---------------------------------------------------------------------*/
/* compute a 16bit hash value for the given name */
#if (defined (_WIN32) || defined (_WIN64))
_Check_return_
LPCSTR
szName
);
#endif
_Check_return_
LHashValOfNameSys
(
SYSKIND
syskind
,
LCID
lcid
,
const
OLECHAR
*
szName
);
#define LHashValOfName(lcid, szName) \
LHashValOfNameSys(SYS_WIN32, lcid, szName)
#define WHashValOfLHashVal(lhashval) \
((USHORT) (0x0000ffff & (lhashval)))
#define IsHashValCompatible(lhashval1, lhashval2) \
((BOOL) ((0x00ff0000 & (lhashval1)) == (0x00ff0000 & (lhashval2))))
/* load the typelib from the file with the given filename */
/* Control how a type library is registered */
typedef
enum
tagREGKIND
{
REGKIND_DEFAULT
,
REGKIND_REGISTER
,
REGKIND_NONE
}
REGKIND
;
// Constants for specifying format in which TLB should be loaded
// (the default format is 32-bit on WIN32 and 64-bit on WIN64)
#define LOAD_TLB_AS_32BIT 0x20
#define LOAD_TLB_AS_64BIT 0x40
#define MASK_TO_RESET_TLB_BITS ~(LOAD_TLB_AS_32BIT | LOAD_TLB_AS_64BIT)
_Check_return_
ITypeLib
**
pptlib
);
/* load registered typelib */
_Check_return_
LCID
lcid
,
ITypeLib
**
pptlib
);
/* get path to registered typelib */
/* add typelib to registry */
_Check_return_
/* remove typelib from registry */
_Check_return_
WORD
wVerMinor
,
LCID
lcid
,
SYSKIND
syskind
);
/* Registers a type library for use by the calling user. */
/* Removes type library information that was registered by using RegisterTypeLibForUser. */
WORD
wMajorVerNum
,
WORD
wMinorVerNum
,
LCID
lcid
,
SYSKIND
syskind
);
_Check_return_
ICreateTypeLib
**
ppctlib
);
_Check_return_
ICreateTypeLib2
**
ppctlib
);
/*---------------------------------------------------------------------*/
/* IDispatch implementation support */
/*---------------------------------------------------------------------*/
typedef
struct
tagPARAMDATA
{
OLECHAR
*
szName
;
/* parameter name */
VARTYPE
vt
;
/* parameter type */
}
PARAMDATA
, *
LPPARAMDATA
;
typedef
struct
tagMETHODDATA
{
OLECHAR
*
szName
;
/* method name */
PARAMDATA
*
ppdata
;
/* pointer to an array of PARAMDATAs */
DISPID
dispid
;
/* method ID */
UINT
iMeth
;
/* method index */
CALLCONV
cc
;
/* calling convention */
UINT
cArgs
;
/* count of arguments */
WORD
wFlags
;
/* same wFlags as on IDispatch::Invoke() */
VARTYPE
vtReturn
; }
METHODDATA
, *
LPMETHODDATA
;
typedef
struct
tagINTERFACEDATA
{
METHODDATA
*
pmethdata
;
/* pointer to an array of METHODDATAs */
UINT
cMembers
;
/* count of members */
}
INTERFACEDATA
, *
LPINTERFACEDATA
;
/* Locate the parameter indicated by the given position, and * return it coerced to the given target VARTYPE (vtTarg). */
_Check_return_
UINT
position
,
VARTYPE
vtTarg
, );
/* Automatic TypeInfo driven implementation of IDispatch::GetIDsOfNames() */
/* Automatic TypeInfo driven implementation of IDispatch::Invoke() */
_Check_return_
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion #pragma region Application Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
WORD
wFlags
,
DISPPARAMS
*
pparams
,
VARIANT
*
pvarResult
,
EXCEPINFO
*
pexcepinfo
,
UINT
*
puArgErr
);
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion #pragma region Desktop Family or OneCore Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM)
/* Construct a TypeInfo from an interface data description */
_Check_return_
ITypeInfo
**
pptinfo
);
/* Create an instance of the standard TypeInfo driven IDispatch * implementation. */
_Check_return_
ITypeInfo
*
ptinfo
,
IUnknown
**
ppunkStdDisp
);
/* Low-level helper for IDispatch::Invoke() provides machine independence * for customized Invoke(). */
/*---------------------------------------------------------------------*/
/* Active Object Registration API */
/*---------------------------------------------------------------------*/
/* flags for RegisterActiveObject */
#define ACTIVEOBJECT_STRONG 0x0
#define ACTIVEOBJECT_WEAK 0x1
_Check_return_
DWORD
dwFlags
,
DWORD
*
pdwRegister
);
IUnknown
**
ppunk
);
/*---------------------------------------------------------------------*/
/* ErrorInfo API */
/*---------------------------------------------------------------------*/
_Check_return_
_Check_return_
/*---------------------------------------------------------------------*/
/* User Defined Data types support */
/*---------------------------------------------------------------------*/
IRecordInfo
**
ppRecInfo
);
ULONG
uVerMajor
,
ULONG
uVerMinor
,
LCID
lcid
,
/*---------------------------------------------------------------------*/
/* MISC API */
/*---------------------------------------------------------------------*/
#if (NTDDI_VERSION >= NTDDI_VISTASP1)
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM) */
#pragma endregion
// Declare variant access functions.
#if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION) || (!defined(_MSC_EXTENSIONS) && !defined(_FORCENAMELESSUNION))
#define V_UNION(X, Y) ((X)->n1.n2.n3.Y)
#define V_VT(X) ((X)->n1.n2.vt)
#define V_RECORDINFO(X) ((X)->n1.n2.n3.brecVal.pRecInfo)
#define V_RECORD(X) ((X)->n1.n2.n3.brecVal.pvRecord) #else
#define V_UNION(X, Y) ((X)->Y)
#define V_VT(X) ((X)->vt)
#define V_RECORDINFO(X) ((X)->pRecInfo)
#define V_RECORD(X) ((X)->pvRecord) #endif
/* Variant access macros */
#define V_ISBYREF(X) (V_VT(X)&VT_BYREF)
#define V_ISARRAY(X) (V_VT(X)&VT_ARRAY)
#define V_ISVECTOR(X) (V_VT(X)&VT_VECTOR)
#define V_NONE(X) V_I2(X)
#define V_UI1(X) V_UNION(X, bVal)
#define V_UI1REF(X) V_UNION(X, pbVal)
#define V_I2(X) V_UNION(X, iVal)
#define V_I2REF(X) V_UNION(X, piVal)
#define V_I4(X) V_UNION(X, lVal)
#define V_I4REF(X) V_UNION(X, plVal)
#define V_I8(X) V_UNION(X, llVal)
#define V_I8REF(X) V_UNION(X, pllVal)
#define V_R4(X) V_UNION(X, fltVal)
#define V_R4REF(X) V_UNION(X, pfltVal)
#define V_R8(X) V_UNION(X, dblVal)
#define V_R8REF(X) V_UNION(X, pdblVal)
#define V_I1(X) V_UNION(X, cVal)
#define V_I1REF(X) V_UNION(X, pcVal)
#define V_UI2(X) V_UNION(X, uiVal)
#define V_UI2REF(X) V_UNION(X, puiVal)
#define V_UI4(X) V_UNION(X, ulVal)
#define V_UI4REF(X) V_UNION(X, pulVal)
#define V_UI8(X) V_UNION(X, ullVal)
#define V_UI8REF(X) V_UNION(X, pullVal)
#define V_INT(X) V_UNION(X, intVal)
#define V_INTREF(X) V_UNION(X, pintVal)
#define V_UINT(X) V_UNION(X, uintVal)
#define V_UINTREF(X) V_UNION(X, puintVal)
#ifdef _WIN64
#define V_INT_PTR(X) V_UNION(X, llVal)
#define V_UINT_PTR(X) V_UNION(X, ullVal)
#define V_INT_PTRREF(X) V_UNION(X, pllVal)
#define V_UINT_PTRREF(X) V_UNION(X, pullVal)
#else
#define V_INT_PTR(X) V_UNION(X, lVal)
#define V_UINT_PTR(X) V_UNION(X, ulVal)
#define V_INT_PTRREF(X) V_UNION(X, plVal)
#define V_UINT_PTRREF(X) V_UNION(X, pulVal) #endif
#define V_CY(X) V_UNION(X, cyVal)
#define V_CYREF(X) V_UNION(X, pcyVal)
#define V_DATE(X) V_UNION(X, date)
#define V_DATEREF(X) V_UNION(X, pdate)
#define V_BSTR(X) V_UNION(X, bstrVal)
#define V_BSTRREF(X) V_UNION(X, pbstrVal)
#define V_DISPATCH(X) V_UNION(X, pdispVal)
#define V_DISPATCHREF(X) V_UNION(X, ppdispVal)
#define V_ERROR(X) V_UNION(X, scode)
#define V_ERRORREF(X) V_UNION(X, pscode)
#define V_BOOL(X) V_UNION(X, boolVal)
#define V_BOOLREF(X) V_UNION(X, pboolVal)
#define V_UNKNOWN(X) V_UNION(X, punkVal)
#define V_UNKNOWNREF(X) V_UNION(X, ppunkVal)
#define V_VARIANTREF(X) V_UNION(X, pvarVal)
#define V_ARRAY(X) V_UNION(X, parray)
#define V_ARRAYREF(X) V_UNION(X, pparray)
#define V_BYREF(X) V_UNION(X, byref)
#define V_DECIMAL(X) V_UNION(X, decVal)
#define V_DECIMALREF(X) V_UNION(X, pdecVal)
#ifndef RC_INVOKED #include <poppack.h> #endif // RC_INVOKED
#endif // __OLEAUTO_H__
#if _MSC_VER >= 1200
#pragma warning(pop)
#endif