2 * Copyright (C) the Wine project
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 #ifndef __WINE_OLEAUTO_H
20 #define __WINE_OLEAUTO_H
23 #define __WINE_INCLUDE_OAIDL
25 #undef __WINE_INCLUDE_OAIDL
32 struct tagSAFEARRAYBOUND
;
39 BSTR WINAPI
SysAllocString(const OLECHAR
*);
40 BSTR WINAPI
SysAllocStringByteLen(LPCSTR
,UINT
);
41 BSTR WINAPI
SysAllocStringLen(const OLECHAR
*,UINT
);
42 void WINAPI
SysFreeString(BSTR
);
43 INT WINAPI
SysReAllocString(LPBSTR
,const OLECHAR
*);
44 int WINAPI
SysReAllocStringLen(BSTR
*,const OLECHAR
*,UINT
);
45 int WINAPI
SysStringByteLen(BSTR
);
46 int WINAPI
SysStringLen(BSTR
);
49 /*****************************************************************
53 HRESULT WINAPI
SetErrorInfo(ULONG dwReserved
, IErrorInfo
*perrinfo
);
54 HRESULT WINAPI
GetErrorInfo(ULONG dwReserved
, IErrorInfo
**pperrinfo
);
55 HRESULT WINAPI
CreateErrorInfo(ICreateErrorInfo
**pperrinfo
);
57 /*****************************************************************
62 SafeArrayAllocDescriptor(UINT cDims
, struct tagSAFEARRAY
**ppsaOut
);
65 SafeArrayAllocData(struct tagSAFEARRAY
*psa
);
67 struct tagSAFEARRAY
* WINAPI
68 SafeArrayCreate(VARTYPE vt
, UINT cDims
, struct tagSAFEARRAYBOUND
*rgsabound
);
71 SafeArrayDestroyDescriptor(struct tagSAFEARRAY
*psa
);
74 SafeArrayPutElement(struct tagSAFEARRAY
*psa
, LONG
*rgIndices
, void *pv
);
77 SafeArrayGetElement(struct tagSAFEARRAY
*psa
, LONG
*rgIndices
, void *pv
);
80 SafeArrayLock(struct tagSAFEARRAY
*psa
);
83 SafeArrayUnlock(struct tagSAFEARRAY
*psa
);
86 SafeArrayGetUBound(struct tagSAFEARRAY
*psa
, UINT nDim
, LONG
*plUbound
);
89 SafeArrayGetLBound(struct tagSAFEARRAY
*psa
, UINT nDim
, LONG
*plLbound
);
92 SafeArrayGetDim(struct tagSAFEARRAY
*psa
);
95 SafeArrayGetElemsize(struct tagSAFEARRAY
*psa
);
98 SafeArrayAccessData(struct tagSAFEARRAY
*psa
, void **ppvData
);
101 SafeArrayUnaccessData(struct tagSAFEARRAY
*psa
);
104 SafeArrayPtrOfIndex(struct tagSAFEARRAY
*psa
, LONG
*rgIndices
, void **ppvData
);
107 SafeArrayCopyData(struct tagSAFEARRAY
*psaSource
, struct tagSAFEARRAY
**psaTarget
);
110 SafeArrayDestroyData(struct tagSAFEARRAY
*psa
);
113 SafeArrayDestroy(struct tagSAFEARRAY
*psa
);
116 SafeArrayCopy(struct tagSAFEARRAY
*psa
, struct tagSAFEARRAY
**ppsaOut
);
118 struct tagSAFEARRAY
* WINAPI
119 SafeArrayCreateVector(VARTYPE vt
, LONG lLbound
, ULONG cElements
);
122 SafeArrayRedim(struct tagSAFEARRAY
*psa
, struct tagSAFEARRAYBOUND
*psaboundNew
);
125 /* These are macros that help accessing the VARIANT date type.
127 #if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION)
128 #define V_UNION(A, B) ((A)->n1.n2.n3.B)
129 #define V_VT(A) ((A)->n1.n2.vt)
131 #define V_UNION(A, B) ((A)->B)
132 #define V_VT(A) ((A)->vt)
133 #endif /* cplusplus */
135 #define V_ISBYREF(A) (V_VT(A)&VT_BYREF)
136 #define V_ISARRAY(A) (V_VT(A)&VT_ARRAY)
137 #define V_ISVECTOR(A) (V_VT(A)&VT_VECTOR)
138 #define V_NONE(A) V_I2(A)
140 #define V_UI1(A) V_UNION(A, bVal)
141 #define V_UI1REF(A) V_UNION(A, pbVal)
142 #define V_I2(A) V_UNION(A, iVal)
143 #define V_I2REF(A) V_UNION(A, piVal)
144 #define V_I4(A) V_UNION(A, lVal)
145 #define V_I4REF(A) V_UNION(A, plVal)
146 #define V_R4(A) V_UNION(A, fltVal)
147 #define V_R4REF(A) V_UNION(A, pfltVal)
148 #define V_R8(A) V_UNION(A, dblVal)
149 #define V_R8REF(A) V_UNION(A, pdblVal)
150 #define V_I1(A) V_UNION(A, cVal)
151 #define V_I1REF(A) V_UNION(A, pcVal)
152 #define V_UI2(A) V_UNION(A, uiVal)
153 #define V_UI2REF(A) V_UNION(A, puiVal)
154 #define V_UI4(A) V_UNION(A, ulVal)
155 #define V_UI4REF(A) V_UNION(A, pulVal)
156 #define V_INT(A) V_UNION(A, intVal)
157 #define V_INTREF(A) V_UNION(A, pintVal)
158 #define V_UINT(A) V_UNION(A, uintVal)
159 #define V_UINTREF(A) V_UNION(A, puintVal)
160 #define V_CY(A) V_UNION(A, cyVal)
161 #define V_CYREF(A) V_UNION(A, pcyVal)
162 #define V_DATE(A) V_UNION(A, date)
163 #define V_DATEREF(A) V_UNION(A, pdate)
164 #define V_BSTR(A) V_UNION(A, bstrVal)
165 #define V_BSTRREF(A) V_UNION(A, pbstrVal)
166 #define V_DISPATCH(A) V_UNION(A, pdispVal)
167 #define V_DISPATCHREF(A) V_UNION(A, ppdispVal)
168 #define V_ERROR(A) V_UNION(A, scode)
169 #define V_ERRORREF(A) V_UNION(A, pscode)
170 #define V_BOOL(A) V_UNION(A, boolVal)
171 #define V_BOOLREF(A) V_UNION(A, pboolVal)
172 #define V_UNKNOWN(A) V_UNION(A, punkVal)
173 #define V_UNKNOWNREF(A) V_UNION(A, ppunkVal)
174 #define V_VARIANTREF(A) V_UNION(A, pvarVal)
175 #define V_ARRAY(A) V_UNION(A, parray)
176 #define V_ARRAYREF(A) V_UNION(A, pparray)
177 #define V_BYREF(A) V_UNION(A, byref)
178 #define V_DECIMALREF(A) V_UNION(A, pdecVal)
179 #if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION)
180 #define V_DECIMAL(A) ((A)->n1.decVal)
182 #define V_DECIMAL(A) ((A)->decVal)
189 void WINAPI
VariantInit(struct tagVARIANT
* pvarg
);
190 HRESULT WINAPI
VariantClear(struct tagVARIANT
* pvarg
);
191 HRESULT WINAPI
VariantCopy(struct tagVARIANT
* pvargDest
, struct tagVARIANT
* pvargSrc
);
192 HRESULT WINAPI
VariantCopyInd(struct tagVARIANT
* pvargDest
, struct tagVARIANT
* pvargSrc
);
193 HRESULT WINAPI
VariantChangeType(struct tagVARIANT
* pvargDest
, struct tagVARIANT
* pvargSrc
,
194 USHORT wFlags
, VARTYPE vt
);
195 HRESULT WINAPI
VariantChangeTypeEx(struct tagVARIANT
* pvargDest
, struct tagVARIANT
* pvargSrc
,
196 LCID lcid
, USHORT wFlags
, VARTYPE vt
);
199 * These flags are used for the VariantChangeType and VariantChangeTypeEx APIs.
203 * This one is of general use.
205 #define VARIANT_NOVALUEPROP 0x1
207 * This one is used for conversions of VT_BOOL to VT_BSTR,
208 * the API will convert to "True"|"False" instead of "-1"|"0".
210 #define VARIANT_ALPHABOOL 0x2
212 * This one is used for conversions to or from a VT_BSTR string,
213 * it passes LOCALE_NOUSEROVERRIDE to the core (low-level) coercion routines.
214 * This means it will use the system default locale settings instead of custom
217 #define VARIANT_NOUSEROVERRIDE 0x4
221 * VARTYPE Coercion API
224 /* Omits the date portion and return only the time value.
226 #define VAR_TIMEVALUEONLY ((DWORD)0x00000001)
227 /* Omits the time portion and return only the date value.
229 #define VAR_DATEVALUEONLY ((DWORD)0x00000002)
232 HRESULT WINAPI
VarUI1FromI2(short sIn
, BYTE
* pbOut
);
233 HRESULT WINAPI
VarUI1FromI4(LONG lIn
, BYTE
* pbOut
);
234 HRESULT WINAPI
VarUI1FromR4(FLOAT fltIn
, BYTE
* pbOut
);
235 HRESULT WINAPI
VarUI1FromR8(double dblIn
, BYTE
* pbOut
);
236 HRESULT WINAPI
VarUI1FromDate(DATE dateIn
, BYTE
* pbOut
);
237 HRESULT WINAPI
VarUI1FromBool(VARIANT_BOOL boolIn
, BYTE
* pbOut
);
238 HRESULT WINAPI
VarUI1FromI1(CHAR cIn
, BYTE
*pbOut
);
239 HRESULT WINAPI
VarUI1FromUI2(USHORT uiIn
, BYTE
*pbOut
);
240 HRESULT WINAPI
VarUI1FromUI4(ULONG ulIn
, BYTE
*pbOut
);
241 HRESULT WINAPI
VarUI1FromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, BYTE
* pbOut
);
242 HRESULT WINAPI
VarUI1FromCy(CY cyIn
, BYTE
* pbOut
);
243 HRESULT WINAPI
VarUI1FromDec(DECIMAL
* pdecIn
, BYTE
* pbOut
);
244 HRESULT WINAPI
VarUI1FromDisp(IDispatch
* pdispIn
, LCID lcid
, BYTE
* pbOut
);
246 HRESULT WINAPI
VarI2FromUI1(BYTE bIn
, short* psOut
);
247 HRESULT WINAPI
VarI2FromI4(LONG lIn
, short* psOut
);
248 HRESULT WINAPI
VarI2FromR4(FLOAT fltIn
, short* psOut
);
249 HRESULT WINAPI
VarI2FromR8(double dblIn
, short* psOut
);
250 HRESULT WINAPI
VarI2FromDate(DATE dateIn
, short* psOut
);
251 HRESULT WINAPI
VarI2FromBool(VARIANT_BOOL boolIn
, short* psOut
);
252 HRESULT WINAPI
VarI2FromI1(CHAR cIn
, short*psOut
);
253 HRESULT WINAPI
VarI2FromUI2(USHORT uiIn
, short*psOut
);
254 HRESULT WINAPI
VarI2FromUI4(ULONG ulIn
, short*psOut
);
255 HRESULT WINAPI
VarI2FromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, short* psOut
);
256 HRESULT WINAPI
VarI2FromCy(CY cyIn
, short* psOut
);
257 HRESULT WINAPI
VarI2FromDec(DECIMAL
* pdecIn
, short* psOut
);
258 HRESULT WINAPI
VarI2FromDisp(IDispatch
* pdispIn
, LCID lcid
, short* psOut
);
260 HRESULT WINAPI
VarI4FromUI1(BYTE bIn
, LONG
* plOut
);
261 HRESULT WINAPI
VarI4FromI2(short sIn
, LONG
* plOut
);
262 HRESULT WINAPI
VarI4FromR4(FLOAT fltIn
, LONG
* plOut
);
263 HRESULT WINAPI
VarI4FromR8(double dblIn
, LONG
* plOut
);
264 HRESULT WINAPI
VarI4FromDate(DATE dateIn
, LONG
* plOut
);
265 HRESULT WINAPI
VarI4FromBool(VARIANT_BOOL boolIn
, LONG
* plOut
);
266 HRESULT WINAPI
VarI4FromI1(CHAR cIn
, LONG
* plOut
);
267 HRESULT WINAPI
VarI4FromUI2(USHORT uiIn
, LONG
*plOut
);
268 HRESULT WINAPI
VarI4FromUI4(ULONG ulIn
, LONG
*plOut
);
269 HRESULT WINAPI
VarI4FromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, LONG
* plOut
);
270 HRESULT WINAPI
VarI4FromCy(CY cyIn
, LONG
* plOut
);
271 HRESULT WINAPI
VarI4FromDec(DECIMAL
* pdecIn
, LONG
* plOut
);
272 HRESULT WINAPI
VarI4FromDisp(IDispatch
* pdispIn
, LCID lcid
, LONG
* plOut
);
274 HRESULT WINAPI
VarR4FromUI1(BYTE bIn
, FLOAT
* pfltOut
);
275 HRESULT WINAPI
VarR4FromI2(short sIn
, FLOAT
* pfltOut
);
276 HRESULT WINAPI
VarR4FromI4(LONG lIn
, FLOAT
* pfltOut
);
277 HRESULT WINAPI
VarR4FromR8(double dblIn
, FLOAT
* pfltOut
);
278 HRESULT WINAPI
VarR4FromDate(DATE dateIn
, FLOAT
* pfltOut
);
279 HRESULT WINAPI
VarR4FromBool(VARIANT_BOOL boolIn
, FLOAT
* pfltOut
);
280 HRESULT WINAPI
VarR4FromI1(CHAR cIn
, FLOAT
*pfltOut
);
281 HRESULT WINAPI
VarR4FromUI2(USHORT uiIn
, FLOAT
*pfltOut
);
282 HRESULT WINAPI
VarR4FromUI4(ULONG ulIn
, FLOAT
*pfltOut
);
283 HRESULT WINAPI
VarR4FromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, FLOAT
*pfltOut
);
284 HRESULT WINAPI
VarR4FromCy(CY cyIn
, FLOAT
* pfltOut
);
285 HRESULT WINAPI
VarR4FromDec(DECIMAL
* pdecIn
, FLOAT
* pfltOut
);
286 HRESULT WINAPI
VarR4FromDisp(IDispatch
* pdispIn
, LCID lcid
, FLOAT
* pfltOut
);
288 HRESULT WINAPI
VarR8FromUI1(BYTE bIn
, double* pdblOut
);
289 HRESULT WINAPI
VarR8FromI2(short sIn
, double* pdblOut
);
290 HRESULT WINAPI
VarR8FromI4(LONG lIn
, double* pdblOut
);
291 HRESULT WINAPI
VarR8FromR4(FLOAT fltIn
, double* pdblOut
);
292 HRESULT WINAPI
VarR8FromDate(DATE dateIn
, double* pdblOut
);
293 HRESULT WINAPI
VarR8FromBool(VARIANT_BOOL boolIn
, double* pdblOut
);
294 HRESULT WINAPI
VarR8FromI1(CHAR cIn
, double*pdblOut
);
295 HRESULT WINAPI
VarR8FromUI2(USHORT uiIn
, double*pdblOut
);
296 HRESULT WINAPI
VarR8FromUI4(ULONG ulIn
, double*pdblOut
);
297 HRESULT WINAPI
VarR8FromStr(OLECHAR
*strIn
, LCID lcid
, ULONG dwFlags
, double*pdblOut
);
298 HRESULT WINAPI
VarR8FromCy(CY cyIn
, double* pdblOut
);
299 HRESULT WINAPI
VarR8FromDec(DECIMAL
* pdecIn
, double* pdblOut
);
300 HRESULT WINAPI
VarR8FromDisp(IDispatch
* pdispIn
, LCID lcid
, double* pdblOut
);
302 HRESULT WINAPI
VarDateFromUI1(BYTE bIn
, DATE
* pdateOut
);
303 HRESULT WINAPI
VarDateFromI2(short sIn
, DATE
* pdateOut
);
304 HRESULT WINAPI
VarDateFromI4(LONG lIn
, DATE
* pdateOut
);
305 HRESULT WINAPI
VarDateFromR4(FLOAT fltIn
, DATE
* pdateOut
);
306 HRESULT WINAPI
VarDateFromR8(double dblIn
, DATE
* pdateOut
);
307 HRESULT WINAPI
VarDateFromStr(OLECHAR
*strIn
, LCID lcid
, ULONG dwFlags
, DATE
*pdateOut
);
308 HRESULT WINAPI
VarDateFromI1(CHAR cIn
, DATE
*pdateOut
);
309 HRESULT WINAPI
VarDateFromUI2(USHORT uiIn
, DATE
*pdateOut
);
310 HRESULT WINAPI
VarDateFromUI4(ULONG ulIn
, DATE
*pdateOut
);
311 HRESULT WINAPI
VarDateFromBool(VARIANT_BOOL boolIn
, DATE
* pdateOut
);
312 HRESULT WINAPI
VarDateFromCy(CY cyIn
, DATE
* pdateOut
);
313 HRESULT WINAPI
VarDateFromDec(DECIMAL
* pdecIn
, DATE
* pdateOut
);
314 HRESULT WINAPI
VarDateFromDisp(IDispatch
* pdispIn
, LCID lcid
, DATE
* pdateOut
);
316 HRESULT WINAPI
VarCyFromUI1(BYTE bIn
, CY
* pcyOut
);
317 HRESULT WINAPI
VarCyFromI2(short sIn
, CY
* pcyOut
);
318 HRESULT WINAPI
VarCyFromI4(LONG lIn
, CY
* pcyOut
);
319 HRESULT WINAPI
VarCyFromR4(FLOAT fltIn
, CY
* pcyOut
);
320 HRESULT WINAPI
VarCyFromR8(double dblIn
, CY
* pcyOut
);
321 HRESULT WINAPI
VarCyFromDate(DATE dateIn
, CY
* pcyOut
);
322 HRESULT WINAPI
VarCyFromStr(OLECHAR
*strIn
, LCID lcid
, ULONG dwFlags
, CY
*pcyOut
);
323 HRESULT WINAPI
VarCyFromBool(VARIANT_BOOL boolIn
, CY
* pcyOut
);
324 HRESULT WINAPI
VarCyFromI1(signed char cIn
, CY
*pcyOut
);
325 HRESULT WINAPI
VarCyFromUI2(USHORT uiIn
, CY
*pcyOut
);
326 HRESULT WINAPI
VarCyFromUI4(ULONG ulIn
, CY
*pcyOut
);
327 HRESULT WINAPI
VarCyFromDec(DECIMAL
*pdecIn
, CY
*pcyOut
);
328 HRESULT WINAPI
VarCyFromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, CY
* pcyOut
);
329 HRESULT WINAPI
VarCyFromDisp(IDispatch
* pdispIn
, LCID lcid
, CY
* pcyOut
);
331 HRESULT WINAPI
VarBstrFromUI1(BYTE bVal
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
332 HRESULT WINAPI
VarBstrFromI2(short iVal
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
333 HRESULT WINAPI
VarBstrFromI4(LONG lIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
334 HRESULT WINAPI
VarBstrFromR4(FLOAT fltIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
335 HRESULT WINAPI
VarBstrFromR8(double dblIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
336 HRESULT WINAPI
VarBstrFromDate(DATE dateIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
337 HRESULT WINAPI
VarBstrFromBool(VARIANT_BOOL boolIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
338 HRESULT WINAPI
VarBstrFromI1(CHAR cIn
, LCID lcid
, ULONG dwFlags
, BSTR
*pbstrOut
);
339 HRESULT WINAPI
VarBstrFromUI2(USHORT uiIn
, LCID lcid
, ULONG dwFlags
, BSTR
*pbstrOut
);
340 HRESULT WINAPI
VarBstrFromUI4(ULONG ulIn
, LCID lcid
, ULONG dwFlags
, BSTR
*pbstrOut
);
341 HRESULT WINAPI
VarBstrFromCy(CY cyIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
342 HRESULT WINAPI
VarBstrFromDec(DECIMAL
* pdecIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
343 HRESULT WINAPI
VarBstrFromDisp(IDispatch
* pdispIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
345 HRESULT WINAPI
VarBoolFromUI1(BYTE bIn
, VARIANT_BOOL
* pboolOut
);
346 HRESULT WINAPI
VarBoolFromI2(short sIn
, VARIANT_BOOL
* pboolOut
);
347 HRESULT WINAPI
VarBoolFromI4(LONG lIn
, VARIANT_BOOL
* pboolOut
);
348 HRESULT WINAPI
VarBoolFromR4(FLOAT fltIn
, VARIANT_BOOL
* pboolOut
);
349 HRESULT WINAPI
VarBoolFromR8(double dblIn
, VARIANT_BOOL
* pboolOut
);
350 HRESULT WINAPI
VarBoolFromDate(DATE dateIn
, VARIANT_BOOL
* pboolOut
);
351 HRESULT WINAPI
VarBoolFromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, VARIANT_BOOL
* pboolOut
);
352 HRESULT WINAPI
VarBoolFromI1(CHAR cIn
, VARIANT_BOOL
*pboolOut
);
353 HRESULT WINAPI
VarBoolFromUI2(USHORT uiIn
, VARIANT_BOOL
*pboolOut
);
354 HRESULT WINAPI
VarBoolFromUI4(ULONG ulIn
, VARIANT_BOOL
*pboolOut
);
355 HRESULT WINAPI
VarBoolFromCy(CY cyIn
, VARIANT_BOOL
* pboolOut
);
356 HRESULT WINAPI
VarBoolFromDec(DECIMAL
* pdecIn
, VARIANT_BOOL
* pboolOut
);
357 HRESULT WINAPI
VarBoolFromDisp(IDispatch
* pdispIn
, LCID lcid
, VARIANT_BOOL
* pboolOut
);
359 HRESULT WINAPI
VarI1FromUI1(BYTE bIn
, CHAR
*pcOut
);
360 HRESULT WINAPI
VarI1FromI2(short uiIn
, CHAR
*pcOut
);
361 HRESULT WINAPI
VarI1FromI4(LONG lIn
, CHAR
*pcOut
);
362 HRESULT WINAPI
VarI1FromR4(FLOAT fltIn
, CHAR
*pcOut
);
363 HRESULT WINAPI
VarI1FromR8(double dblIn
, CHAR
*pcOut
);
364 HRESULT WINAPI
VarI1FromDate(DATE dateIn
, CHAR
*pcOut
);
365 HRESULT WINAPI
VarI1FromStr(OLECHAR
*strIn
, LCID lcid
, ULONG dwFlags
, CHAR
*pcOut
);
366 HRESULT WINAPI
VarI1FromBool(VARIANT_BOOL boolIn
, CHAR
*pcOut
);
367 HRESULT WINAPI
VarI1FromUI2(USHORT uiIn
, CHAR
*pcOut
);
368 HRESULT WINAPI
VarI1FromUI4(ULONG ulIn
, CHAR
*pcOut
);
369 HRESULT WINAPI
VarI1FromCy(CY cyIn
, CHAR
*pcOut
);
370 HRESULT WINAPI
VarI1FromDec(DECIMAL
* pdecIn
, CHAR
* pcOut
);
371 HRESULT WINAPI
VarI1FromDisp(IDispatch
* pdispIn
, LCID lcid
, CHAR
* pcOut
);
373 HRESULT WINAPI
VarUI2FromUI1(BYTE bIn
, USHORT
*puiOut
);
374 HRESULT WINAPI
VarUI2FromI2(short uiIn
, USHORT
*puiOut
);
375 HRESULT WINAPI
VarUI2FromI4(LONG lIn
, USHORT
*puiOut
);
376 HRESULT WINAPI
VarUI2FromR4(FLOAT fltIn
, USHORT
*puiOut
);
377 HRESULT WINAPI
VarUI2FromR8(double dblIn
, USHORT
*puiOut
);
378 HRESULT WINAPI
VarUI2FromDate(DATE dateIn
, USHORT
*puiOut
);
379 HRESULT WINAPI
VarUI2FromStr(OLECHAR
*strIn
, LCID lcid
, ULONG dwFlags
, USHORT
*puiOut
);
380 HRESULT WINAPI
VarUI2FromBool(VARIANT_BOOL boolIn
, USHORT
*puiOut
);
381 HRESULT WINAPI
VarUI2FromI1(CHAR cIn
, USHORT
*puiOut
);
382 HRESULT WINAPI
VarUI2FromUI4(ULONG ulIn
, USHORT
*puiOut
);
383 HRESULT WINAPI
VarUI2FromCy(CY cyIn
, USHORT
*puiOut
);
384 HRESULT WINAPI
VarUI2FromDec(DECIMAL
* pdecIn
, USHORT
* puiOut
);
385 HRESULT WINAPI
VarUI2FromDisp(IDispatch
* pdispIn
, LCID lcid
, USHORT
* puiOut
);
387 HRESULT WINAPI
VarUI4FromStr(OLECHAR
*strIn
, LCID lcid
, ULONG dwFlags
, ULONG
*pulOut
);
388 HRESULT WINAPI
VarUI4FromUI1(BYTE bIn
, ULONG
*pulOut
);
389 HRESULT WINAPI
VarUI4FromI2(short uiIn
, ULONG
*pulOut
);
390 HRESULT WINAPI
VarUI4FromI4(LONG lIn
, ULONG
*pulOut
);
391 HRESULT WINAPI
VarUI4FromR4(FLOAT fltIn
, ULONG
*pulOut
);
392 HRESULT WINAPI
VarUI4FromR8(double dblIn
, ULONG
*pulOut
);
393 HRESULT WINAPI
VarUI4FromDate(DATE dateIn
, ULONG
*pulOut
);
394 HRESULT WINAPI
VarUI4FromBool(VARIANT_BOOL boolIn
, ULONG
*pulOut
);
395 HRESULT WINAPI
VarUI4FromI1(CHAR cIn
, ULONG
*pulOut
);
396 HRESULT WINAPI
VarUI4FromUI2(USHORT uiIn
, ULONG
*pulOut
);
397 HRESULT WINAPI
VarUI4FromCy(CY cyIn
, ULONG
*pulOut
);
398 HRESULT WINAPI
VarUI4FromDec(DECIMAL
* pdecIn
, ULONG
* pulOut
);
399 HRESULT WINAPI
VarUI4FromDisp(IDispatch
* pdispIn
, LCID lcid
, ULONG
* pulOut
);
401 HRESULT WINAPI
VarDecFromUI1(BYTE bIn
, DECIMAL
*pdecOut
);
402 HRESULT WINAPI
VarDecFromI2(short uiIn
, DECIMAL
*pdecOut
);
403 HRESULT WINAPI
VarDecFromI4(LONG lIn
, DECIMAL
*pdecOut
);
404 HRESULT WINAPI
VarDecFromR4(FLOAT fltIn
, DECIMAL
*pdecOut
);
405 HRESULT WINAPI
VarDecFromR8(double dblIn
, DECIMAL
*pdecOut
);
406 HRESULT WINAPI
VarDecFromDate(DATE dateIn
, DECIMAL
*pdecOut
);
407 HRESULT WINAPI
VarDecFromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, DECIMAL
* pdecOut
);
408 HRESULT WINAPI
VarDecFromBool(VARIANT_BOOL boolIn
, DECIMAL
* pdecOut
);
409 HRESULT WINAPI
VarDecFromI1(CHAR cIn
, DECIMAL
* pdecOut
);
410 HRESULT WINAPI
VarDecFromUI2(USHORT uiIn
, DECIMAL
* pdecOut
);
411 HRESULT WINAPI
VarDecFromUI4(ULONG ulIn
, DECIMAL
* pdecOut
);
412 HRESULT WINAPI
VarDecFromCy(CY cyIn
, DECIMAL
* pdecOut
);
413 HRESULT WINAPI
VarDecFromDisp(IDispatch
* pdispIn
, LCID lcid
, DECIMAL
* pdecOut
);
417 #define VarUI4FromUI4( in, pOut ) ( *(pOut) = (in) )
418 #define VarI4FromI4( in, pOut ) ( *(pOut) = (in) )
420 #define VarUI1FromInt VarUI1FromI4
421 #define VarUI1FromUint VarUI1FromUI4
422 #define VarI2FromInt VarI2FromI4
423 #define VarI2FromUint VarI2FromUI4
424 #define VarI4FromInt VarI4FromI4
425 #define VarI4FromUint VarI4FromUI4
426 #define VarR4FromInt VarR4FromI4
427 #define VarR4FromUint VarR4FromUI4
428 #define VarR8FromInt VarR8FromI4
429 #define VarR8FromUint VarR8FromUI4
430 #define VarDateFromInt VarDateFromI4
431 #define VarDateFromUint VarDateFromUI4
432 #define VarCyFromInt VarCyFromI4
433 #define VarCyFromUint VarCyFromUI4
434 #define VarBstrFromInt VarBstrFromI4
435 #define VarBstrFromUint VarBstrFromUI4
436 #define VarBoolFromInt VarBoolFromI4
437 #define VarBoolFromUint VarBoolFromUI4
438 #define VarI1FromInt VarI1FromI4
439 #define VarI1FromUint VarI1FromUI4
440 #define VarUI2FromInt VarUI2FromI4
441 #define VarUI2FromUint VarUI2FromUI4
442 #define VarUI4FromInt VarUI4FromI4
443 #define VarUI4FromUint VarUI4FromUI4
444 #define VarDecFromInt VarDecFromI4
445 #define VarDecFromUint VarDecFromUI4
446 #define VarIntFromUI1 VarI4FromUI1
447 #define VarIntFromI2 VarI4FromI2
448 #define VarIntFromI4 VarI4FromI4
449 #define VarIntFromR4 VarI4FromR4
450 #define VarIntFromR8 VarI4FromR8
451 #define VarIntFromDate VarI4FromDate
452 #define VarIntFromCy VarI4FromCy
453 #define VarIntFromStr VarI4FromStr
454 #define VarIntFromDisp VarI4FromDisp
455 #define VarIntFromBool VarI4FromBool
456 #define VarIntFromI1 VarI4FromI1
457 #define VarIntFromUI2 VarI4FromUI2
458 #define VarIntFromUI4 VarI4FromUI4
459 #define VarIntFromDec VarI4FromDec
460 #define VarIntFromUint VarI4FromUI4
461 #define VarUintFromUI1 VarUI4FromUI1
462 #define VarUintFromI2 VarUI4FromI2
463 #define VarUintFromI4 VarUI4FromI4
464 #define VarUintFromR4 VarUI4FromR4
465 #define VarUintFromR8 VarUI4FromR8
466 #define VarUintFromDate VarUI4FromDate
467 #define VarUintFromCy VarUI4FromCy
468 #define VarUintFromStr VarUI4FromStr
469 #define VarUintFromDisp VarUI4FromDisp
470 #define VarUintFromBool VarUI4FromBool
471 #define VarUintFromI1 VarUI4FromI1
472 #define VarUintFromUI2 VarUI4FromUI2
473 #define VarUintFromUI4 VarUI4FromUI4
474 #define VarUintFromDec VarUI4FromDec
475 #define VarUintFromInt VarUI4FromI4
478 * Variant Math operations
483 #define VARCMP_NULL 3
485 HRESULT WINAPI
VarAdd(LPVARIANT
,LPVARIANT
,LPVARIANT
);
486 HRESULT WINAPI
VarAnd(LPVARIANT
,LPVARIANT
,LPVARIANT
);
487 HRESULT WINAPI
VarCat(LPVARIANT
,LPVARIANT
,LPVARIANT
);
488 HRESULT WINAPI
VarDiv(LPVARIANT
,LPVARIANT
,LPVARIANT
);
489 HRESULT WINAPI
VarEqv(LPVARIANT
,LPVARIANT
,LPVARIANT
);
490 HRESULT WINAPI
VarIdiv(LPVARIANT
,LPVARIANT
,LPVARIANT
);
491 HRESULT WINAPI
VarImp(LPVARIANT
,LPVARIANT
,LPVARIANT
);
492 HRESULT WINAPI
VarMod(LPVARIANT
,LPVARIANT
,LPVARIANT
);
493 HRESULT WINAPI
VarMul(LPVARIANT
,LPVARIANT
,LPVARIANT
);
494 HRESULT WINAPI
VarOr(LPVARIANT
,LPVARIANT
,LPVARIANT
);
495 HRESULT WINAPI
VarPow(LPVARIANT
,LPVARIANT
,LPVARIANT
);
496 HRESULT WINAPI
VarSub(LPVARIANT
,LPVARIANT
,LPVARIANT
);
497 HRESULT WINAPI
VarXor(LPVARIANT
,LPVARIANT
,LPVARIANT
);
499 HRESULT WINAPI
VarAbs(LPVARIANT
,LPVARIANT
);
500 HRESULT WINAPI
VarFix(LPVARIANT
,LPVARIANT
);
501 HRESULT WINAPI
VarInt(LPVARIANT
,LPVARIANT
);
502 HRESULT WINAPI
VarNeg(LPVARIANT
,LPVARIANT
);
503 HRESULT WINAPI
VarNot(LPVARIANT
,LPVARIANT
);
505 HRESULT WINAPI
VarRound(LPVARIANT
,int,LPVARIANT
);
507 HRESULT WINAPI
VarCmp(LPVARIANT
,LPVARIANT
,LCID
,ULONG
);
511 typedef struct tagPARAMDATA
{
512 OLECHAR
* szName
; /* parameter name */
513 VARTYPE vt
; /* parameter type */
514 } PARAMDATA
, * LPPARAMDATA
;
516 typedef struct tagMETHODDATA
{
517 OLECHAR
* szName
; /* method name */
518 PARAMDATA
* ppdata
; /* pointer to an array of PARAMDATAs */
519 DISPID dispid
; /* method ID */
520 UINT iMeth
; /* method index */
521 CALLCONV cc
; /* calling convention */
522 UINT cArgs
; /* count of arguments */
523 WORD wFlags
; /* same wFlags as on IDispatch::Invoke() */
525 } METHODDATA
, * LPMETHODDATA
;
527 typedef struct tagINTERFACEDATA
{
528 METHODDATA
* pmethdata
; /* pointer to an array of METHODDATAs */
529 UINT cMembers
; /* count of members */
530 } INTERFACEDATA
, * LPINTERFACEDATA
;
532 typedef enum tagREGKIND
553 #define NUMPRS_LEADING_WHITE 0x0001
554 #define NUMPRS_TRAILING_WHITE 0x0002
555 #define NUMPRS_LEADING_PLUS 0x0004
556 #define NUMPRS_TRAILING_PLUS 0x0008
557 #define NUMPRS_LEADING_MINUS 0x0010
558 #define NUMPRS_TRAILING_MINUS 0x0020
559 #define NUMPRS_HEX_OCT 0x0040
560 #define NUMPRS_PARENS 0x0080
561 #define NUMPRS_DECIMAL 0x0100
562 #define NUMPRS_THOUSANDS 0x0200
563 #define NUMPRS_CURRENCY 0x0400
564 #define NUMPRS_EXPONENT 0x0800
565 #define NUMPRS_USE_ALL 0x1000
566 #define NUMPRS_STD 0x1FFF
568 #define NUMPRS_NEG 0x10000
569 #define NUMPRS_INEXACT 0x20000
571 #define VTBIT_I1 (1 << VT_I1)
572 #define VTBIT_UI1 (1 << VT_UI1)
573 #define VTBIT_I2 (1 << VT_I2)
574 #define VTBIT_UI2 (1 << VT_UI2)
575 #define VTBIT_I4 (1 << VT_I4)
576 #define VTBIT_UI4 (1 << VT_UI4)
577 #define VTBIT_R4 (1 << VT_R4)
578 #define VTBIT_R8 (1 << VT_R8)
579 #define VTBIT_CY (1 << VT_CY)
580 #define VTBIT_DECIMAL (1 << VT_DECIMAL)
582 HRESULT WINAPI
VarParseNumFromStr(OLECHAR
*,LCID
,ULONG
,NUMPARSE
*,BYTE
*);
583 HRESULT WINAPI
VarNumFromParseNum(NUMPARSE
*,BYTE
*,ULONG
,VARIANT
*);
585 INT WINAPI
DosDateTimeToVariantTime(USHORT
,USHORT
,DATE
*);
586 INT WINAPI
VariantTimeToDosDateTime(DATE
, USHORT
*, USHORT
*);
588 HRESULT WINAPI
VariantTimeToSystemTime(double,LPSYSTEMTIME
);
589 HRESULT WINAPI
SystemTimeToVariantTime(LPSYSTEMTIME
,double*);
591 HRESULT WINAPI
VarDateFromUdate(UDATE
*,ULONG
, DATE
*);
592 HRESULT WINAPI
VarUdateFromDate(DATE
, ULONG
, UDATE
*);
594 ULONG WINAPI
LHashValOfNameSysA(SYSKIND syskind
,LCID lcid
,LPCSTR szName
);
595 ULONG WINAPI
LHashValOfNameSys (SYSKIND syskind
,LCID lcid
,LPCOLESTR szName
);
597 HRESULT WINAPI
DispGetParam(DISPPARAMS
* pdispparams
, UINT position
,
598 VARTYPE vtTarg
, VARIANT
* pvarResult
, UINT
* puArgErr
);
599 HRESULT WINAPI
DispGetIDsOfNames(ITypeInfo
* ptinfo
, OLECHAR
** rgszNames
,
600 UINT cNames
, DISPID
* rgdispid
);
601 HRESULT WINAPI
DispInvoke(void* _this
, ITypeInfo
* ptinfo
, DISPID dispidMember
,
602 WORD wFlags
, DISPPARAMS
* pparams
, VARIANT
* pvarResult
,
603 EXCEPINFO
* pexcepinfo
, UINT
* puArgErr
);
604 HRESULT WINAPI
CreateDispTypeInfo(INTERFACEDATA
* pidata
, LCID lcid
,
605 ITypeInfo
** pptinfo
);
606 HRESULT WINAPI
CreateStdDispatch(IUnknown
* punkOuter
, void* pvThis
,
607 ITypeInfo
* ptinfo
, IUnknown
** ppunkStdDisp
);
608 HRESULT WINAPI
DispCallFunc(void* pvInstance
, ULONG oVft
, CALLCONV cc
,
609 VARTYPE vtReturn
, UINT cActuals
, VARTYPE
* prgvt
,
610 VARIANTARG
** prgpvarg
, VARIANT
* pvargResult
);
617 HRESULT WINAPI
CreateTypeLib(SYSKIND
,const OLECHAR
*,ICreateTypeLib
**);
618 HRESULT WINAPI
CreateTypeLib2(SYSKIND
,LPCOLESTR
,ICreateTypeLib2
**);
619 HRESULT WINAPI
LoadRegTypeLib(REFGUID
,WORD
,WORD
,LCID
,ITypeLib
**);
620 HRESULT WINAPI
LoadTypeLib(const OLECHAR
*,ITypeLib
**);
621 HRESULT WINAPI
LoadTypeLibEx(LPCOLESTR
,REGKIND
,ITypeLib
**);
622 HRESULT WINAPI
QueryPathOfRegTypeLib(REFGUID
,WORD
,WORD
,LCID
,LPBSTR
);
623 HRESULT WINAPI
RegisterTypeLib(ITypeLib
*,OLECHAR
*,OLECHAR
*);
624 HRESULT WINAPI
UnRegisterTypeLib(REFGUID
,WORD
,WORD
,LCID
,SYSKIND
);
631 #endif /*__WINE_OLEAUTO_H*/