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 SafeArrayAllocDescriptorEx(VARTYPE vt
,UINT cDims
,struct tagSAFEARRAY
**ppsaOut
);
68 SafeArrayAllocData(struct tagSAFEARRAY
*psa
);
70 struct tagSAFEARRAY
* WINAPI
71 SafeArrayCreate(VARTYPE vt
, UINT cDims
, struct tagSAFEARRAYBOUND
*rgsabound
);
74 SafeArrayDestroyDescriptor(struct tagSAFEARRAY
*psa
);
77 SafeArrayPutElement(struct tagSAFEARRAY
*psa
, LONG
*rgIndices
, void *pv
);
80 SafeArrayGetElement(struct tagSAFEARRAY
*psa
, LONG
*rgIndices
, void *pv
);
83 SafeArrayLock(struct tagSAFEARRAY
*psa
);
86 SafeArrayUnlock(struct tagSAFEARRAY
*psa
);
89 SafeArrayGetUBound(struct tagSAFEARRAY
*psa
, UINT nDim
, LONG
*plUbound
);
92 SafeArrayGetLBound(struct tagSAFEARRAY
*psa
, UINT nDim
, LONG
*plLbound
);
95 SafeArrayGetDim(struct tagSAFEARRAY
*psa
);
98 SafeArrayGetElemsize(struct tagSAFEARRAY
*psa
);
101 SafeArrayAccessData(struct tagSAFEARRAY
*psa
, void **ppvData
);
104 SafeArrayUnaccessData(struct tagSAFEARRAY
*psa
);
107 SafeArrayPtrOfIndex(struct tagSAFEARRAY
*psa
, LONG
*rgIndices
, void **ppvData
);
110 SafeArrayCopyData(struct tagSAFEARRAY
*psaSource
, struct tagSAFEARRAY
*psaTarget
);
113 SafeArrayDestroyData(struct tagSAFEARRAY
*psa
);
116 SafeArrayDestroy(struct tagSAFEARRAY
*psa
);
119 SafeArrayCopy(struct tagSAFEARRAY
*psa
, struct tagSAFEARRAY
**ppsaOut
);
121 struct tagSAFEARRAY
* WINAPI
122 SafeArrayCreateVector(VARTYPE vt
, LONG lLbound
, ULONG cElements
);
125 SafeArrayRedim(struct tagSAFEARRAY
*psa
, struct tagSAFEARRAYBOUND
*psaboundNew
);
128 SafeArraySetIID(struct tagSAFEARRAY
*psa
, REFGUID riid
);
131 SafeArrayGetIID(struct tagSAFEARRAY
*psa
, GUID
*riid
);
134 SafeArrayGetVartype(struct tagSAFEARRAY
*psa
, VARTYPE
*vt
);
137 SafeArrayGetRecordInfo(struct tagSAFEARRAY
*psa
, IRecordInfo
**recordinfo
);
140 SafeArraySetRecordInfo(struct tagSAFEARRAY
*psa
, IRecordInfo
*recordinfo
);
143 /* These are macros that help accessing the VARIANT date type.
145 #if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION)
146 #define V_UNION(A, B) ((A)->n1.n2.n3.B)
147 #define V_VT(A) ((A)->n1.n2.vt)
149 #define V_UNION(A, B) ((A)->B)
150 #define V_VT(A) ((A)->vt)
151 #endif /* cplusplus */
153 #define V_ISBYREF(A) (V_VT(A)&VT_BYREF)
154 #define V_ISARRAY(A) (V_VT(A)&VT_ARRAY)
155 #define V_ISVECTOR(A) (V_VT(A)&VT_VECTOR)
156 #define V_NONE(A) V_I2(A)
158 #define V_UI1(A) V_UNION(A, bVal)
159 #define V_UI1REF(A) V_UNION(A, pbVal)
160 #define V_I2(A) V_UNION(A, iVal)
161 #define V_I2REF(A) V_UNION(A, piVal)
162 #define V_I4(A) V_UNION(A, lVal)
163 #define V_I4REF(A) V_UNION(A, plVal)
164 #define V_R4(A) V_UNION(A, fltVal)
165 #define V_R4REF(A) V_UNION(A, pfltVal)
166 #define V_R8(A) V_UNION(A, dblVal)
167 #define V_R8REF(A) V_UNION(A, pdblVal)
168 #define V_I1(A) V_UNION(A, cVal)
169 #define V_I1REF(A) V_UNION(A, pcVal)
170 #define V_UI2(A) V_UNION(A, uiVal)
171 #define V_UI2REF(A) V_UNION(A, puiVal)
172 #define V_UI4(A) V_UNION(A, ulVal)
173 #define V_UI4REF(A) V_UNION(A, pulVal)
174 #define V_INT(A) V_UNION(A, intVal)
175 #define V_INTREF(A) V_UNION(A, pintVal)
176 #define V_UINT(A) V_UNION(A, uintVal)
177 #define V_UINTREF(A) V_UNION(A, puintVal)
178 #define V_CY(A) V_UNION(A, cyVal)
179 #define V_CYREF(A) V_UNION(A, pcyVal)
180 #define V_DATE(A) V_UNION(A, date)
181 #define V_DATEREF(A) V_UNION(A, pdate)
182 #define V_BSTR(A) V_UNION(A, bstrVal)
183 #define V_BSTRREF(A) V_UNION(A, pbstrVal)
184 #define V_DISPATCH(A) V_UNION(A, pdispVal)
185 #define V_DISPATCHREF(A) V_UNION(A, ppdispVal)
186 #define V_ERROR(A) V_UNION(A, scode)
187 #define V_ERRORREF(A) V_UNION(A, pscode)
188 #define V_BOOL(A) V_UNION(A, boolVal)
189 #define V_BOOLREF(A) V_UNION(A, pboolVal)
190 #define V_UNKNOWN(A) V_UNION(A, punkVal)
191 #define V_UNKNOWNREF(A) V_UNION(A, ppunkVal)
192 #define V_VARIANTREF(A) V_UNION(A, pvarVal)
193 #define V_ARRAY(A) V_UNION(A, parray)
194 #define V_ARRAYREF(A) V_UNION(A, pparray)
195 #define V_BYREF(A) V_UNION(A, byref)
196 #define V_DECIMALREF(A) V_UNION(A, pdecVal)
197 #if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION)
198 #define V_DECIMAL(A) ((A)->n1.decVal)
200 #define V_DECIMAL(A) ((A)->decVal)
207 void WINAPI
VariantInit(struct tagVARIANT
* pvarg
);
208 HRESULT WINAPI
VariantClear(struct tagVARIANT
* pvarg
);
209 HRESULT WINAPI
VariantCopy(struct tagVARIANT
* pvargDest
, struct tagVARIANT
* pvargSrc
);
210 HRESULT WINAPI
VariantCopyInd(struct tagVARIANT
* pvargDest
, struct tagVARIANT
* pvargSrc
);
211 HRESULT WINAPI
VariantChangeType(struct tagVARIANT
* pvargDest
, struct tagVARIANT
* pvargSrc
,
212 USHORT wFlags
, VARTYPE vt
);
213 HRESULT WINAPI
VariantChangeTypeEx(struct tagVARIANT
* pvargDest
, struct tagVARIANT
* pvargSrc
,
214 LCID lcid
, USHORT wFlags
, VARTYPE vt
);
217 * These flags are used for the VariantChangeType and VariantChangeTypeEx APIs.
221 * This one is of general use.
223 #define VARIANT_NOVALUEPROP 0x1
225 * This one is used for conversions of VT_BOOL to VT_BSTR,
226 * the API will convert to "True"|"False" instead of "-1"|"0".
228 #define VARIANT_ALPHABOOL 0x2
230 * This one is used for conversions to or from a VT_BSTR string,
231 * it passes LOCALE_NOUSEROVERRIDE to the core (low-level) coercion routines.
232 * This means it will use the system default locale settings instead of custom
235 #define VARIANT_NOUSEROVERRIDE 0x4
239 * VARTYPE Coercion API
242 /* Omits the date portion and return only the time value.
244 #define VAR_TIMEVALUEONLY ((DWORD)0x00000001)
245 /* Omits the time portion and return only the date value.
247 #define VAR_DATEVALUEONLY ((DWORD)0x00000002)
250 HRESULT WINAPI
VarUI1FromI2(short sIn
, BYTE
* pbOut
);
251 HRESULT WINAPI
VarUI1FromI4(LONG lIn
, BYTE
* pbOut
);
252 HRESULT WINAPI
VarUI1FromR4(FLOAT fltIn
, BYTE
* pbOut
);
253 HRESULT WINAPI
VarUI1FromR8(double dblIn
, BYTE
* pbOut
);
254 HRESULT WINAPI
VarUI1FromDate(DATE dateIn
, BYTE
* pbOut
);
255 HRESULT WINAPI
VarUI1FromBool(VARIANT_BOOL boolIn
, BYTE
* pbOut
);
256 HRESULT WINAPI
VarUI1FromI1(CHAR cIn
, BYTE
*pbOut
);
257 HRESULT WINAPI
VarUI1FromUI2(USHORT uiIn
, BYTE
*pbOut
);
258 HRESULT WINAPI
VarUI1FromUI4(ULONG ulIn
, BYTE
*pbOut
);
259 HRESULT WINAPI
VarUI1FromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, BYTE
* pbOut
);
260 HRESULT WINAPI
VarUI1FromCy(CY cyIn
, BYTE
* pbOut
);
261 HRESULT WINAPI
VarUI1FromDec(DECIMAL
* pdecIn
, BYTE
* pbOut
);
262 HRESULT WINAPI
VarUI1FromDisp(IDispatch
* pdispIn
, LCID lcid
, BYTE
* pbOut
);
264 HRESULT WINAPI
VarI2FromUI1(BYTE bIn
, short* psOut
);
265 HRESULT WINAPI
VarI2FromI4(LONG lIn
, short* psOut
);
266 HRESULT WINAPI
VarI2FromR4(FLOAT fltIn
, short* psOut
);
267 HRESULT WINAPI
VarI2FromR8(double dblIn
, short* psOut
);
268 HRESULT WINAPI
VarI2FromDate(DATE dateIn
, short* psOut
);
269 HRESULT WINAPI
VarI2FromBool(VARIANT_BOOL boolIn
, short* psOut
);
270 HRESULT WINAPI
VarI2FromI1(CHAR cIn
, short*psOut
);
271 HRESULT WINAPI
VarI2FromUI2(USHORT uiIn
, short*psOut
);
272 HRESULT WINAPI
VarI2FromUI4(ULONG ulIn
, short*psOut
);
273 HRESULT WINAPI
VarI2FromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, short* psOut
);
274 HRESULT WINAPI
VarI2FromCy(CY cyIn
, short* psOut
);
275 HRESULT WINAPI
VarI2FromDec(DECIMAL
* pdecIn
, short* psOut
);
276 HRESULT WINAPI
VarI2FromDisp(IDispatch
* pdispIn
, LCID lcid
, short* psOut
);
278 HRESULT WINAPI
VarI4FromUI1(BYTE bIn
, LONG
* plOut
);
279 HRESULT WINAPI
VarI4FromI2(short sIn
, LONG
* plOut
);
280 HRESULT WINAPI
VarI4FromR4(FLOAT fltIn
, LONG
* plOut
);
281 HRESULT WINAPI
VarI4FromR8(double dblIn
, LONG
* plOut
);
282 HRESULT WINAPI
VarI4FromDate(DATE dateIn
, LONG
* plOut
);
283 HRESULT WINAPI
VarI4FromBool(VARIANT_BOOL boolIn
, LONG
* plOut
);
284 HRESULT WINAPI
VarI4FromI1(CHAR cIn
, LONG
* plOut
);
285 HRESULT WINAPI
VarI4FromUI2(USHORT uiIn
, LONG
*plOut
);
286 HRESULT WINAPI
VarI4FromUI4(ULONG ulIn
, LONG
*plOut
);
287 HRESULT WINAPI
VarI4FromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, LONG
* plOut
);
288 HRESULT WINAPI
VarI4FromCy(CY cyIn
, LONG
* plOut
);
289 HRESULT WINAPI
VarI4FromDec(DECIMAL
* pdecIn
, LONG
* plOut
);
290 HRESULT WINAPI
VarI4FromDisp(IDispatch
* pdispIn
, LCID lcid
, LONG
* plOut
);
292 HRESULT WINAPI
VarR4FromUI1(BYTE bIn
, FLOAT
* pfltOut
);
293 HRESULT WINAPI
VarR4FromI2(short sIn
, FLOAT
* pfltOut
);
294 HRESULT WINAPI
VarR4FromI4(LONG lIn
, FLOAT
* pfltOut
);
295 HRESULT WINAPI
VarR4FromR8(double dblIn
, FLOAT
* pfltOut
);
296 HRESULT WINAPI
VarR4FromDate(DATE dateIn
, FLOAT
* pfltOut
);
297 HRESULT WINAPI
VarR4FromBool(VARIANT_BOOL boolIn
, FLOAT
* pfltOut
);
298 HRESULT WINAPI
VarR4FromI1(CHAR cIn
, FLOAT
*pfltOut
);
299 HRESULT WINAPI
VarR4FromUI2(USHORT uiIn
, FLOAT
*pfltOut
);
300 HRESULT WINAPI
VarR4FromUI4(ULONG ulIn
, FLOAT
*pfltOut
);
301 HRESULT WINAPI
VarR4FromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, FLOAT
*pfltOut
);
302 HRESULT WINAPI
VarR4FromCy(CY cyIn
, FLOAT
* pfltOut
);
303 HRESULT WINAPI
VarR4FromDec(DECIMAL
* pdecIn
, FLOAT
* pfltOut
);
304 HRESULT WINAPI
VarR4FromDisp(IDispatch
* pdispIn
, LCID lcid
, FLOAT
* pfltOut
);
306 HRESULT WINAPI
VarR8FromUI1(BYTE bIn
, double* pdblOut
);
307 HRESULT WINAPI
VarR8FromI2(short sIn
, double* pdblOut
);
308 HRESULT WINAPI
VarR8FromI4(LONG lIn
, double* pdblOut
);
309 HRESULT WINAPI
VarR8FromR4(FLOAT fltIn
, double* pdblOut
);
310 HRESULT WINAPI
VarR8FromDate(DATE dateIn
, double* pdblOut
);
311 HRESULT WINAPI
VarR8FromBool(VARIANT_BOOL boolIn
, double* pdblOut
);
312 HRESULT WINAPI
VarR8FromI1(CHAR cIn
, double*pdblOut
);
313 HRESULT WINAPI
VarR8FromUI2(USHORT uiIn
, double*pdblOut
);
314 HRESULT WINAPI
VarR8FromUI4(ULONG ulIn
, double*pdblOut
);
315 HRESULT WINAPI
VarR8FromStr(OLECHAR
*strIn
, LCID lcid
, ULONG dwFlags
, double*pdblOut
);
316 HRESULT WINAPI
VarR8FromCy(CY cyIn
, double* pdblOut
);
317 HRESULT WINAPI
VarR8FromDec(DECIMAL
* pdecIn
, double* pdblOut
);
318 HRESULT WINAPI
VarR8FromDisp(IDispatch
* pdispIn
, LCID lcid
, double* pdblOut
);
320 HRESULT WINAPI
VarDateFromUI1(BYTE bIn
, DATE
* pdateOut
);
321 HRESULT WINAPI
VarDateFromI2(short sIn
, DATE
* pdateOut
);
322 HRESULT WINAPI
VarDateFromI4(LONG lIn
, DATE
* pdateOut
);
323 HRESULT WINAPI
VarDateFromR4(FLOAT fltIn
, DATE
* pdateOut
);
324 HRESULT WINAPI
VarDateFromR8(double dblIn
, DATE
* pdateOut
);
325 HRESULT WINAPI
VarDateFromStr(OLECHAR
*strIn
, LCID lcid
, ULONG dwFlags
, DATE
*pdateOut
);
326 HRESULT WINAPI
VarDateFromI1(CHAR cIn
, DATE
*pdateOut
);
327 HRESULT WINAPI
VarDateFromUI2(USHORT uiIn
, DATE
*pdateOut
);
328 HRESULT WINAPI
VarDateFromUI4(ULONG ulIn
, DATE
*pdateOut
);
329 HRESULT WINAPI
VarDateFromBool(VARIANT_BOOL boolIn
, DATE
* pdateOut
);
330 HRESULT WINAPI
VarDateFromCy(CY cyIn
, DATE
* pdateOut
);
331 HRESULT WINAPI
VarDateFromDec(DECIMAL
* pdecIn
, DATE
* pdateOut
);
332 HRESULT WINAPI
VarDateFromDisp(IDispatch
* pdispIn
, LCID lcid
, DATE
* pdateOut
);
334 HRESULT WINAPI
VarCyFromUI1(BYTE bIn
, CY
* pcyOut
);
335 HRESULT WINAPI
VarCyFromI2(short sIn
, CY
* pcyOut
);
336 HRESULT WINAPI
VarCyFromI4(LONG lIn
, CY
* pcyOut
);
337 HRESULT WINAPI
VarCyFromR4(FLOAT fltIn
, CY
* pcyOut
);
338 HRESULT WINAPI
VarCyFromR8(double dblIn
, CY
* pcyOut
);
339 HRESULT WINAPI
VarCyFromDate(DATE dateIn
, CY
* pcyOut
);
340 HRESULT WINAPI
VarCyFromStr(OLECHAR
*strIn
, LCID lcid
, ULONG dwFlags
, CY
*pcyOut
);
341 HRESULT WINAPI
VarCyFromBool(VARIANT_BOOL boolIn
, CY
* pcyOut
);
342 HRESULT WINAPI
VarCyFromI1(signed char cIn
, CY
*pcyOut
);
343 HRESULT WINAPI
VarCyFromUI2(USHORT uiIn
, CY
*pcyOut
);
344 HRESULT WINAPI
VarCyFromUI4(ULONG ulIn
, CY
*pcyOut
);
345 HRESULT WINAPI
VarCyFromDec(DECIMAL
*pdecIn
, CY
*pcyOut
);
346 HRESULT WINAPI
VarCyFromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, CY
* pcyOut
);
347 HRESULT WINAPI
VarCyFromDisp(IDispatch
* pdispIn
, LCID lcid
, CY
* pcyOut
);
349 HRESULT WINAPI
VarBstrFromUI1(BYTE bVal
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
350 HRESULT WINAPI
VarBstrFromI2(short iVal
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
351 HRESULT WINAPI
VarBstrFromI4(LONG lIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
352 HRESULT WINAPI
VarBstrFromR4(FLOAT fltIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
353 HRESULT WINAPI
VarBstrFromR8(double dblIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
354 HRESULT WINAPI
VarBstrFromDate(DATE dateIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
355 HRESULT WINAPI
VarBstrFromBool(VARIANT_BOOL boolIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
356 HRESULT WINAPI
VarBstrFromI1(CHAR cIn
, LCID lcid
, ULONG dwFlags
, BSTR
*pbstrOut
);
357 HRESULT WINAPI
VarBstrFromUI2(USHORT uiIn
, LCID lcid
, ULONG dwFlags
, BSTR
*pbstrOut
);
358 HRESULT WINAPI
VarBstrFromUI4(ULONG ulIn
, LCID lcid
, ULONG dwFlags
, BSTR
*pbstrOut
);
359 HRESULT WINAPI
VarBstrFromCy(CY cyIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
360 HRESULT WINAPI
VarBstrFromDec(DECIMAL
* pdecIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
361 HRESULT WINAPI
VarBstrFromDisp(IDispatch
* pdispIn
, LCID lcid
, ULONG dwFlags
, BSTR
* pbstrOut
);
363 HRESULT WINAPI
VarBoolFromUI1(BYTE bIn
, VARIANT_BOOL
* pboolOut
);
364 HRESULT WINAPI
VarBoolFromI2(short sIn
, VARIANT_BOOL
* pboolOut
);
365 HRESULT WINAPI
VarBoolFromI4(LONG lIn
, VARIANT_BOOL
* pboolOut
);
366 HRESULT WINAPI
VarBoolFromR4(FLOAT fltIn
, VARIANT_BOOL
* pboolOut
);
367 HRESULT WINAPI
VarBoolFromR8(double dblIn
, VARIANT_BOOL
* pboolOut
);
368 HRESULT WINAPI
VarBoolFromDate(DATE dateIn
, VARIANT_BOOL
* pboolOut
);
369 HRESULT WINAPI
VarBoolFromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, VARIANT_BOOL
* pboolOut
);
370 HRESULT WINAPI
VarBoolFromI1(CHAR cIn
, VARIANT_BOOL
*pboolOut
);
371 HRESULT WINAPI
VarBoolFromUI2(USHORT uiIn
, VARIANT_BOOL
*pboolOut
);
372 HRESULT WINAPI
VarBoolFromUI4(ULONG ulIn
, VARIANT_BOOL
*pboolOut
);
373 HRESULT WINAPI
VarBoolFromCy(CY cyIn
, VARIANT_BOOL
* pboolOut
);
374 HRESULT WINAPI
VarBoolFromDec(DECIMAL
* pdecIn
, VARIANT_BOOL
* pboolOut
);
375 HRESULT WINAPI
VarBoolFromDisp(IDispatch
* pdispIn
, LCID lcid
, VARIANT_BOOL
* pboolOut
);
377 HRESULT WINAPI
VarI1FromUI1(BYTE bIn
, CHAR
*pcOut
);
378 HRESULT WINAPI
VarI1FromI2(short uiIn
, CHAR
*pcOut
);
379 HRESULT WINAPI
VarI1FromI4(LONG lIn
, CHAR
*pcOut
);
380 HRESULT WINAPI
VarI1FromR4(FLOAT fltIn
, CHAR
*pcOut
);
381 HRESULT WINAPI
VarI1FromR8(double dblIn
, CHAR
*pcOut
);
382 HRESULT WINAPI
VarI1FromDate(DATE dateIn
, CHAR
*pcOut
);
383 HRESULT WINAPI
VarI1FromStr(OLECHAR
*strIn
, LCID lcid
, ULONG dwFlags
, CHAR
*pcOut
);
384 HRESULT WINAPI
VarI1FromBool(VARIANT_BOOL boolIn
, CHAR
*pcOut
);
385 HRESULT WINAPI
VarI1FromUI2(USHORT uiIn
, CHAR
*pcOut
);
386 HRESULT WINAPI
VarI1FromUI4(ULONG ulIn
, CHAR
*pcOut
);
387 HRESULT WINAPI
VarI1FromCy(CY cyIn
, CHAR
*pcOut
);
388 HRESULT WINAPI
VarI1FromDec(DECIMAL
* pdecIn
, CHAR
* pcOut
);
389 HRESULT WINAPI
VarI1FromDisp(IDispatch
* pdispIn
, LCID lcid
, CHAR
* pcOut
);
391 HRESULT WINAPI
VarUI2FromUI1(BYTE bIn
, USHORT
*puiOut
);
392 HRESULT WINAPI
VarUI2FromI2(short uiIn
, USHORT
*puiOut
);
393 HRESULT WINAPI
VarUI2FromI4(LONG lIn
, USHORT
*puiOut
);
394 HRESULT WINAPI
VarUI2FromR4(FLOAT fltIn
, USHORT
*puiOut
);
395 HRESULT WINAPI
VarUI2FromR8(double dblIn
, USHORT
*puiOut
);
396 HRESULT WINAPI
VarUI2FromDate(DATE dateIn
, USHORT
*puiOut
);
397 HRESULT WINAPI
VarUI2FromStr(OLECHAR
*strIn
, LCID lcid
, ULONG dwFlags
, USHORT
*puiOut
);
398 HRESULT WINAPI
VarUI2FromBool(VARIANT_BOOL boolIn
, USHORT
*puiOut
);
399 HRESULT WINAPI
VarUI2FromI1(CHAR cIn
, USHORT
*puiOut
);
400 HRESULT WINAPI
VarUI2FromUI4(ULONG ulIn
, USHORT
*puiOut
);
401 HRESULT WINAPI
VarUI2FromCy(CY cyIn
, USHORT
*puiOut
);
402 HRESULT WINAPI
VarUI2FromDec(DECIMAL
* pdecIn
, USHORT
* puiOut
);
403 HRESULT WINAPI
VarUI2FromDisp(IDispatch
* pdispIn
, LCID lcid
, USHORT
* puiOut
);
405 HRESULT WINAPI
VarUI4FromStr(OLECHAR
*strIn
, LCID lcid
, ULONG dwFlags
, ULONG
*pulOut
);
406 HRESULT WINAPI
VarUI4FromUI1(BYTE bIn
, ULONG
*pulOut
);
407 HRESULT WINAPI
VarUI4FromI2(short uiIn
, ULONG
*pulOut
);
408 HRESULT WINAPI
VarUI4FromI4(LONG lIn
, ULONG
*pulOut
);
409 HRESULT WINAPI
VarUI4FromR4(FLOAT fltIn
, ULONG
*pulOut
);
410 HRESULT WINAPI
VarUI4FromR8(double dblIn
, ULONG
*pulOut
);
411 HRESULT WINAPI
VarUI4FromDate(DATE dateIn
, ULONG
*pulOut
);
412 HRESULT WINAPI
VarUI4FromBool(VARIANT_BOOL boolIn
, ULONG
*pulOut
);
413 HRESULT WINAPI
VarUI4FromI1(CHAR cIn
, ULONG
*pulOut
);
414 HRESULT WINAPI
VarUI4FromUI2(USHORT uiIn
, ULONG
*pulOut
);
415 HRESULT WINAPI
VarUI4FromCy(CY cyIn
, ULONG
*pulOut
);
416 HRESULT WINAPI
VarUI4FromDec(DECIMAL
* pdecIn
, ULONG
* pulOut
);
417 HRESULT WINAPI
VarUI4FromDisp(IDispatch
* pdispIn
, LCID lcid
, ULONG
* pulOut
);
419 HRESULT WINAPI
VarDecFromUI1(BYTE bIn
, DECIMAL
*pdecOut
);
420 HRESULT WINAPI
VarDecFromI2(short uiIn
, DECIMAL
*pdecOut
);
421 HRESULT WINAPI
VarDecFromI4(LONG lIn
, DECIMAL
*pdecOut
);
422 HRESULT WINAPI
VarDecFromR4(FLOAT fltIn
, DECIMAL
*pdecOut
);
423 HRESULT WINAPI
VarDecFromR8(double dblIn
, DECIMAL
*pdecOut
);
424 HRESULT WINAPI
VarDecFromDate(DATE dateIn
, DECIMAL
*pdecOut
);
425 HRESULT WINAPI
VarDecFromStr(OLECHAR
* strIn
, LCID lcid
, ULONG dwFlags
, DECIMAL
* pdecOut
);
426 HRESULT WINAPI
VarDecFromBool(VARIANT_BOOL boolIn
, DECIMAL
* pdecOut
);
427 HRESULT WINAPI
VarDecFromI1(CHAR cIn
, DECIMAL
* pdecOut
);
428 HRESULT WINAPI
VarDecFromUI2(USHORT uiIn
, DECIMAL
* pdecOut
);
429 HRESULT WINAPI
VarDecFromUI4(ULONG ulIn
, DECIMAL
* pdecOut
);
430 HRESULT WINAPI
VarDecFromCy(CY cyIn
, DECIMAL
* pdecOut
);
431 HRESULT WINAPI
VarDecFromDisp(IDispatch
* pdispIn
, LCID lcid
, DECIMAL
* pdecOut
);
435 #define VarUI4FromUI4( in, pOut ) ( *(pOut) = (in) )
436 #define VarI4FromI4( in, pOut ) ( *(pOut) = (in) )
438 #define VarUI1FromInt VarUI1FromI4
439 #define VarUI1FromUint VarUI1FromUI4
440 #define VarI2FromInt VarI2FromI4
441 #define VarI2FromUint VarI2FromUI4
442 #define VarI4FromInt VarI4FromI4
443 #define VarI4FromUint VarI4FromUI4
444 #define VarR4FromInt VarR4FromI4
445 #define VarR4FromUint VarR4FromUI4
446 #define VarR8FromInt VarR8FromI4
447 #define VarR8FromUint VarR8FromUI4
448 #define VarDateFromInt VarDateFromI4
449 #define VarDateFromUint VarDateFromUI4
450 #define VarCyFromInt VarCyFromI4
451 #define VarCyFromUint VarCyFromUI4
452 #define VarBstrFromInt VarBstrFromI4
453 #define VarBstrFromUint VarBstrFromUI4
454 #define VarBoolFromInt VarBoolFromI4
455 #define VarBoolFromUint VarBoolFromUI4
456 #define VarI1FromInt VarI1FromI4
457 #define VarI1FromUint VarI1FromUI4
458 #define VarUI2FromInt VarUI2FromI4
459 #define VarUI2FromUint VarUI2FromUI4
460 #define VarUI4FromInt VarUI4FromI4
461 #define VarUI4FromUint VarUI4FromUI4
462 #define VarDecFromInt VarDecFromI4
463 #define VarDecFromUint VarDecFromUI4
464 #define VarIntFromUI1 VarI4FromUI1
465 #define VarIntFromI2 VarI4FromI2
466 #define VarIntFromI4 VarI4FromI4
467 #define VarIntFromR4 VarI4FromR4
468 #define VarIntFromR8 VarI4FromR8
469 #define VarIntFromDate VarI4FromDate
470 #define VarIntFromCy VarI4FromCy
471 #define VarIntFromStr VarI4FromStr
472 #define VarIntFromDisp VarI4FromDisp
473 #define VarIntFromBool VarI4FromBool
474 #define VarIntFromI1 VarI4FromI1
475 #define VarIntFromUI2 VarI4FromUI2
476 #define VarIntFromUI4 VarI4FromUI4
477 #define VarIntFromDec VarI4FromDec
478 #define VarIntFromUint VarI4FromUI4
479 #define VarUintFromUI1 VarUI4FromUI1
480 #define VarUintFromI2 VarUI4FromI2
481 #define VarUintFromI4 VarUI4FromI4
482 #define VarUintFromR4 VarUI4FromR4
483 #define VarUintFromR8 VarUI4FromR8
484 #define VarUintFromDate VarUI4FromDate
485 #define VarUintFromCy VarUI4FromCy
486 #define VarUintFromStr VarUI4FromStr
487 #define VarUintFromDisp VarUI4FromDisp
488 #define VarUintFromBool VarUI4FromBool
489 #define VarUintFromI1 VarUI4FromI1
490 #define VarUintFromUI2 VarUI4FromUI2
491 #define VarUintFromUI4 VarUI4FromUI4
492 #define VarUintFromDec VarUI4FromDec
493 #define VarUintFromInt VarUI4FromI4
496 * Variant Math operations
501 #define VARCMP_NULL 3
503 HRESULT WINAPI
VarAdd(LPVARIANT
,LPVARIANT
,LPVARIANT
);
504 HRESULT WINAPI
VarAnd(LPVARIANT
,LPVARIANT
,LPVARIANT
);
505 HRESULT WINAPI
VarCat(LPVARIANT
,LPVARIANT
,LPVARIANT
);
506 HRESULT WINAPI
VarDiv(LPVARIANT
,LPVARIANT
,LPVARIANT
);
507 HRESULT WINAPI
VarEqv(LPVARIANT
,LPVARIANT
,LPVARIANT
);
508 HRESULT WINAPI
VarIdiv(LPVARIANT
,LPVARIANT
,LPVARIANT
);
509 HRESULT WINAPI
VarImp(LPVARIANT
,LPVARIANT
,LPVARIANT
);
510 HRESULT WINAPI
VarMod(LPVARIANT
,LPVARIANT
,LPVARIANT
);
511 HRESULT WINAPI
VarMul(LPVARIANT
,LPVARIANT
,LPVARIANT
);
512 HRESULT WINAPI
VarOr(LPVARIANT
,LPVARIANT
,LPVARIANT
);
513 HRESULT WINAPI
VarPow(LPVARIANT
,LPVARIANT
,LPVARIANT
);
514 HRESULT WINAPI
VarSub(LPVARIANT
,LPVARIANT
,LPVARIANT
);
515 HRESULT WINAPI
VarXor(LPVARIANT
,LPVARIANT
,LPVARIANT
);
517 HRESULT WINAPI
VarAbs(LPVARIANT
,LPVARIANT
);
518 HRESULT WINAPI
VarFix(LPVARIANT
,LPVARIANT
);
519 HRESULT WINAPI
VarInt(LPVARIANT
,LPVARIANT
);
520 HRESULT WINAPI
VarNeg(LPVARIANT
,LPVARIANT
);
521 HRESULT WINAPI
VarNot(LPVARIANT
,LPVARIANT
);
523 HRESULT WINAPI
VarRound(LPVARIANT
,int,LPVARIANT
);
525 HRESULT WINAPI
VarCmp(LPVARIANT
,LPVARIANT
,LCID
,ULONG
);
529 typedef struct tagPARAMDATA
{
530 OLECHAR
* szName
; /* parameter name */
531 VARTYPE vt
; /* parameter type */
532 } PARAMDATA
, * LPPARAMDATA
;
534 typedef struct tagMETHODDATA
{
535 OLECHAR
* szName
; /* method name */
536 PARAMDATA
* ppdata
; /* pointer to an array of PARAMDATAs */
537 DISPID dispid
; /* method ID */
538 UINT iMeth
; /* method index */
539 CALLCONV cc
; /* calling convention */
540 UINT cArgs
; /* count of arguments */
541 WORD wFlags
; /* same wFlags as on IDispatch::Invoke() */
543 } METHODDATA
, * LPMETHODDATA
;
545 typedef struct tagINTERFACEDATA
{
546 METHODDATA
* pmethdata
; /* pointer to an array of METHODDATAs */
547 UINT cMembers
; /* count of members */
548 } INTERFACEDATA
, * LPINTERFACEDATA
;
550 typedef enum tagREGKIND
571 #define NUMPRS_LEADING_WHITE 0x0001
572 #define NUMPRS_TRAILING_WHITE 0x0002
573 #define NUMPRS_LEADING_PLUS 0x0004
574 #define NUMPRS_TRAILING_PLUS 0x0008
575 #define NUMPRS_LEADING_MINUS 0x0010
576 #define NUMPRS_TRAILING_MINUS 0x0020
577 #define NUMPRS_HEX_OCT 0x0040
578 #define NUMPRS_PARENS 0x0080
579 #define NUMPRS_DECIMAL 0x0100
580 #define NUMPRS_THOUSANDS 0x0200
581 #define NUMPRS_CURRENCY 0x0400
582 #define NUMPRS_EXPONENT 0x0800
583 #define NUMPRS_USE_ALL 0x1000
584 #define NUMPRS_STD 0x1FFF
586 #define NUMPRS_NEG 0x10000
587 #define NUMPRS_INEXACT 0x20000
589 #define VTBIT_I1 (1 << VT_I1)
590 #define VTBIT_UI1 (1 << VT_UI1)
591 #define VTBIT_I2 (1 << VT_I2)
592 #define VTBIT_UI2 (1 << VT_UI2)
593 #define VTBIT_I4 (1 << VT_I4)
594 #define VTBIT_UI4 (1 << VT_UI4)
595 #define VTBIT_R4 (1 << VT_R4)
596 #define VTBIT_R8 (1 << VT_R8)
597 #define VTBIT_CY (1 << VT_CY)
598 #define VTBIT_DECIMAL (1 << VT_DECIMAL)
600 HRESULT WINAPI
VarParseNumFromStr(OLECHAR
*,LCID
,ULONG
,NUMPARSE
*,BYTE
*);
601 HRESULT WINAPI
VarNumFromParseNum(NUMPARSE
*,BYTE
*,ULONG
,VARIANT
*);
603 INT WINAPI
DosDateTimeToVariantTime(USHORT
,USHORT
,DATE
*);
604 INT WINAPI
VariantTimeToDosDateTime(DATE
, USHORT
*, USHORT
*);
606 HRESULT WINAPI
VariantTimeToSystemTime(double,LPSYSTEMTIME
);
607 HRESULT WINAPI
SystemTimeToVariantTime(LPSYSTEMTIME
,double*);
609 HRESULT WINAPI
VarDateFromUdate(UDATE
*,ULONG
, DATE
*);
610 HRESULT WINAPI
VarUdateFromDate(DATE
, ULONG
, UDATE
*);
612 ULONG WINAPI
LHashValOfNameSysA(SYSKIND syskind
,LCID lcid
,LPCSTR szName
);
613 ULONG WINAPI
LHashValOfNameSys (SYSKIND syskind
,LCID lcid
,LPCOLESTR szName
);
615 HRESULT WINAPI
DispGetParam(DISPPARAMS
* pdispparams
, UINT position
,
616 VARTYPE vtTarg
, VARIANT
* pvarResult
, UINT
* puArgErr
);
617 HRESULT WINAPI
DispGetIDsOfNames(ITypeInfo
* ptinfo
, OLECHAR
** rgszNames
,
618 UINT cNames
, DISPID
* rgdispid
);
619 HRESULT WINAPI
DispInvoke(void* _this
, ITypeInfo
* ptinfo
, DISPID dispidMember
,
620 WORD wFlags
, DISPPARAMS
* pparams
, VARIANT
* pvarResult
,
621 EXCEPINFO
* pexcepinfo
, UINT
* puArgErr
);
622 HRESULT WINAPI
CreateDispTypeInfo(INTERFACEDATA
* pidata
, LCID lcid
,
623 ITypeInfo
** pptinfo
);
624 HRESULT WINAPI
CreateStdDispatch(IUnknown
* punkOuter
, void* pvThis
,
625 ITypeInfo
* ptinfo
, IUnknown
** ppunkStdDisp
);
626 HRESULT WINAPI
DispCallFunc(void* pvInstance
, ULONG oVft
, CALLCONV cc
,
627 VARTYPE vtReturn
, UINT cActuals
, VARTYPE
* prgvt
,
628 VARIANTARG
** prgpvarg
, VARIANT
* pvargResult
);
629 HRESULT WINAPI
GetActiveObject(REFCLSID
, void*, IUnknown
**);
636 HRESULT WINAPI
CreateTypeLib(SYSKIND
,const OLECHAR
*,ICreateTypeLib
**);
637 HRESULT WINAPI
CreateTypeLib2(SYSKIND
,LPCOLESTR
,ICreateTypeLib2
**);
638 HRESULT WINAPI
LoadRegTypeLib(REFGUID
,WORD
,WORD
,LCID
,ITypeLib
**);
639 HRESULT WINAPI
LoadTypeLib(const OLECHAR
*,ITypeLib
**);
640 HRESULT WINAPI
LoadTypeLibEx(LPCOLESTR
,REGKIND
,ITypeLib
**);
641 HRESULT WINAPI
QueryPathOfRegTypeLib(REFGUID
,WORD
,WORD
,LCID
,LPBSTR
);
642 HRESULT WINAPI
RegisterTypeLib(ITypeLib
*,OLECHAR
*,OLECHAR
*);
643 HRESULT WINAPI
UnRegisterTypeLib(REFGUID
,WORD
,WORD
,LCID
,SYSKIND
);
650 #endif /*__WINE_OLEAUTO_H*/