ReactOS Fundraising Campaign 2012
 
€ 4,410 / € 30,000

Information | Donate

Home | Info | Community | Development | myReactOS | Contact Us

  1. Home
  2. Community
  3. Development
  4. myReactOS
  5. Fundraiser 2012

  1. Main Page
  2. Alphabetical List
  3. Data Structures
  4. Directories
  5. File List
  6. Data Fields
  7. Globals
  8. Related Pages

ReactOS Development > Doxygen

oleauto.h
Go to the documentation of this file.
00001 /*
00002  * Copyright (C) the Wine project
00003  *
00004  * This library is free software; you can redistribute it and/or
00005  * modify it under the terms of the GNU Lesser General Public
00006  * License as published by the Free Software Foundation; either
00007  * version 2.1 of the License, or (at your option) any later version.
00008  *
00009  * This library is distributed in the hope that it will be useful,
00010  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012  * Lesser General Public License for more details.
00013  *
00014  * You should have received a copy of the GNU Lesser General Public
00015  * License along with this library; if not, write to the Free Software
00016  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
00017  */
00018 
00019 #ifndef __WINE_OLEAUTO_H
00020 #define __WINE_OLEAUTO_H
00021 
00022 #include <oaidl.h>
00023 
00024 #ifdef __cplusplus
00025 extern "C" {
00026 #endif
00027 
00028 DEFINE_OLEGUID(IID_StdOle, 0x00020430,0,0);
00029 
00030 #define STDOLE_MAJORVERNUM  1
00031 #define STDOLE_MINORVERNUM  0
00032 #define STDOLE_LCID         0
00033 
00034 #define STDOLE2_MAJORVERNUM 2
00035 #define STDOLE2_MINORVERNUM 0
00036 #define STDOLE2_LCID        0
00037 
00038 ULONG WINAPI OaBuildVersion(void);
00039 
00040 /* BSTR functions */
00041 BSTR WINAPI SysAllocString(const OLECHAR*);
00042 BSTR WINAPI SysAllocStringByteLen(LPCSTR,UINT);
00043 BSTR WINAPI SysAllocStringLen(const OLECHAR*,UINT);
00044 void WINAPI SysFreeString(BSTR);
00045 INT  WINAPI SysReAllocString(LPBSTR,const OLECHAR*);
00046 int  WINAPI SysReAllocStringLen(BSTR*,const OLECHAR*,UINT);
00047 UINT WINAPI SysStringByteLen(BSTR);
00048 UINT WINAPI SysStringLen(BSTR);
00049 
00050 /* IErrorInfo helpers */
00051 HRESULT WINAPI SetErrorInfo(ULONG,IErrorInfo*);
00052 HRESULT WINAPI GetErrorInfo(ULONG,IErrorInfo**);
00053 HRESULT WINAPI CreateErrorInfo(ICreateErrorInfo**);
00054 
00055 /* SafeArray functions */
00056 SAFEARRAY* WINAPI SafeArrayCreate(VARTYPE,UINT,SAFEARRAYBOUND*);
00057 SAFEARRAY* WINAPI SafeArrayCreateEx(VARTYPE,UINT,SAFEARRAYBOUND*,LPVOID);
00058 SAFEARRAY* WINAPI SafeArrayCreateVector(VARTYPE,LONG,ULONG);
00059 SAFEARRAY* WINAPI SafeArrayCreateVectorEx(VARTYPE,LONG,ULONG,LPVOID);
00060 
00061 HRESULT WINAPI SafeArrayAllocDescriptor(UINT,SAFEARRAY**);
00062 HRESULT WINAPI SafeArrayAllocDescriptorEx(VARTYPE,UINT,SAFEARRAY**);
00063 HRESULT WINAPI SafeArrayAllocData(SAFEARRAY*);
00064 HRESULT WINAPI SafeArrayDestroyDescriptor(SAFEARRAY*);
00065 HRESULT WINAPI SafeArrayPutElement(SAFEARRAY*,LONG*,void*);
00066 HRESULT WINAPI SafeArrayGetElement(SAFEARRAY*,LONG*,void*);
00067 HRESULT WINAPI SafeArrayLock(SAFEARRAY*);
00068 HRESULT WINAPI SafeArrayUnlock(SAFEARRAY*);
00069 HRESULT WINAPI SafeArrayGetUBound(SAFEARRAY*,UINT,LONG*);
00070 HRESULT WINAPI SafeArrayGetLBound(SAFEARRAY*,UINT,LONG*);
00071 UINT    WINAPI SafeArrayGetDim(SAFEARRAY*);
00072 UINT    WINAPI SafeArrayGetElemsize(SAFEARRAY*);
00073 HRESULT WINAPI SafeArrayGetVartype(SAFEARRAY*,VARTYPE*);
00074 HRESULT WINAPI SafeArrayAccessData(SAFEARRAY*,void**);
00075 HRESULT WINAPI SafeArrayUnaccessData(SAFEARRAY*);
00076 HRESULT WINAPI SafeArrayPtrOfIndex(SAFEARRAY*,LONG*,void **);
00077 HRESULT WINAPI SafeArrayCopyData(SAFEARRAY*,SAFEARRAY*);
00078 HRESULT WINAPI SafeArrayDestroyData(SAFEARRAY*);
00079 HRESULT WINAPI SafeArrayDestroy(SAFEARRAY*);
00080 HRESULT WINAPI SafeArrayCopy(SAFEARRAY*,SAFEARRAY**);
00081 HRESULT WINAPI SafeArrayRedim(SAFEARRAY*,SAFEARRAYBOUND*);
00082 HRESULT WINAPI SafeArraySetRecordInfo(SAFEARRAY*,IRecordInfo*);
00083 HRESULT WINAPI SafeArrayGetRecordInfo(SAFEARRAY*,IRecordInfo**);
00084 HRESULT WINAPI SafeArraySetIID(SAFEARRAY*,REFGUID);
00085 HRESULT WINAPI SafeArrayGetIID(SAFEARRAY*,GUID*);
00086 
00087 HRESULT WINAPI VectorFromBstr(BSTR,SAFEARRAY**);
00088 HRESULT WINAPI BstrFromVector(SAFEARRAY*,BSTR*);
00089 
00090 /* Object registration helpers */
00091 #define ACTIVEOBJECT_STRONG 0
00092 #define ACTIVEOBJECT_WEAK   1
00093 
00094 HRESULT WINAPI RegisterActiveObject(LPUNKNOWN,REFCLSID,DWORD,LPDWORD);
00095 HRESULT WINAPI RevokeActiveObject(DWORD,LPVOID);
00096 HRESULT WINAPI GetActiveObject(REFCLSID,LPVOID,LPUNKNOWN*);
00097 
00098 /* IRecordInfo helpers */
00099 HRESULT WINAPI GetRecordInfoFromTypeInfo(ITypeInfo*,IRecordInfo**);
00100 HRESULT WINAPI GetRecordInfoFromGuids(REFGUID,ULONG,ULONG,LCID,REFGUID,IRecordInfo**);
00101 
00102 /*
00103  * Variants
00104  */
00105 
00106 /* Macros for accessing the fields of the VARIANT type */
00107 #if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION)
00108 #define V_UNION(A,B) ((A)->n1.n2.n3.B)
00109 #define V_VT(A)      ((A)->n1.n2.vt)
00110 #else
00111 #define V_UNION(A,B) ((A)->B)
00112 #define V_VT(A)      ((A)->vt)
00113 #endif
00114 
00115 #define V_ISBYREF(A)  (V_VT(A) & VT_BYREF)
00116 #define V_ISARRAY(A)  (V_VT(A) & VT_ARRAY)
00117 #define V_ISVECTOR(A) (V_VT(A) & VT_VECTOR)
00118 #define V_NONE(A)     V_I2(A)
00119 
00120 #define V_ARRAY(A)       V_UNION(A,parray)
00121 #define V_ARRAYREF(A)    V_UNION(A,pparray)
00122 #define V_BOOL(A)        V_UNION(A,boolVal)
00123 #define V_BOOLREF(A)     V_UNION(A,pboolVal)
00124 #define V_BSTR(A)        V_UNION(A,bstrVal)
00125 #define V_BSTRREF(A)     V_UNION(A,pbstrVal)
00126 #define V_BYREF(A)       V_UNION(A,byref)
00127 #define V_CY(A)          V_UNION(A,cyVal)
00128 #define V_CYREF(A)       V_UNION(A,pcyVal)
00129 #define V_DATE(A)        V_UNION(A,date)
00130 #define V_DATEREF(A)     V_UNION(A,pdate)
00131 #if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION)
00132 #define V_DECIMAL(A)     ((A)->n1.decVal)
00133 #else
00134 #define V_DECIMAL(A)     ((A)->decVal)
00135 #endif
00136 #define V_DECIMALREF(A)  V_UNION(A,pdecVal)
00137 #define V_DISPATCH(A)    V_UNION(A,pdispVal)
00138 #define V_DISPATCHREF(A) V_UNION(A,ppdispVal)
00139 #define V_ERROR(A)       V_UNION(A,scode)
00140 #define V_ERRORREF(A)    V_UNION(A,pscode)
00141 #define V_I1(A)          V_UNION(A,cVal)
00142 #define V_I1REF(A)       V_UNION(A,pcVal)
00143 #define V_I2(A)          V_UNION(A,iVal)
00144 #define V_I2REF(A)       V_UNION(A,piVal)
00145 #define V_I4(A)          V_UNION(A,lVal)
00146 #define V_I4REF(A)       V_UNION(A,plVal)
00147 #define V_I8(A)          V_UNION(A,llVal)
00148 #define V_I8REF(A)       V_UNION(A,pllVal)
00149 #define V_INT(A)         V_UNION(A,intVal)
00150 #define V_INTREF(A)      V_UNION(A,pintVal)
00151 #ifdef _WIN64
00152 #define V_INT_PTR(A)     V_I8(A)
00153 #define V_INT_PTRREF(A)  V_I8REF(A)
00154 #else
00155 #define V_INT_PTR(A)     V_I4(A)
00156 #define V_INT_PTRREF(A)  V_I4REF(A)
00157 #endif
00158 #define V_R4(A)          V_UNION(A,fltVal)
00159 #define V_R4REF(A)       V_UNION(A,pfltVal)
00160 #define V_R8(A)          V_UNION(A,dblVal)
00161 #define V_R8REF(A)       V_UNION(A,pdblVal)
00162 #define V_UINT(A)        V_UNION(A,uintVal)
00163 #define V_UINTREF(A)     V_UNION(A,puintVal)
00164 #define V_UI1(A)         V_UNION(A,bVal)
00165 #define V_UI1REF(A)      V_UNION(A,pbVal)
00166 #define V_UI2(A)         V_UNION(A,uiVal)
00167 #define V_UI2REF(A)      V_UNION(A,puiVal)
00168 #define V_UI4(A)         V_UNION(A,ulVal)
00169 #define V_UI4REF(A)      V_UNION(A,pulVal)
00170 #define V_UI8(A)         V_UNION(A,ullVal)
00171 #define V_UI8REF(A)      V_UNION(A,pullVal)
00172 #ifdef _WIN64
00173 #define V_UINT_PTR(A)    V_UI8(A)
00174 #define V_UINT_PTRREF(A) V_UI8REF(A)
00175 #else
00176 #define V_UINT_PTR(A)    V_UI4(A)
00177 #define V_UINT_PTRREF(A) V_UI4REF(A)
00178 #endif
00179 #define V_UNKNOWN(A)     V_UNION(A,punkVal)
00180 #define V_UNKNOWNREF(A)  V_UNION(A,ppunkVal)
00181 #define V_VARIANTREF(A)  V_UNION(A,pvarVal)
00182 
00183 void    WINAPI VariantInit(VARIANT*);
00184 HRESULT WINAPI VariantClear(VARIANT*);
00185 HRESULT WINAPI VariantCopy(VARIANT*,VARIANT*);
00186 HRESULT WINAPI VariantCopyInd(VARIANT*,VARIANT*);
00187 HRESULT WINAPI VariantChangeType(VARIANT*,VARIANT*,USHORT,VARTYPE);
00188 HRESULT WINAPI VariantChangeTypeEx(VARIANT*,VARIANT*,LCID,USHORT,VARTYPE);
00189 
00190 /* VariantChangeType/VariantChangeTypeEx flags */
00191 #define VARIANT_NOVALUEPROP        0x01 /* Don't get the default value property from IDispatch */
00192 #define VARIANT_ALPHABOOL          0x02 /* Coerce to "True"|"False" instead of "-1"|"0" */
00193 #define VARIANT_NOUSEROVERRIDE     0x04 /* Pass LOCALE_NOUSEROVERRIDE to low level conversions */
00194 #define VARIANT_CALENDAR_HIJRI     0x08 /* Use the Hijri calendar */
00195 #define VARIANT_LOCALBOOL          0x10 /* Like VARIANT_ALPHABOOL, but use localised text */
00196 #define VARIANT_CALENDAR_THAI      0x20 /* Use the Thai buddhist calendar */
00197 #define VARIANT_CALENDAR_GREGORIAN 0x40 /* Use the Gregorian calendar */
00198 #define VARIANT_USE_NLS            0x80 /* Format result using NLS calls */
00199 
00200 /*
00201  * Low level Variant coercion functions
00202  */
00203 
00204 #define VT_HARDTYPE VT_RESERVED /* Don't coerce this variant when comparing it to others */
00205 
00206 /* Flags for low level coercions. LOCALE_ flags can also be passed */
00207 #define VAR_TIMEVALUEONLY       0x001 /* Ignore date portion of VT_DATE */
00208 #define VAR_DATEVALUEONLY       0x002 /* Ignore time portion of VT_DATE */
00209 #define VAR_VALIDDATE           0x004
00210 #define VAR_CALENDAR_HIJRI      0x008 /* Use the Hijri calendar */
00211 #define VAR_LOCALBOOL           0x010 /* VT_BOOL<->VT_BSTR: Use localised boolean text */
00212 #define VAR_FORMAT_NOSUBSTITUTE 0x020 /* Don't change format strings for un-coercable types */
00213 #define VAR_FOURDIGITYEARS      0x040 /* Always print years with 4 digits */
00214 #define VAR_CALENDAR_THAI       0x080 /* Use the Thai buddhist calendar */
00215 #define VAR_CALENDAR_GREGORIAN  0x100 /* Use the Gregorian calendar */
00216 
00217 #ifndef LOCALE_USE_NLS
00218 /* This is missing from native winnls.h, but may be added at some point */
00219 #define LOCALE_USE_NLS          0x10000000
00220 #endif
00221 
00222 #define VTDATEGRE_MIN -657434 /* Minimum possible Gregorian date: 1/1/100 */
00223 #define VTDATEGRE_MAX 2958465 /* Maximum possible Gregorian date: 31/12/9999 */
00224 
00225 HRESULT WINAPI VarUI1FromI2(SHORT,BYTE*);
00226 HRESULT WINAPI VarUI1FromI4(LONG,BYTE*);
00227 HRESULT WINAPI VarUI1FromI8(LONG64,BYTE*);
00228 HRESULT WINAPI VarUI1FromR4(FLOAT,BYTE*);
00229 HRESULT WINAPI VarUI1FromR8(DOUBLE,BYTE*);
00230 HRESULT WINAPI VarUI1FromDate(DATE,BYTE*);
00231 HRESULT WINAPI VarUI1FromBool(VARIANT_BOOL,BYTE*);
00232 HRESULT WINAPI VarUI1FromI1(signed char,BYTE*);
00233 HRESULT WINAPI VarUI1FromUI2(USHORT,BYTE*);
00234 HRESULT WINAPI VarUI1FromUI4(ULONG,BYTE*);
00235 HRESULT WINAPI VarUI1FromUI8(ULONG64,BYTE*);
00236 HRESULT WINAPI VarUI1FromStr(OLECHAR*,LCID,ULONG,BYTE*);
00237 HRESULT WINAPI VarUI1FromCy(CY,BYTE*);
00238 HRESULT WINAPI VarUI1FromDec(DECIMAL*,BYTE*);
00239 HRESULT WINAPI VarUI1FromDisp(IDispatch*,LCID,BYTE*);
00240 
00241 HRESULT WINAPI VarI2FromUI1(BYTE,SHORT*);
00242 HRESULT WINAPI VarI2FromI4(LONG,SHORT*);
00243 HRESULT WINAPI VarI2FromI8(LONG64,SHORT*);
00244 HRESULT WINAPI VarI2FromR4(FLOAT,SHORT*);
00245 HRESULT WINAPI VarI2FromR8(DOUBLE,SHORT*);
00246 HRESULT WINAPI VarI2FromDate(DATE,SHORT*);
00247 HRESULT WINAPI VarI2FromBool(VARIANT_BOOL,SHORT*);
00248 HRESULT WINAPI VarI2FromI1(signed char,SHORT*);
00249 HRESULT WINAPI VarI2FromUI2(USHORT,SHORT*);
00250 HRESULT WINAPI VarI2FromUI4(ULONG,SHORT*);
00251 HRESULT WINAPI VarI2FromUI8(ULONG64,SHORT*);
00252 HRESULT WINAPI VarI2FromStr(OLECHAR*,LCID,ULONG,SHORT*);
00253 HRESULT WINAPI VarI2FromCy(CY,SHORT*);
00254 HRESULT WINAPI VarI2FromDec(DECIMAL*,SHORT*);
00255 HRESULT WINAPI VarI2FromDisp(IDispatch*,LCID,SHORT*);
00256 
00257 HRESULT WINAPI VarI4FromUI1(BYTE,LONG*);
00258 HRESULT WINAPI VarI4FromI2(SHORT,LONG*);
00259 HRESULT WINAPI VarI4FromI8(LONG64,LONG*);
00260 HRESULT WINAPI VarI4FromR4(FLOAT,LONG*);
00261 HRESULT WINAPI VarI4FromR8(DOUBLE,LONG*);
00262 HRESULT WINAPI VarI4FromDate(DATE,LONG*);
00263 HRESULT WINAPI VarI4FromBool(VARIANT_BOOL,LONG*);
00264 HRESULT WINAPI VarI4FromI1(signed char,LONG*);
00265 HRESULT WINAPI VarI4FromUI2(USHORT,LONG*);
00266 HRESULT WINAPI VarI4FromUI4(ULONG,LONG*);
00267 HRESULT WINAPI VarI4FromUI8(ULONG64,LONG*);
00268 HRESULT WINAPI VarI4FromStr(OLECHAR*,LCID,ULONG,LONG*);
00269 HRESULT WINAPI VarI4FromCy(CY,LONG*);
00270 HRESULT WINAPI VarI4FromDec(DECIMAL*,LONG*);
00271 HRESULT WINAPI VarI4FromDisp(IDispatch*,LCID,LONG*);
00272 
00273 HRESULT WINAPI VarI8FromUI1(BYTE,LONG64*);
00274 HRESULT WINAPI VarI8FromI2(SHORT,LONG64*);
00275 HRESULT WINAPI VarI8FromI4(LONG,LONG64*);
00276 HRESULT WINAPI VarI8FromR4(FLOAT,LONG64*);
00277 HRESULT WINAPI VarI8FromR8(DOUBLE,LONG64*);
00278 HRESULT WINAPI VarI8FromDate(DATE,LONG64*);
00279 HRESULT WINAPI VarI8FromStr(OLECHAR*,LCID,ULONG,LONG64*);
00280 HRESULT WINAPI VarI8FromBool(VARIANT_BOOL,LONG64*);
00281 HRESULT WINAPI VarI8FromI1(signed char,LONG64*);
00282 HRESULT WINAPI VarI8FromUI2(USHORT,LONG64*);
00283 HRESULT WINAPI VarI8FromUI4(ULONG,LONG64*);
00284 HRESULT WINAPI VarI8FromUI8(ULONG64,LONG64*);
00285 HRESULT WINAPI VarI8FromDec(DECIMAL *pdecIn,LONG64*);
00286 HRESULT WINAPI VarI8FromInt(INT intIn,LONG64*);
00287 HRESULT WINAPI VarI8FromCy(CY,LONG64*);
00288 HRESULT WINAPI VarI8FromDisp(IDispatch*,LCID,LONG64*);
00289 
00290 HRESULT WINAPI VarR4FromUI1(BYTE,FLOAT*);
00291 HRESULT WINAPI VarR4FromI2(SHORT,FLOAT*);
00292 HRESULT WINAPI VarR4FromI4(LONG,FLOAT*);
00293 HRESULT WINAPI VarR4FromI8(LONG64,FLOAT*);
00294 HRESULT WINAPI VarR4FromR8(DOUBLE,FLOAT*);
00295 HRESULT WINAPI VarR4FromDate(DATE,FLOAT*);
00296 HRESULT WINAPI VarR4FromBool(VARIANT_BOOL,FLOAT*);
00297 HRESULT WINAPI VarR4FromI1(signed char,FLOAT*);
00298 HRESULT WINAPI VarR4FromUI2(USHORT,FLOAT*);
00299 HRESULT WINAPI VarR4FromUI4(ULONG,FLOAT*);
00300 HRESULT WINAPI VarR4FromUI8(ULONG64,FLOAT*);
00301 HRESULT WINAPI VarR4FromStr(OLECHAR*,LCID,ULONG,FLOAT*);
00302 HRESULT WINAPI VarR4FromCy(CY,FLOAT*);
00303 HRESULT WINAPI VarR4FromDec(DECIMAL*,FLOAT*);
00304 HRESULT WINAPI VarR4FromDisp(IDispatch*,LCID,FLOAT*);
00305 
00306 HRESULT WINAPI VarR8FromUI1(BYTE,double*);
00307 HRESULT WINAPI VarR8FromI2(SHORT,double*);
00308 HRESULT WINAPI VarR8FromI4(LONG,double*);
00309 HRESULT WINAPI VarR8FromI8(LONG64,double*);
00310 HRESULT WINAPI VarR8FromR4(FLOAT,double*);
00311 HRESULT WINAPI VarR8FromDate(DATE,double*);
00312 HRESULT WINAPI VarR8FromBool(VARIANT_BOOL,double*);
00313 HRESULT WINAPI VarR8FromI1(signed char,double*);
00314 HRESULT WINAPI VarR8FromUI2(USHORT,double*);
00315 HRESULT WINAPI VarR8FromUI4(ULONG,double*);
00316 HRESULT WINAPI VarR8FromUI8(ULONG64,double*);
00317 HRESULT WINAPI VarR8FromStr(OLECHAR*,LCID,ULONG,double*);
00318 HRESULT WINAPI VarR8FromCy(CY,double*);
00319 HRESULT WINAPI VarR8FromDec(const DECIMAL*,double*);
00320 HRESULT WINAPI VarR8FromDisp(IDispatch*,LCID,double*);
00321 
00322 HRESULT WINAPI VarDateFromUI1(BYTE,DATE*);
00323 HRESULT WINAPI VarDateFromI2(SHORT,DATE*);
00324 HRESULT WINAPI VarDateFromI4(LONG,DATE*);
00325 HRESULT WINAPI VarDateFromI8(LONG64,DATE*);
00326 HRESULT WINAPI VarDateFromR4(FLOAT,DATE*);
00327 HRESULT WINAPI VarDateFromR8(DOUBLE,DATE*);
00328 HRESULT WINAPI VarDateFromStr(OLECHAR*,LCID,ULONG,DATE*);
00329 HRESULT WINAPI VarDateFromI1(signed char,DATE*);
00330 HRESULT WINAPI VarDateFromUI2(USHORT,DATE*);
00331 HRESULT WINAPI VarDateFromUI4(ULONG,DATE*);
00332 HRESULT WINAPI VarDateFromUI8(ULONG64,DATE*);
00333 HRESULT WINAPI VarDateFromBool(VARIANT_BOOL,DATE*);
00334 HRESULT WINAPI VarDateFromCy(CY,DATE*);
00335 HRESULT WINAPI VarDateFromDec(DECIMAL*,DATE*);
00336 HRESULT WINAPI VarDateFromDisp(IDispatch*,LCID,DATE*);
00337 
00338 HRESULT WINAPI VarCyFromUI1(BYTE,CY*);
00339 HRESULT WINAPI VarCyFromI2(SHORT sIn,CY*);
00340 HRESULT WINAPI VarCyFromI4(LONG,CY*);
00341 HRESULT WINAPI VarCyFromI8(LONG64,CY*);
00342 HRESULT WINAPI VarCyFromR4(FLOAT,CY*);
00343 HRESULT WINAPI VarCyFromR8(DOUBLE,CY*);
00344 HRESULT WINAPI VarCyFromDate(DATE,CY*);
00345 HRESULT WINAPI VarCyFromStr(OLECHAR*,LCID,ULONG,CY*);
00346 HRESULT WINAPI VarCyFromBool(VARIANT_BOOL,CY*);
00347 HRESULT WINAPI VarCyFromI1(signed char,CY*);
00348 HRESULT WINAPI VarCyFromUI2(USHORT,CY*);
00349 HRESULT WINAPI VarCyFromUI4(ULONG,CY*);
00350 HRESULT WINAPI VarCyFromUI8(ULONG64,CY*);
00351 HRESULT WINAPI VarCyFromDec(DECIMAL*,CY*);
00352 HRESULT WINAPI VarCyFromDisp(IDispatch*,LCID,CY*);
00353 
00354 HRESULT WINAPI VarBstrFromUI1(BYTE,LCID,ULONG,BSTR*);
00355 HRESULT WINAPI VarBstrFromI2(SHORT,LCID,ULONG,BSTR*);
00356 HRESULT WINAPI VarBstrFromI4(LONG,LCID,ULONG,BSTR*);
00357 HRESULT WINAPI VarBstrFromI8(LONG64,LCID,ULONG,BSTR*);
00358 HRESULT WINAPI VarBstrFromR4(FLOAT,LCID,ULONG,BSTR*);
00359 HRESULT WINAPI VarBstrFromR8(DOUBLE,LCID,ULONG,BSTR*);
00360 HRESULT WINAPI VarBstrFromDate(DATE,LCID,ULONG,BSTR*);
00361 HRESULT WINAPI VarBstrFromBool(VARIANT_BOOL,LCID,ULONG,BSTR*);
00362 HRESULT WINAPI VarBstrFromI1(signed char,LCID,ULONG,BSTR*);
00363 HRESULT WINAPI VarBstrFromUI2(USHORT,LCID,ULONG,BSTR*);
00364 HRESULT WINAPI VarBstrFromUI8(ULONG64,LCID,ULONG,BSTR*);
00365 HRESULT WINAPI VarBstrFromUI4(ULONG,LCID,ULONG,BSTR*);
00366 HRESULT WINAPI VarBstrFromCy(CY,LCID,ULONG,BSTR*);
00367 HRESULT WINAPI VarBstrFromDec(DECIMAL*,LCID,ULONG,BSTR*);
00368 HRESULT WINAPI VarBstrFromDisp(IDispatch*,LCID,ULONG,BSTR*);
00369 
00370 HRESULT WINAPI VarBoolFromUI1(BYTE,VARIANT_BOOL*);
00371 HRESULT WINAPI VarBoolFromI2(SHORT,VARIANT_BOOL*);
00372 HRESULT WINAPI VarBoolFromI4(LONG,VARIANT_BOOL*);
00373 HRESULT WINAPI VarBoolFromI8(LONG64,VARIANT_BOOL*);
00374 HRESULT WINAPI VarBoolFromR4(FLOAT,VARIANT_BOOL*);
00375 HRESULT WINAPI VarBoolFromR8(DOUBLE,VARIANT_BOOL*);
00376 HRESULT WINAPI VarBoolFromDate(DATE,VARIANT_BOOL*);
00377 HRESULT WINAPI VarBoolFromStr(OLECHAR*,LCID,ULONG,VARIANT_BOOL*);
00378 HRESULT WINAPI VarBoolFromI1(signed char,VARIANT_BOOL*);
00379 HRESULT WINAPI VarBoolFromUI2(USHORT,VARIANT_BOOL*);
00380 HRESULT WINAPI VarBoolFromUI4(ULONG,VARIANT_BOOL*);
00381 HRESULT WINAPI VarBoolFromUI8(ULONG64,VARIANT_BOOL*);
00382 HRESULT WINAPI VarBoolFromCy(CY,VARIANT_BOOL*);
00383 HRESULT WINAPI VarBoolFromDec(DECIMAL*,VARIANT_BOOL*);
00384 HRESULT WINAPI VarBoolFromDisp(IDispatch*,LCID,VARIANT_BOOL*);
00385 
00386 HRESULT WINAPI VarI1FromUI1(BYTE,signed char*);
00387 HRESULT WINAPI VarI1FromI2(SHORT,signed char*);
00388 HRESULT WINAPI VarI1FromI4(LONG,signed char*);
00389 HRESULT WINAPI VarI1FromI8(LONG64,signed char*);
00390 HRESULT WINAPI VarI1FromR4(FLOAT,signed char*);
00391 HRESULT WINAPI VarI1FromR8(DOUBLE,signed char*);
00392 HRESULT WINAPI VarI1FromDate(DATE,signed char*);
00393 HRESULT WINAPI VarI1FromStr(OLECHAR*,LCID,ULONG,signed char*);
00394 HRESULT WINAPI VarI1FromBool(VARIANT_BOOL,signed char*);
00395 HRESULT WINAPI VarI1FromUI2(USHORT,signed char*);
00396 HRESULT WINAPI VarI1FromUI4(ULONG,signed char*);
00397 HRESULT WINAPI VarI1FromUI8(ULONG64,signed char*);
00398 HRESULT WINAPI VarI1FromCy(CY,signed char*);
00399 HRESULT WINAPI VarI1FromDec(DECIMAL*,signed char*);
00400 HRESULT WINAPI VarI1FromDisp(IDispatch*,LCID,signed char*);
00401 
00402 HRESULT WINAPI VarUI2FromUI1(BYTE,USHORT*);
00403 HRESULT WINAPI VarUI2FromI2(SHORT,USHORT*);
00404 HRESULT WINAPI VarUI2FromI4(LONG,USHORT*);
00405 HRESULT WINAPI VarUI2FromI8(LONG64,USHORT*);
00406 HRESULT WINAPI VarUI2FromR4(FLOAT,USHORT*);
00407 HRESULT WINAPI VarUI2FromR8(DOUBLE,USHORT*);
00408 HRESULT WINAPI VarUI2FromDate(DATE,USHORT*);
00409 HRESULT WINAPI VarUI2FromStr(OLECHAR*,LCID,ULONG,USHORT*);
00410 HRESULT WINAPI VarUI2FromBool(VARIANT_BOOL,USHORT*);
00411 HRESULT WINAPI VarUI2FromI1(signed char,USHORT*);
00412 HRESULT WINAPI VarUI2FromUI4(ULONG,USHORT*);
00413 HRESULT WINAPI VarUI2FromUI8(ULONG64,USHORT*);
00414 HRESULT WINAPI VarUI2FromCy(CY,USHORT*);
00415 HRESULT WINAPI VarUI2FromDec(DECIMAL*,USHORT*);
00416 HRESULT WINAPI VarUI2FromDisp(IDispatch*,LCID,USHORT*);
00417 
00418 HRESULT WINAPI VarUI4FromStr(OLECHAR*,LCID,ULONG,ULONG*);
00419 HRESULT WINAPI VarUI4FromUI1(BYTE,ULONG*);
00420 HRESULT WINAPI VarUI4FromI2(SHORT,ULONG*);
00421 HRESULT WINAPI VarUI4FromI4(LONG,ULONG*);
00422 HRESULT WINAPI VarUI4FromI8(LONG64,ULONG*);
00423 HRESULT WINAPI VarUI4FromR4(FLOAT,ULONG*);
00424 HRESULT WINAPI VarUI4FromR8(DOUBLE,ULONG*);
00425 HRESULT WINAPI VarUI4FromDate(DATE,ULONG*);
00426 HRESULT WINAPI VarUI4FromBool(VARIANT_BOOL,ULONG*);
00427 HRESULT WINAPI VarUI4FromI1(signed char,ULONG*);
00428 HRESULT WINAPI VarUI4FromUI2(USHORT,ULONG*);
00429 HRESULT WINAPI VarUI4FromUI8(ULONG64,ULONG*);
00430 HRESULT WINAPI VarUI4FromCy(CY,ULONG*);
00431 HRESULT WINAPI VarUI4FromDec(DECIMAL*,ULONG*);
00432 HRESULT WINAPI VarUI4FromDisp(IDispatch*,LCID,ULONG*);
00433 
00434 HRESULT WINAPI VarUI8FromUI1(BYTE,ULONG64*);
00435 HRESULT WINAPI VarUI8FromI2(SHORT,ULONG64*);
00436 HRESULT WINAPI VarUI8FromI4(LONG,ULONG64*);
00437 HRESULT WINAPI VarUI8FromI8(LONG64,ULONG64*);
00438 HRESULT WINAPI VarUI8FromR4(FLOAT,ULONG64*);
00439 HRESULT WINAPI VarUI8FromR8(DOUBLE,ULONG64*);
00440 HRESULT WINAPI VarUI8FromDate(DATE,ULONG64*);
00441 HRESULT WINAPI VarUI8FromStr(OLECHAR*,LCID,ULONG,ULONG64*);
00442 HRESULT WINAPI VarUI8FromBool(VARIANT_BOOL,ULONG64*);
00443 HRESULT WINAPI VarUI8FromI1(signed char,ULONG64*);
00444 HRESULT WINAPI VarUI8FromUI2(USHORT,ULONG64*);
00445 HRESULT WINAPI VarUI8FromUI4(ULONG,ULONG64*);
00446 HRESULT WINAPI VarUI8FromDec(DECIMAL*,ULONG64*);
00447 HRESULT WINAPI VarUI8FromInt(INT,ULONG64*);
00448 HRESULT WINAPI VarUI8FromCy(CY,ULONG64*);
00449 HRESULT WINAPI VarUI8FromDisp(IDispatch*,LCID,ULONG64*);
00450 
00451 HRESULT WINAPI VarDecFromUI1(BYTE,DECIMAL*);
00452 HRESULT WINAPI VarDecFromI2(SHORT,DECIMAL*);
00453 HRESULT WINAPI VarDecFromI4(LONG,DECIMAL*);
00454 HRESULT WINAPI VarDecFromI8(LONG64,DECIMAL*);
00455 HRESULT WINAPI VarDecFromR4(FLOAT,DECIMAL*);
00456 HRESULT WINAPI VarDecFromR8(DOUBLE,DECIMAL*);
00457 HRESULT WINAPI VarDecFromDate(DATE,DECIMAL*);
00458 HRESULT WINAPI VarDecFromStr(OLECHAR*,LCID,ULONG,DECIMAL*);
00459 HRESULT WINAPI VarDecFromBool(VARIANT_BOOL,DECIMAL*);
00460 HRESULT WINAPI VarDecFromI1(signed char,DECIMAL*);
00461 HRESULT WINAPI VarDecFromUI2(USHORT,DECIMAL*);
00462 HRESULT WINAPI VarDecFromUI4(ULONG,DECIMAL*);
00463 HRESULT WINAPI VarDecFromUI8(ULONG64,DECIMAL*);
00464 HRESULT WINAPI VarDecFromCy(CY,DECIMAL*);
00465 HRESULT WINAPI VarDecFromDisp(IDispatch*,LCID,DECIMAL*);
00466 
00467 #define VarUI4FromUI4( in,pOut ) ( *(pOut) =  (in) )
00468 #define VarI4FromI4( in,pOut )   ( *(pOut) =  (in) )
00469 
00470 #define VarUI1FromInt   VarUI1FromI4
00471 #define VarUI1FromUint  VarUI1FromUI4
00472 #define VarI2FromInt    VarI2FromI4
00473 #define VarI2FromUint   VarI2FromUI4
00474 #define VarI4FromInt    VarI4FromI4
00475 #define VarI4FromUint   VarI4FromUI4
00476 #define VarI8FromInt    VarI8FromI4
00477 #define VarI8FromUint   VarI8FromUI4
00478 #define VarR4FromInt    VarR4FromI4
00479 #define VarR4FromUint   VarR4FromUI4
00480 #define VarR8FromInt    VarR8FromI4
00481 #define VarR8FromUint   VarR8FromUI4
00482 #define VarDateFromInt  VarDateFromI4
00483 #define VarDateFromUint VarDateFromUI4
00484 #define VarCyFromInt    VarCyFromI4
00485 #define VarCyFromUint   VarCyFromUI4
00486 #define VarBstrFromInt  VarBstrFromI4
00487 #define VarBstrFromUint VarBstrFromUI4
00488 #define VarBoolFromInt  VarBoolFromI4
00489 #define VarBoolFromUint VarBoolFromUI4
00490 #define VarI1FromInt    VarI1FromI4
00491 #define VarI1FromUint   VarI1FromUI4
00492 #define VarUI2FromInt   VarUI2FromI4
00493 #define VarUI2FromUint  VarUI2FromUI4
00494 #define VarUI4FromInt   VarUI4FromI4
00495 #define VarUI4FromUint  VarUI4FromUI4
00496 #define VarUI8FromInt   VarUI8FromI4
00497 #define VarUI8FromUint  VarUI8FromUI4
00498 #define VarDecFromInt   VarDecFromI4
00499 #define VarDecFromUint  VarDecFromUI4
00500 #define VarIntFromUI1   VarI4FromUI1
00501 #define VarIntFromI2    VarI4FromI2
00502 #define VarIntFromI4    VarI4FromI4
00503 #define VarIntFromI8    VarI4FromI8
00504 #define VarIntFromR4    VarI4FromR4
00505 #define VarIntFromR8    VarI4FromR8
00506 #define VarIntFromDate  VarI4FromDate
00507 #define VarIntFromCy    VarI4FromCy
00508 #define VarIntFromStr   VarI4FromStr
00509 #define VarIntFromDisp  VarI4FromDisp
00510 #define VarIntFromBool  VarI4FromBool
00511 #define VarIntFromI1    VarI4FromI1
00512 #define VarIntFromUI2   VarI4FromUI2
00513 #define VarIntFromUI4   VarI4FromUI4
00514 #define VarIntFromUI8   VarI4FromUI8
00515 #define VarIntFromDec   VarI4FromDec
00516 #define VarIntFromUint  VarI4FromUI4
00517 #define VarUintFromUI1  VarUI4FromUI1
00518 #define VarUintFromI2   VarUI4FromI2
00519 #define VarUintFromI4   VarUI4FromI4
00520 #define VarUintFromI8   VarUI4FromI8
00521 #define VarUintFromR4   VarUI4FromR4
00522 #define VarUintFromR8   VarUI4FromR8
00523 #define VarUintFromDate VarUI4FromDate
00524 #define VarUintFromCy   VarUI4FromCy
00525 #define VarUintFromStr  VarUI4FromStr
00526 #define VarUintFromDisp VarUI4FromDisp
00527 #define VarUintFromBool VarUI4FromBool
00528 #define VarUintFromI1   VarUI4FromI1
00529 #define VarUintFromUI2  VarUI4FromUI2
00530 #define VarUintFromUI4  VarUI4FromUI4
00531 #define VarUintFromUI8  VarUI4FromUI8
00532 #define VarUintFromDec  VarUI4FromDec
00533 #define VarUintFromInt  VarUI4FromI4
00534 
00535 /*
00536  * Variant Math operations
00537  */
00538 #define VARCMP_LT   0
00539 #define VARCMP_EQ   1
00540 #define VARCMP_GT   2
00541 #define VARCMP_NULL 3
00542 
00543 HRESULT WINAPI VarR4CmpR8(float,double);
00544 
00545 HRESULT WINAPI VarR8Pow(double,double,double*);
00546 HRESULT WINAPI VarR8Round(double,int,double*);
00547 
00548 HRESULT WINAPI VarDecAbs(const DECIMAL*,DECIMAL*);
00549 HRESULT WINAPI VarDecAdd(const DECIMAL*,const DECIMAL*,DECIMAL*);
00550 HRESULT WINAPI VarDecCmp(const DECIMAL*,const DECIMAL*);
00551 HRESULT WINAPI VarDecCmpR8(const DECIMAL*,DOUBLE);
00552 HRESULT WINAPI VarDecDiv(const DECIMAL*,const DECIMAL*,DECIMAL*);
00553 HRESULT WINAPI VarDecFix(const DECIMAL*,DECIMAL*);
00554 HRESULT WINAPI VarDecInt(const DECIMAL*,DECIMAL*);
00555 HRESULT WINAPI VarDecMul(const DECIMAL*,const DECIMAL*,DECIMAL*);
00556 HRESULT WINAPI VarDecNeg(const DECIMAL*,DECIMAL*);
00557 HRESULT WINAPI VarDecRound(const DECIMAL*,int,DECIMAL*);
00558 HRESULT WINAPI VarDecSub(const DECIMAL*,const DECIMAL*,DECIMAL*);
00559 
00560 HRESULT WINAPI VarCyAbs(const CY,CY*);
00561 HRESULT WINAPI VarCyAdd(const CY,const CY,CY*);
00562 HRESULT WINAPI VarCyCmp(const CY,const CY);
00563 HRESULT WINAPI VarCyCmpR8(const CY,DOUBLE);
00564 HRESULT WINAPI VarCyFix(const CY,CY*);
00565 HRESULT WINAPI VarCyInt(const CY,CY*);
00566 HRESULT WINAPI VarCyMul(const CY,CY,CY*);
00567 HRESULT WINAPI VarCyMulI4(const CY,LONG,CY*);
00568 HRESULT WINAPI VarCyMulI8(const CY,LONG64,CY*);
00569 HRESULT WINAPI VarCyNeg(const CY,CY*);
00570 HRESULT WINAPI VarCyRound(const CY,INT,CY*);
00571 HRESULT WINAPI VarCySub(const CY,const CY,CY*);
00572 
00573 HRESULT WINAPI VarAdd(LPVARIANT,LPVARIANT,LPVARIANT);
00574 HRESULT WINAPI VarAnd(LPVARIANT,LPVARIANT,LPVARIANT);
00575 HRESULT WINAPI VarCat(LPVARIANT,LPVARIANT,LPVARIANT);
00576 HRESULT WINAPI VarDiv(LPVARIANT,LPVARIANT,LPVARIANT);
00577 HRESULT WINAPI VarEqv(LPVARIANT,LPVARIANT,LPVARIANT);
00578 HRESULT WINAPI VarIdiv(LPVARIANT,LPVARIANT,LPVARIANT);
00579 HRESULT WINAPI VarImp(LPVARIANT,LPVARIANT,LPVARIANT);
00580 HRESULT WINAPI VarMod(LPVARIANT,LPVARIANT,LPVARIANT);
00581 HRESULT WINAPI VarMul(LPVARIANT,LPVARIANT,LPVARIANT);
00582 HRESULT WINAPI VarOr(LPVARIANT,LPVARIANT,LPVARIANT);
00583 HRESULT WINAPI VarPow(LPVARIANT,LPVARIANT,LPVARIANT);
00584 HRESULT WINAPI VarSub(LPVARIANT,LPVARIANT,LPVARIANT);
00585 HRESULT WINAPI VarXor(LPVARIANT,LPVARIANT,LPVARIANT);
00586 
00587 HRESULT WINAPI VarAbs(LPVARIANT,LPVARIANT);
00588 HRESULT WINAPI VarFix(LPVARIANT,LPVARIANT);
00589 HRESULT WINAPI VarInt(LPVARIANT,LPVARIANT);
00590 HRESULT WINAPI VarNeg(LPVARIANT,LPVARIANT);
00591 HRESULT WINAPI VarNot(LPVARIANT,LPVARIANT);
00592 
00593 HRESULT WINAPI VarRound(LPVARIANT,int,LPVARIANT);
00594 
00595 HRESULT WINAPI VarCmp(LPVARIANT,LPVARIANT,LCID,ULONG);
00596 
00597 HRESULT WINAPI VarBstrCmp(BSTR,BSTR,LCID,ULONG);
00598 HRESULT WINAPI VarBstrCat(BSTR,BSTR,BSTR*);
00599 
00600 
00601 typedef struct {
00602     SYSTEMTIME st;
00603     USHORT wDayOfYear;
00604 } UDATE;
00605 
00606 typedef struct
00607 {
00608     INT   cDig;       /* Number of parsed digits */
00609     ULONG dwInFlags;  /* Acceptable state of the input string (NUMPRS_ flags) */
00610     ULONG dwOutFlags; /* Parsed state of the output string (NUMPRS_ flags) */
00611     INT   cchUsed;    /* Number of characters parsed from input string */
00612     INT   nBaseShift; /* Base of the number (but apparently unused) */
00613     INT   nPwr10;     /* Scale of the number in powers of 10 */
00614 } NUMPARSE;
00615 
00616 #define NUMPRS_LEADING_WHITE  0x00001 /* Leading whitespace */
00617 #define NUMPRS_TRAILING_WHITE 0x00002 /* Trailing whitespace */
00618 #define NUMPRS_LEADING_PLUS   0x00004 /* Leading '+' sign */
00619 #define NUMPRS_TRAILING_PLUS  0x00008 /* Trailing '+' sign */
00620 #define NUMPRS_LEADING_MINUS  0x00010 /* Leading '-' sign */
00621 #define NUMPRS_TRAILING_MINUS 0x00020 /* Trailing '-' sign */
00622 #define NUMPRS_HEX_OCT        0x00040 /* Octal number (with a leading 0) */
00623 #define NUMPRS_PARENS         0x00080 /* Parentheses for negative numbers */
00624 #define NUMPRS_DECIMAL        0x00100 /* Decimal separator */
00625 #define NUMPRS_THOUSANDS      0x00200 /* Thousands separator */
00626 #define NUMPRS_CURRENCY       0x00400 /* Currency symbol */
00627 #define NUMPRS_EXPONENT       0x00800 /* Exponent (e.g. "e-14") */
00628 #define NUMPRS_USE_ALL        0x01000 /* Parse the entire string */
00629 #define NUMPRS_STD            0x01FFF /* Standard flags for internal coercions (All of the above) */
00630 #define NUMPRS_NEG            0x10000 /* Number is negative (dwOutFlags only) */
00631 #define NUMPRS_INEXACT        0x20000 /* Number is represented inexactly (dwOutFlags only) */
00632 
00633 #define VTBIT_I1      (1 << VT_I1)
00634 #define VTBIT_UI1     (1 << VT_UI1)
00635 #define VTBIT_I2      (1 << VT_I2)
00636 #define VTBIT_UI2     (1 << VT_UI2)
00637 #define VTBIT_I4      (1 << VT_I4)
00638 #define VTBIT_UI4     (1 << VT_UI4)
00639 #define VTBIT_I8      (1 << VT_I8)
00640 #define VTBIT_UI8     (1 << VT_UI8)
00641 #define VTBIT_R4      (1 << VT_R4)
00642 #define VTBIT_R8      (1 << VT_R8)
00643 #define VTBIT_CY      (1 << VT_CY)
00644 #define VTBIT_DECIMAL (1 << VT_DECIMAL)
00645 
00646 HRESULT WINAPI VarParseNumFromStr(OLECHAR*,LCID,ULONG,NUMPARSE*,BYTE*);
00647 HRESULT WINAPI VarNumFromParseNum(NUMPARSE*,BYTE*,ULONG,VARIANT*);
00648 
00649 INT WINAPI DosDateTimeToVariantTime(USHORT,USHORT,double*);
00650 INT WINAPI VariantTimeToDosDateTime(double,USHORT*,USHORT*);
00651 
00652 INT WINAPI VariantTimeToSystemTime(DOUBLE,LPSYSTEMTIME);
00653 INT WINAPI SystemTimeToVariantTime(LPSYSTEMTIME,double*);
00654 
00655 HRESULT WINAPI VarDateFromUdate(UDATE*,ULONG,DATE*);
00656 HRESULT WINAPI VarDateFromUdateEx(UDATE*,LCID,ULONG,DATE*);
00657 HRESULT WINAPI VarUdateFromDate(DATE,ULONG,UDATE*);
00658 
00659 /* Variant formatting */
00660 HRESULT WINAPI VarWeekdayName(int,int,int,ULONG,BSTR*);
00661 HRESULT WINAPI VarMonthName(int,int,ULONG,BSTR*);
00662 HRESULT WINAPI GetAltMonthNames(LCID,LPOLESTR**);
00663 
00664 HRESULT WINAPI VarFormat(LPVARIANT,LPOLESTR,int,int,ULONG,BSTR*);
00665 HRESULT WINAPI VarFormatCurrency(LPVARIANT,int,int,int,int,ULONG,BSTR*);
00666 HRESULT WINAPI VarFormatDateTime(LPVARIANT,int,ULONG,BSTR*);
00667 HRESULT WINAPI VarFormatNumber(LPVARIANT,int,int,int,int,ULONG,BSTR*);
00668 HRESULT WINAPI VarFormatPercent(LPVARIANT,int,int,int,int,ULONG,BSTR*);
00669 
00670 HRESULT WINAPI VarFormatFromTokens(LPVARIANT,LPOLESTR,LPBYTE,ULONG,BSTR*,LCID);
00671 HRESULT WINAPI VarTokenizeFormatString(LPOLESTR,LPBYTE,int,int,int,LCID,int*);
00672 
00673 
00674 /*
00675  * IDispatch types and helper functions
00676  */
00677 
00678 /* A structure describing a single parameter to a com object method. */
00679 typedef struct tagPARAMDATA
00680 {
00681     OLECHAR *szName; /* Name of Parameter */
00682     VARTYPE  vt;     /* Type of Parameter */
00683 } PARAMDATA, *LPPARAMDATA;
00684 
00685 /* A structure describing a single method of a com object. */
00686 typedef struct tagMETHODDATA
00687 {
00688     OLECHAR   *szName;   /* Name of method */
00689     PARAMDATA *ppdata;   /* Parameters of the method */
00690     DISPID     dispid;   /* Id of the method */
00691     UINT       iMeth;    /* Vtable index of the method */
00692     CALLCONV   cc;       /* Calling convention of the method */
00693     UINT       cArgs;    /* Number of parameters in the method */
00694     WORD       wFlags;   /* Type of the method (DISPATCH_ flags) */
00695     VARTYPE    vtReturn; /* Type of the return value */
00696 } METHODDATA, *LPMETHODDATA;
00697 
00698 /* Structure describing a single com object */
00699 typedef struct tagINTERFACEDATA
00700 {
00701     METHODDATA *pmethdata;  /* Methods of the object */
00702     UINT        cMembers;   /* Number of methods in the object */
00703 } INTERFACEDATA, *LPINTERFACEDATA;
00704 
00705 typedef enum tagREGKIND
00706 {
00707     REGKIND_DEFAULT,
00708     REGKIND_REGISTER,
00709     REGKIND_NONE
00710 } REGKIND;
00711 
00712 HRESULT WINAPI DispGetParam(DISPPARAMS*,UINT,VARTYPE,VARIANT*,UINT*);
00713 HRESULT WINAPI DispGetIDsOfNames(ITypeInfo*,OLECHAR**,UINT,DISPID*);
00714 HRESULT WINAPI DispInvoke(void*,ITypeInfo*,DISPID,WORD,DISPPARAMS*,VARIANT*,
00715                           EXCEPINFO*,UINT*);
00716 HRESULT WINAPI CreateDispTypeInfo(INTERFACEDATA*,LCID,ITypeInfo**);
00717 HRESULT WINAPI CreateStdDispatch(IUnknown*,void*,ITypeInfo*,IUnknown**);
00718 HRESULT WINAPI DispCallFunc(void*,ULONG_PTR,CALLCONV,VARTYPE,UINT,VARTYPE*,
00719                             VARIANTARG**,VARIANT*);
00720 
00721 
00722 /*
00723  * TypeLib API
00724  */
00725 
00726 ULONG WINAPI LHashValOfNameSysA(SYSKIND,LCID,LPCSTR);
00727 ULONG WINAPI LHashValOfNameSys(SYSKIND,LCID,LPCOLESTR);
00728 
00729 #define LHashValOfName(lcid,name) LHashValOfNameSys(SYS_WIN32,lcid,name)
00730 #define WHashValOfLHashVal(hash) ((USHORT)((hash) & 0xffff))
00731 #define IsHashValCompatible(hash1,hash2) ((hash1) & 0xff0000 == (hash2) & 0xff0000)
00732 
00733 #define MEMBERID_NIL   DISPID_UNKNOWN
00734 #define ID_DEFAULTINST -2
00735 
00736 #define DISPATCH_METHOD         0x1
00737 #define DISPATCH_PROPERTYGET    0x2
00738 #define DISPATCH_PROPERTYPUT    0x4
00739 #define DISPATCH_PROPERTYPUTREF 0x8
00740 
00741 #define LOAD_TLB_AS_32BIT       0x20
00742 #define LOAD_TLB_AS_64BIT       0x40
00743 #define MASK_TO_RESET_TLB_BITS  ~(LOAD_TLB_AS_32BIT|LOAD_TLB_AS_64BIT)
00744 
00745 HRESULT WINAPI CreateTypeLib(SYSKIND,const OLECHAR*,ICreateTypeLib**);
00746 HRESULT WINAPI CreateTypeLib2(SYSKIND,LPCOLESTR,ICreateTypeLib2**);
00747 HRESULT WINAPI LoadRegTypeLib(REFGUID,WORD,WORD,LCID,ITypeLib**);
00748 HRESULT WINAPI LoadTypeLib(const OLECHAR*,ITypeLib**);
00749 HRESULT WINAPI LoadTypeLibEx(LPCOLESTR,REGKIND,ITypeLib**);
00750 HRESULT WINAPI QueryPathOfRegTypeLib(REFGUID,WORD,WORD,LCID,LPBSTR);
00751 HRESULT WINAPI RegisterTypeLib(ITypeLib*,OLECHAR*,OLECHAR*);
00752 HRESULT WINAPI UnRegisterTypeLib(REFGUID,WORD,WORD,LCID,SYSKIND);
00753 
00754 VOID WINAPI ClearCustData(LPCUSTDATA);
00755 
00756 #ifdef __cplusplus
00757 } /* extern "C" */
00758 #endif
00759 
00760 
00761 #endif /*__WINE_OLEAUTO_H*/

Generated on Sat May 26 2012 04:30:57 for ReactOS by doxygen 1.7.6.1

ReactOS is a registered trademark or a trademark of ReactOS Foundation in the United States and other countries.