1 /*
2  * The contents of this file is dual-licensed under 2
3  * alternative Open Source/Free licenses: LGPL 2.1 or later and
4  * Apache License 2.0. (starting with JNA version 4.0.0).
5  *
6  * You can freely decide which license you want to apply to
7  * the project.
8  *
9  * You may obtain a copy of the LGPL License at:
10  *
11  * http://www.gnu.org/licenses/licenses.html
12  *
13  * A copy is also included in the downloadable source code package
14  * containing JNA, in file "LGPL2.1".
15  *
16  * You may obtain a copy of the Apache License at:
17  *
18  * http://www.apache.org/licenses/
19  *
20  * A copy is also included in the downloadable source code package
21  * containing JNA, in file "AL2.0".
22  */
23 package com.sun.jna.platform.win32;
24 
25 import java.util.Date;
26 
27 import com.sun.jna.Pointer;
28 import com.sun.jna.Structure;
29 import com.sun.jna.Structure.FieldOrder;
30 import com.sun.jna.Union;
31 import com.sun.jna.platform.win32.OaIdl.CURRENCY;
32 import com.sun.jna.platform.win32.OaIdl.DATE;
33 import com.sun.jna.platform.win32.OaIdl.DECIMAL;
34 import com.sun.jna.platform.win32.OaIdl.SAFEARRAY;
35 import com.sun.jna.platform.win32.OaIdl.VARIANT_BOOL;
36 import com.sun.jna.platform.win32.OaIdl.VARIANT_BOOLByReference;
37 import com.sun.jna.platform.win32.OaIdl._VARIANT_BOOLByReference;
38 import com.sun.jna.platform.win32.WTypes.BSTR;
39 import com.sun.jna.platform.win32.WTypes.VARTYPE;
40 import com.sun.jna.platform.win32.WinDef.BOOL;
41 import com.sun.jna.platform.win32.WinDef.BYTE;
42 import com.sun.jna.platform.win32.WinDef.CHAR;
43 import com.sun.jna.platform.win32.WinDef.CHARByReference;
44 import com.sun.jna.platform.win32.WinDef.LONG;
45 import com.sun.jna.platform.win32.WinDef.LONGByReference;
46 import com.sun.jna.platform.win32.WinDef.LONGLONG;
47 import com.sun.jna.platform.win32.WinDef.LONGLONGByReference;
48 import com.sun.jna.platform.win32.WinDef.PVOID;
49 import com.sun.jna.platform.win32.WinDef.SCODE;
50 import com.sun.jna.platform.win32.WinDef.SCODEByReference;
51 import com.sun.jna.platform.win32.WinDef.SHORT;
52 import com.sun.jna.platform.win32.WinDef.UINT;
53 import com.sun.jna.platform.win32.WinDef.UINTByReference;
54 import com.sun.jna.platform.win32.WinDef.ULONG;
55 import com.sun.jna.platform.win32.WinDef.ULONGByReference;
56 import com.sun.jna.platform.win32.WinDef.ULONGLONG;
57 import com.sun.jna.platform.win32.WinDef.ULONGLONGByReference;
58 import com.sun.jna.platform.win32.WinDef.USHORT;
59 import com.sun.jna.platform.win32.WinDef.USHORTByReference;
60 import com.sun.jna.platform.win32.COM.Dispatch;
61 import com.sun.jna.platform.win32.COM.IDispatch;
62 import com.sun.jna.platform.win32.COM.Unknown;
63 import com.sun.jna.platform.win32.OaIdl.SAFEARRAYByReference;
64 import com.sun.jna.platform.win32.WTypes.BSTRByReference;
65 import com.sun.jna.ptr.ByteByReference;
66 import com.sun.jna.ptr.DoubleByReference;
67 import com.sun.jna.ptr.FloatByReference;
68 import com.sun.jna.ptr.IntByReference;
69 import com.sun.jna.ptr.ShortByReference;
70 
71 public interface Variant {
72 
73     public static int VT_EMPTY = 0;
74     public static int VT_NULL = 1;
75     public static int VT_I2 = 2;
76     public static int VT_I4 = 3;
77     public static int VT_R4 = 4;
78     public static int VT_R8 = 5;
79     public static int VT_CY = 6;
80     public static int VT_DATE = 7;
81     public static int VT_BSTR = 8;
82     public static int VT_DISPATCH = 9;
83     public static int VT_ERROR = 10;
84     public static int VT_BOOL = 11;
85     public static int VT_VARIANT = 12;
86     public static int VT_UNKNOWN = 13;
87     public static int VT_DECIMAL = 14;
88     public static int VT_I1 = 16;
89     public static int VT_UI1 = 17;
90     public static int VT_UI2 = 18;
91     public static int VT_UI4 = 19;
92     public static int VT_I8 = 20;
93     public static int VT_UI8 = 21;
94     public static int VT_INT = 22;
95     public static int VT_UINT = 23;
96     public static int VT_VOID = 24;
97     public static int VT_HRESULT = 25;
98     public static int VT_PTR = 26;
99     public static int VT_SAFEARRAY = 27;
100     public static int VT_CARRAY = 28;
101     public static int VT_USERDEFINED = 29;
102     public static int VT_LPSTR = 30;
103     public static int VT_LPWSTR = 31;
104     public static int VT_RECORD = 36;
105     public static int VT_INT_PTR = 37;
106     public static int VT_UINT_PTR = 38;
107     public static int VT_FILETIME = 64;
108     public static int VT_BLOB = 65;
109     public static int VT_STREAM = 66;
110     public static int VT_STORAGE = 67;
111     public static int VT_STREAMED_OBJECT = 68;
112     public static int VT_STORED_OBJECT = 69;
113     public static int VT_BLOB_OBJECT = 70;
114     public static int VT_CF = 71;
115     public static int VT_CLSID = 72;
116     public static int VT_VERSIONED_STREAM = 73;
117     public static int VT_BSTR_BLOB = 0xfff;
118     public static int VT_VECTOR = 0x1000;
119     public static int VT_ARRAY = 0x2000;
120     public static int VT_BYREF = 0x4000;
121     public static int VT_RESERVED = 0x8000;
122     public static int VT_ILLEGAL = 0xffff;
123     public static int VT_ILLEGALMASKED = 0xfff;
124     public static int VT_TYPEMASK = 0xfff;
125 
126     public static VARIANT_BOOL VARIANT_TRUE = new VARIANT_BOOL(0xFFFF);
127     public static VARIANT_BOOL VARIANT_FALSE = new VARIANT_BOOL(0x0000);
128 
129     public static class VARIANT extends Union {
130 
131         public static class ByReference extends VARIANT implements
132                 Structure.ByReference {
ByReference(VARIANT variant)133             public ByReference(VARIANT variant) {
134                 setValue(variant.getVarType(), variant.getValue());
135             }
136 
ByReference(Pointer variant)137             public ByReference(Pointer variant) {
138                 super(variant);
139             }
140 
ByReference()141             public ByReference() {
142                 super();
143             }
144         }
145 
146         public static class ByValue extends VARIANT implements
147                 Structure.ByValue {
ByValue(VARIANT variant)148             public ByValue(VARIANT variant) {
149                 setValue(variant.getVarType(), variant.getValue());
150             }
151 
ByValue(Pointer variant)152             public ByValue(Pointer variant) {
153                 super(variant);
154             }
155 
ByValue()156             public ByValue() {
157                 super();
158             }
159         }
160 
161         public static final VARIANT VARIANT_MISSING;
162 
163         static {
164             VARIANT_MISSING = new VARIANT();
VARIANT_MISSING.setValue(VT_ERROR, new SCODE(WinError.DISP_E_PARAMNOTFOUND))165             VARIANT_MISSING.setValue(VT_ERROR, new SCODE(WinError.DISP_E_PARAMNOTFOUND));
166         }
167 
168         public _VARIANT _variant;
169 
170         public DECIMAL decVal;
171 
VARIANT()172         public VARIANT() {
173             this.setType("_variant");
174             this.read();
175         }
176 
VARIANT(Pointer pointer)177         public VARIANT(Pointer pointer) {
178             super(pointer);
179             this.setType("_variant");
180             this.read();
181         }
182 
VARIANT(BSTR value)183         public VARIANT(BSTR value) {
184             this();
185             this.setValue(VT_BSTR, value);
186         }
187 
VARIANT(BSTRByReference value)188         public VARIANT(BSTRByReference value) {
189             this();
190             this.setValue(VT_BSTR | VT_BYREF, value);
191         }
192 
VARIANT(VARIANT_BOOL value)193         public VARIANT(VARIANT_BOOL value) {
194             this();
195             this.setValue(VT_BOOL, value);
196         }
197 
VARIANT(BOOL value)198         public VARIANT(BOOL value) {
199             this(value.booleanValue());
200         }
201 
VARIANT(LONG value)202         public VARIANT(LONG value) {
203             this();
204             this.setValue(VT_I4, value);
205         }
206 
VARIANT(SHORT value)207         public VARIANT(SHORT value) {
208             this();
209             this.setValue(VT_I2, value);
210         }
211 
VARIANT(DATE value)212         public VARIANT(DATE value) {
213             this();
214             this.setValue(VT_DATE, value);
215         }
216 
VARIANT(byte value)217         public VARIANT(byte value) {
218             this(new BYTE(value));
219         }
220 
VARIANT(BYTE value)221         public VARIANT(BYTE value) {
222             this();
223             this.setValue(Variant.VT_UI1, value);
224         }
225 
VARIANT(char value)226         public VARIANT(char value) {
227             this();
228             this.setValue(VT_UI2, new USHORT(value));
229         }
230 
VARIANT(CHAR value)231         public VARIANT(CHAR value) {
232             this();
233             this.setValue(Variant.VT_I1, value);
234         }
235 
VARIANT(short value)236         public VARIANT(short value) {
237             this();
238             this.setValue(VT_I2, new SHORT(value));
239         }
240 
VARIANT(int value)241         public VARIANT(int value) {
242             this();
243             this.setValue(VT_I4, new LONG(value));
244         }
245 
VARIANT(IntByReference value)246         public VARIANT(IntByReference value) {
247             this();
248             this.setValue(VT_INT | VT_BYREF, value);
249         }
250 
VARIANT(long value)251         public VARIANT(long value) {
252             this();
253             this.setValue(VT_I8, new LONGLONG(value));
254         }
255 
VARIANT(float value)256         public VARIANT(float value) {
257             this();
258             this.setValue(VT_R4, value);
259         }
260 
VARIANT(double value)261         public VARIANT(double value) {
262             this();
263             this.setValue(VT_R8, value);
264         }
265 
266         /**
267          * Create a new VARIANT wrapping the supplied string.
268          *
269          * <p><i>Implementation note:</i> the string is wrapped as a BSTR value,
270          * that is allocated using {@link com.sun.jna.platform.win32.OleAuto#SysAllocString}
271          * and needs to be freed using
272          * {@link com.sun.jna.platform.win32.OleAuto#SysFreeString} by the user</p>
273          *
274          * @param value  to be wrapped
275          */
VARIANT(String value)276         public VARIANT(String value) {
277             this();
278             BSTR bstrValue = OleAuto.INSTANCE.SysAllocString(value);
279             this.setValue(VT_BSTR, bstrValue);
280         }
281 
VARIANT(boolean value)282         public VARIANT(boolean value) {
283             this();
284             this.setValue(VT_BOOL, new VARIANT_BOOL(value));
285         }
286 
287         /**
288          * @deprecated Use {@link #VARIANT(com.sun.jna.platform.win32.COM.Dispatch)}
289          */
290         @Deprecated
VARIANT(IDispatch value)291         public VARIANT(IDispatch value) {
292             this();
293             this.setValue(Variant.VT_DISPATCH, value);
294         }
295 
VARIANT(Dispatch value)296         public VARIANT(Dispatch value) {
297             this();
298             this.setValue(Variant.VT_DISPATCH, value);
299         }
300 
VARIANT(Date value)301         public VARIANT(Date value) {
302             this();
303             this.setValue(VT_DATE, new DATE(value));
304         }
305 
VARIANT(SAFEARRAY array)306         public VARIANT(SAFEARRAY array) {
307             this();
308             this.setValue(array);
309         }
310 
VARIANT(SAFEARRAYByReference array)311         public VARIANT(SAFEARRAYByReference array) {
312             this();
313             this.setValue(array);
314         }
315 
getVarType()316         public VARTYPE getVarType() {
317             this.read();
318             return _variant.vt;
319         }
320 
setVarType(short vt)321         public void setVarType(short vt) {
322             this._variant.vt = new VARTYPE(vt);
323         }
324 
setValue(int vt, Object value)325         public void setValue(int vt, Object value) {
326             this.setValue(new VARTYPE(vt), value);
327         }
328 
setValue(SAFEARRAY array)329         public void setValue(SAFEARRAY array) {
330             this.setValue(array.getVarType().intValue() | VT_ARRAY, array);
331         }
332 
setValue(SAFEARRAYByReference array)333         public void setValue(SAFEARRAYByReference array) {
334             this.setValue(array.pSAFEARRAY.getVarType().intValue() | VT_ARRAY | VT_BYREF, array);
335         }
336 
setValue(VARTYPE vt, Object value)337         public void setValue(VARTYPE vt, Object value) {
338             int varType = vt.intValue();
339             switch (varType) {
340                 case VT_UI1:
341                     this._variant.__variant.writeField("bVal", value);
342                     break;
343                 case VT_I2:
344                     this._variant.__variant.writeField("iVal", value);
345                     break;
346                 case VT_I4:
347                     this._variant.__variant.writeField("lVal", value);
348                     break;
349                 case VT_I8:
350                     this._variant.__variant.writeField("llVal", value);
351                     break;
352                 case VT_R4:
353                     this._variant.__variant.writeField("fltVal", value);
354                     break;
355                 case VT_R8:
356                     this._variant.__variant.writeField("dblVal", value);
357                     break;
358                 case VT_BOOL:
359                     this._variant.__variant.writeField("boolVal", value);
360                     break;
361                 case VT_ERROR:
362                     this._variant.__variant.writeField("scode", value);
363                     break;
364                 case VT_CY:
365                     this._variant.__variant.writeField("cyVal", value);
366                     break;
367                 case VT_DATE:
368                     this._variant.__variant.writeField("date", value);
369                     break;
370                 case VT_BSTR:
371                     this._variant.__variant.writeField("bstrVal", value);
372                     break;
373                 case VT_UNKNOWN:
374                     this._variant.__variant.writeField("punkVal", value);
375                     break;
376                 case VT_DISPATCH:
377                     this._variant.__variant.writeField("pdispVal", value);
378                     break;
379                 case VT_BYREF | VT_UI1:
380                     this._variant.__variant.writeField("pbVal", value);
381                     break;
382                 case VT_BYREF | VT_I2:
383                     this._variant.__variant.writeField("piVal", value);
384                     break;
385                 case VT_BYREF | VT_I4:
386                     this._variant.__variant.writeField("plVal", value);
387                     break;
388                 case VT_BYREF | VT_I8:
389                     this._variant.__variant.writeField("pllVal", value);
390                     break;
391                 case VT_BYREF | VT_R4:
392                     this._variant.__variant.writeField("pfltVal", value);
393                     break;
394                 case VT_BYREF | VT_R8:
395                     this._variant.__variant.writeField("pdblVal", value);
396                     break;
397                 case VT_BYREF | VT_BOOL:
398                     this._variant.__variant.writeField("pboolVal", value);
399                     break;
400                 case VT_BYREF | VT_ERROR:
401                     this._variant.__variant.writeField("pscode", value);
402                     break;
403                 case VT_BYREF | VT_CY:
404                     this._variant.__variant.writeField("pcyVal", value);
405                     break;
406                 case VT_BYREF | VT_DATE:
407                     this._variant.__variant.writeField("pdate", value);
408                     break;
409                 case VT_BYREF | VT_BSTR:
410                     this._variant.__variant.writeField("pbstrVal", value);
411                     break;
412                 case VT_BYREF | VT_UNKNOWN:
413                     this._variant.__variant.writeField("ppunkVal", value);
414                     break;
415                 case VT_BYREF | VT_DISPATCH:
416                     this._variant.__variant.writeField("ppdispVal", value);
417                     break;
418                 case VT_BYREF | VT_VARIANT:
419                     this._variant.__variant.writeField("pvarVal", value);
420                     break;
421                 case VT_BYREF:
422                     this._variant.__variant.writeField("byref", value);
423                     break;
424                 case VT_I1:
425                     this._variant.__variant.writeField("cVal", value);
426                     break;
427                 case VT_UI2:
428                     this._variant.__variant.writeField("uiVal", value);
429                     break;
430                 case VT_UI4:
431                     this._variant.__variant.writeField("ulVal", value);
432                     break;
433                 case VT_UI8:
434                     this._variant.__variant.writeField("ullVal", value);
435                     break;
436                 case VT_INT:
437                     this._variant.__variant.writeField("intVal", value);
438                     break;
439                 case VT_UINT:
440                     this._variant.__variant.writeField("uintVal", value);
441                     break;
442                 case VT_BYREF | VT_DECIMAL:
443                     this._variant.__variant.writeField("pdecVal", value);
444                     break;
445                 case VT_BYREF | VT_I1:
446                     this._variant.__variant.writeField("pcVal", value);
447                     break;
448                 case VT_BYREF | VT_UI2:
449                     this._variant.__variant.writeField("puiVal", value);
450                     break;
451                 case VT_BYREF | VT_UI4:
452                     this._variant.__variant.writeField("pulVal", value);
453                     break;
454                 case VT_BYREF | VT_UI8:
455                     this._variant.__variant.writeField("pullVal", value);
456                     break;
457                 case VT_BYREF | VT_INT:
458                     this._variant.__variant.writeField("pintVal", value);
459                     break;
460                 case VT_BYREF | VT_UINT:
461                     this._variant.__variant.writeField("puintVal", value);
462                     break;
463                 case VT_RECORD:
464                     this._variant.__variant.writeField("pvRecord", value);
465                     break;
466                 default:
467                     if ((varType & VT_ARRAY) > 0) {
468                         if ((varType & VT_BYREF) > 0) {
469                             this._variant.__variant.writeField("pparray", value);
470                         } else {
471                             this._variant.__variant.writeField("parray", value);
472                         }
473                     }
474             }
475 
476             this._variant.writeField("vt", vt);
477             this.write();
478         }
479 
getValue()480         public Object getValue() {
481             // this.read() is called by this.getVarType()
482             int varType = this.getVarType().intValue();
483             switch (varType) {
484                 case VT_UI1:
485                     return this._variant.__variant.readField("bVal");
486                 case VT_I2:
487                     return this._variant.__variant.readField("iVal");
488                 case VT_I4:
489                     return this._variant.__variant.readField("lVal");
490                 case VT_I8:
491                     return this._variant.__variant.readField("llVal");
492                 case VT_R4:
493                     return this._variant.__variant.readField("fltVal");
494                 case VT_R8:
495                     return this._variant.__variant.readField("dblVal");
496                 case VT_BOOL:
497                     return this._variant.__variant.readField("boolVal");
498                 case VT_ERROR:
499                     return this._variant.__variant.readField("scode");
500                 case VT_CY:
501                     return this._variant.__variant.readField("cyVal");
502                 case VT_DATE:
503                     return this._variant.__variant.readField("date");
504                 case VT_BSTR:
505                     return this._variant.__variant.readField("bstrVal");
506                 case VT_UNKNOWN:
507                     return this._variant.__variant.readField("punkVal");
508                 case VT_DISPATCH:
509                     return this._variant.__variant.readField("pdispVal");
510                 case VT_BYREF | VT_UI1:
511                     return this._variant.__variant.readField("pbVal");
512                 case VT_BYREF | VT_I2:
513                     return this._variant.__variant.readField("piVal");
514                 case VT_BYREF | VT_I4:
515                     return this._variant.__variant.readField("plVal");
516                 case VT_BYREF | VT_I8:
517                     return this._variant.__variant.readField("pllVal");
518                 case VT_BYREF | VT_R4:
519                     return this._variant.__variant.readField("pfltVal");
520                 case VT_BYREF | VT_R8:
521                     return this._variant.__variant.readField("pdblVal");
522                 case VT_BYREF | VT_BOOL:
523                     return this._variant.__variant.readField("pboolVal");
524                 case VT_BYREF | VT_ERROR:
525                     return this._variant.__variant.readField("pscode");
526                 case VT_BYREF | VT_CY:
527                     return this._variant.__variant.readField("pcyVal");
528                 case VT_BYREF | VT_DATE:
529                     return this._variant.__variant.readField("pdate");
530                 case VT_BYREF | VT_BSTR:
531                     return this._variant.__variant.readField("pbstrVal");
532                 case VT_BYREF | VT_UNKNOWN:
533                     return this._variant.__variant.readField("ppunkVal");
534                 case VT_BYREF | VT_DISPATCH:
535                     return this._variant.__variant.readField("ppdispVal");
536                 case VT_BYREF | VT_VARIANT:
537                     return this._variant.__variant.readField("pvarVal");
538                 case VT_BYREF:
539                     return this._variant.__variant.readField("byref");
540                 case VT_I1:
541                     return this._variant.__variant.readField("cVal");
542                 case VT_UI2:
543                     return this._variant.__variant.readField("uiVal");
544                 case VT_UI4:
545                     return this._variant.__variant.readField("ulVal");
546                 case VT_UI8:
547                     return this._variant.__variant.readField("ullVal");
548                 case VT_INT:
549                     return this._variant.__variant.readField("intVal");
550                 case VT_UINT:
551                     return this._variant.__variant.readField("uintVal");
552                 case VT_BYREF | VT_DECIMAL:
553                     return this._variant.__variant.readField("pdecVal");
554                 case VT_BYREF | VT_I1:
555                     return this._variant.__variant.readField("pcVal");
556                 case VT_BYREF | VT_UI2:
557                     return this._variant.__variant.readField("puiVal");
558                 case VT_BYREF | VT_UI4:
559                     return this._variant.__variant.readField("pulVal");
560                 case VT_BYREF | VT_UI8:
561                     return this._variant.__variant.readField("pullVal");
562                 case VT_BYREF | VT_INT:
563                     return this._variant.__variant.readField("pintVal");
564                 case VT_BYREF | VT_UINT:
565                     return this._variant.__variant.readField("puintVal");
566                 case VT_RECORD:
567                     return this._variant.__variant.readField("pvRecord");
568                 default:
569                     if((varType & VT_ARRAY) > 0) {
570                         if((varType & VT_BYREF) > 0) {
571                             return this._variant.__variant.readField("pparray");
572                         } else {
573                             return this._variant.__variant.readField("parray");
574                         }
575                     }
576                     return null;
577             }
578         }
579 
byteValue()580         public byte byteValue() {
581             return ((Number) this.getValue()).byteValue();
582         }
583 
shortValue()584         public short shortValue() {
585             return ((Number) this.getValue()).shortValue();
586         }
587 
intValue()588         public int intValue() {
589             return ((Number) this.getValue()).intValue();
590         }
591 
longValue()592         public long longValue() {
593             return ((Number) this.getValue()).longValue();
594         }
595 
floatValue()596         public float floatValue() {
597             return ((Number) this.getValue()).floatValue();
598         }
599 
doubleValue()600         public double doubleValue() {
601             return ((Number) this.getValue()).doubleValue();
602         }
603 
stringValue()604         public String stringValue() {
605             BSTR bstr = (BSTR) this.getValue();
606             if(bstr == null) {
607                 return null;
608             } else {
609                 return bstr.getValue();
610             }
611         }
612 
booleanValue()613         public boolean booleanValue() {
614             // getValue returns a VARIANT_BOOL
615             return ((VARIANT_BOOL) this.getValue()).booleanValue();
616         }
617 
dateValue()618         public Date dateValue() {
619             DATE varDate = (DATE) this.getValue();
620             if(varDate == null) {
621                 return null;
622             } else {
623                 return varDate.getAsJavaDate();
624             }
625         }
626 
627         @FieldOrder({"vt", "wReserved1", "wReserved2", "wReserved3", "__variant"})
628         public static class _VARIANT extends Structure {
629             public static class __VARIANT extends Union {
630                 @FieldOrder({"pvRecord", "pRecInfo"})
631                 public static class BRECORD extends Structure {
632                     public static class ByReference extends BRECORD implements
633                             Structure.ByReference {
634                     }
635 
636                     public PVOID pvRecord;
637                     public Pointer pRecInfo;
638 
BRECORD()639                     public BRECORD() {
640                         super();
641                     }
642 
BRECORD(Pointer pointer)643                     public BRECORD(Pointer pointer) {
644                         super(pointer);
645                     }
646                 }
647 
648                 // LONGLONG VT_I8
649                 public LONGLONG llVal;
650                 // LONG VT_I4
651                 public LONG lVal;
652                 // BYTE VT_UI1
653                 public BYTE bVal;
654                 // SHORT VT_I2
655                 public SHORT iVal;
656                 // FLOAT VT_R4
657                 public Float fltVal;
658                 // DOUBLE VT_R8
659                 public Double dblVal;
660                 // VARIANT_BOOL VT_BOOL
661                 public VARIANT_BOOL boolVal;
662                 // SCODE VT_ERROR
663                 public SCODE scode;
664                 // CY VT_CY
665                 public CURRENCY cyVal;
666                 // DATE VT_DATE
667                 public DATE date;
668                 // BSTR VT_BSTR
669                 public BSTR bstrVal;
670                 // IUnknown * VT_UNKNOWN
671                 public Unknown punkVal;
672                 // IDispatch * VT_DISPATCH
673                 public Dispatch pdispVal;
674                 // SAFEARRAY * VT_ARRAY
675                 public SAFEARRAY.ByReference parray;
676                 // BYTE * VT_BYREF|VT_UI1
677                 public ByteByReference pbVal;
678                 // SHORT * VT_BYREF|VT_I2
679                 public ShortByReference piVal;
680                 // LONG * VT_BYREF|VT_I4
681                 public LONGByReference plVal;
682                 // LONGLONG * VT_BYREF|VT_I8
683                 public LONGLONGByReference pllVal;
684                 // FLOAT * VT_BYREF|VT_R4
685                 public FloatByReference pfltVal;
686                 // DOUBLE * VT_BYREF|VT_R8
687                 public DoubleByReference pdblVal;
688                 // VARIANT_BOOL * VT_BYREF|VT_BOOL
689                 public VARIANT_BOOLByReference pboolVal;
690                 // VARIANT_BOOL * VT_BYREF|VT_BOOL
691                 public _VARIANT_BOOLByReference pbool;
692                 // SCODE * VT_BYREF|VT_ERROR
693                 public SCODEByReference pscode;
694                 // CY * VT_BYREF|VT_CY
695                 public CURRENCY.ByReference pcyVal;
696                 // DATE * VT_BYREF|VT_DATE
697                 public DATE.ByReference pdate;
698                 // BSTR * VT_BYREF|VT_BSTR
699                 public BSTRByReference pbstrVal;
700                 // IUnknown ** VT_BYREF|VT_UNKNOWN
701                 public Unknown.ByReference ppunkVal;
702                 // IDispatch ** VT_BYREF|VT_DISPATCH
703                 public Dispatch.ByReference ppdispVal;
704                 // SAFEARRAY ** VT_BYREF|VT_ARRAY
705                 public SAFEARRAYByReference pparray;
706                 // VARIANT * VT_BYREF|VT_VARIANT
707                 public VARIANT.ByReference pvarVal;
708                 // PVOID VT_BYREF (Generic ByRef)
709                 public PVOID byref;
710                 // CHAR VT_I1
711                 public CHAR cVal;
712                 // USHORT VT_UI2
713                 public USHORT uiVal;
714                 // ULONG VT_UI4
715                 public ULONG ulVal;
716                 // ULONGLONG VT_UI8
717                 public ULONGLONG ullVal;
718                 // INT VT_INT
719                 public Integer intVal;
720                 // UINT VT_UINT
721                 public UINT uintVal;
722                 // DECIMAL * VT_BYREF|VT_DECIMAL
723                 public DECIMAL.ByReference pdecVal;
724                 // CHAR * VT_BYREF|VT_I1
725                 public CHARByReference pcVal;
726                 // USHORT * VT_BYREF|VT_UI2
727                 public USHORTByReference puiVal;
728                 // ULONG * VT_BYREF|VT_UI4
729                 public ULONGByReference pulVal;
730                 // ULONGLONG * VT_BYREF|VT_UI8
731                 public ULONGLONGByReference pullVal;
732                 // INT * VT_BYREF|VT_INT
733                 public IntByReference pintVal;
734                 // UINT * VT_BYREF|VT_UINT
735                 public UINTByReference puintVal;
736                 // BRECORD VT_RECORD
737                 public BRECORD pvRecord;
738 
__VARIANT()739                 public __VARIANT() {
740                     super();
741                     this.read();
742                 }
743 
__VARIANT(Pointer pointer)744                 public __VARIANT(Pointer pointer) {
745                     super(pointer);
746                     this.read();
747                 }
748             }
749 
750             public VARTYPE vt;
751             public short wReserved1;
752             public short wReserved2;
753             public short wReserved3;
754             public __VARIANT __variant;
755 
_VARIANT()756             public _VARIANT() {
757                 super();
758             }
759 
_VARIANT(Pointer pointer)760             public _VARIANT(Pointer pointer) {
761                 super(pointer);
762                 this.read();
763             }
764         }
765     }
766 
767     @FieldOrder({"variantArg"})
768     public static class VariantArg extends Structure {
769         public static class ByReference extends VariantArg implements
770                 Structure.ByReference {
771 
ByReference()772             public ByReference() {
773             }
774 
ByReference(VARIANT[] variantArg)775             public ByReference(VARIANT[] variantArg) {
776                 super(variantArg);
777             }
778         }
779 
780         public VARIANT[] variantArg;
781 
VariantArg()782         public VariantArg() {
783             super();
784             variantArg = new VARIANT[1];
785         }
786 
787         /**
788          * construct VariantArg cast onto pre-allocated memory
789          * @param pointer base address
790          */
VariantArg(Pointer pointer)791         public VariantArg(Pointer pointer) {
792             super(pointer);
793             variantArg = new VARIANT[1];
794         }
795 
VariantArg(VARIANT[] variantArg)796         public VariantArg(VARIANT[] variantArg) {
797             this.variantArg = variantArg;
798         }
799 
setArraySize(int size)800         public void setArraySize(int size) {
801             this.variantArg = new VARIANT[size];
802             this.read();
803         }
804     }
805 }
806