![]() |
![]() |
00001 /****************************************************************************** 00002 * GX variants - V7.2.12.1 00003 * 00004 * 2006-2015 (c) Adaptive Recognition (https://adaptiverecognition.com) 00005 ******************************************************************************/ 00006 #ifndef GX_VARIANT_CPT_INCL 00007 #define GX_VARIANT_CPT_INCL 00008 /******************************************************************************/ 00026 /******************************************************************************/ 00027 #include "gxsd.h" 00028 /******************************************************************************/ 00029 #ifdef GX_NAMESPACES 00030 namespace gx { 00031 #ifdef GX_DOTNET 00032 /* Unmanaged code for .NET. */ 00033 #pragma unmanaged 00034 #endif 00035 #endif 00036 /******************************************************************************/ 00038 #ifndef GX_DOTNET 00039 struct GX_VARIANT; 00040 #else 00041 struct GX_VARIANT{}; 00042 #endif 00043 00044 typedef struct GX_VARIANT* gxVARIANT; 00045 00046 #ifdef GX_DOTNET 00047 #pragma managed 00048 #endif 00049 00050 #ifndef GX_EXT_MODULE 00051 00058 GX_ENUM GX_VARIANT_TYPES 00059 { 00060 /* Basic types (size = size of one element in bytes, nitems = number of items) */ 00061 GX_VARIANT_NULL = 0x00, 00062 GX_VARIANT_INT = 0x01, 00063 GX_VARIANT_UINT = 0x02, 00064 GX_VARIANT_FLOAT = 0x03, 00065 GX_VARIANT_DATETIME = 0x04, 00067 /* Array types, bit 6 set defines the array type. 00068 * (size = size of the element in bytes, nitems = number of items) */ 00069 GX_VARIANT_ARRAY = 0x40, 00070 GX_VARIANT_INTARRAY = 0x41, 00071 GX_VARIANT_UINTARRAY = 0x42, 00072 GX_VARIANT_FLOATARRAY = 0x43, 00073 GX_VARIANT_DATETIMEARRAY= 0x44, 00075 /* Other dynamically sized types */ 00076 GX_VARIANT_LIST = 0x80, 00077 GX_VARIANT_BINARY = 0x81, 00078 GX_VARIANT_ASCII = 0x82, 00079 GX_VARIANT_UNICODE = 0x83, 00080 GX_VARIANT_CONTAINER = 0x84, 00082 /* Types for creation operation only */ 00083 GX_VARIANT_AC_ASCII = 0x1082, 00084 GX_VARIANT_AC_UNICODE = 0x1083, 00085 GX_VARIANT_AS_ASCII = 0x2082, 00086 GX_VARIANT_AS_UNICODE = 0x2083, 00087 }; 00088 00089 #endif 00090 00091 #ifndef GX_MANUAL 00092 00093 #ifndef __cplusplus 00094 typedef enum GX_VARIANT_TYPES GX_VARIANT_TYPES; 00095 #endif 00096 00097 #endif /* GX_MANUAL */ 00098 00099 #ifndef GX_EXT_MODULE 00100 00102 GX_ENUM GX_VARIANT_FLAGS 00103 { 00104 GX_VARIANT_BY_INDEX = 0x0002, 00106 GX_VARIANT_BY_ID = 0x0001, 00107 GX_VARIANT_BY_INDEX_AND_ID = 0x0003, 00108 GX_VARIANT_BY_ORDER_AND_ID = 0x0004, 00110 GX_VARIANT_BY_NAME = 0x0008, 00111 GX_VARIANT_BY_INDEX_AND_NAME = 0x000a, 00112 GX_VARIANT_BY_ORDER_AND_NAME = 0x0010, 00114 GX_VARIANT_APPEND = 0x0100, 00115 GX_VARIANT_LAST = 0x0200, 00116 }; 00117 00118 #endif 00119 /******************************************************************************/ 00120 #ifndef GX_MANUAL 00121 #ifdef __BORLANDC__ 00122 #pragma warn -rch 00123 #endif 00124 00125 /* .NET Workarounds */ 00126 #ifdef GX_DOTNET 00127 #pragma unmanaged 00128 #define _GX_VARIANT_LAST 0x0200 00129 #define _GX_VARIANT_BY_ORDER_AND_ID 4 00130 #else 00131 #define _GX_VARIANT_LAST GX_VARIANT_LAST 00132 #define _GX_VARIANT_BY_ORDER_AND_ID GX_VARIANT_BY_ORDER_AND_ID 00133 #endif 00134 #endif/* GX_MANUAL */ 00135 00136 /******************************************************************************/ 00137 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL) 00138 /* GX call codes */ 00139 enum GX_CALL_VARIANT_CODES 00140 { 00141 GX_CALL_REFVARIANT = GX_CALL_GROUP_VARIANT, 00142 GX_CALL_UNREFVARIANT = GX_CALL_GROUP_VARIANT+1, 00143 GX_CALL_CREATEVARIANT = GX_CALL_GROUP_VARIANT+3, 00144 GX_CALL_DUPLICATEVARIANT = GX_CALL_GROUP_VARIANT+4, 00145 GX_CALL_UPDATEVARIANT = GX_CALL_GROUP_VARIANT+5, 00146 GX_CALL_UPDATEVARIANTDATA = GX_CALL_GROUP_VARIANT+6, 00147 GX_CALL_GETVARIANT = GX_CALL_GROUP_VARIANT+7, 00148 GX_CALL_CONVERTVARIANT = GX_CALL_GROUP_VARIANT+8, 00149 00150 GX_CALL_GETVARIANTITEM = GX_CALL_GROUP_VARIANT+9, 00151 GX_CALL_CUTVARIANTITEM = GX_CALL_GROUP_VARIANT+10, 00152 GX_CALL_FINDVARIANTITEM = GX_CALL_GROUP_VARIANT+11, 00153 GX_CALL_ADDVARIANTITEM = GX_CALL_GROUP_VARIANT+12, 00154 GX_CALL_REMOVEVARIANTITEM = GX_CALL_GROUP_VARIANT+13, 00155 00156 GX_CALL_GETVARIANTCHILD = GX_CALL_GROUP_VARIANT+14, 00157 GX_CALL_CUTVARIANTCHILD = GX_CALL_GROUP_VARIANT+15, 00158 GX_CALL_FINDVARIANTCHILD = GX_CALL_GROUP_VARIANT+16, 00159 GX_CALL_ADDVARIANTCHILD = GX_CALL_GROUP_VARIANT+17, 00160 GX_CALL_REMOVEVARIANTCHILD = GX_CALL_GROUP_VARIANT+18, 00161 00162 GX_CALL_GETVARIANTVALUE = GX_CALL_GROUP_VARIANT+19, 00163 GX_CALL_CUTVARIANTVALUE = GX_CALL_GROUP_VARIANT+20, 00164 GX_CALL_ADDVARIANTVALUE = GX_CALL_GROUP_VARIANT+22, 00165 GX_CALL_REMOVEVARIANTVALUE = GX_CALL_GROUP_VARIANT+23, 00166 00167 GX_CALL_GETVARIANTBYPATH = GX_CALL_GROUP_VARIANT+24, 00168 GX_CALL_GETVARIANTBYPATHA = GX_CALL_GROUP_VARIANT+25, 00169 GX_CALL_CONVERTVARIANTBYPATH = GX_CALL_GROUP_VARIANT+26, 00170 GX_CALL_CONVERTVARIANTBYPATHA = GX_CALL_GROUP_VARIANT+27, 00171 00172 GX_CALL_UPDATEVARIANTID = GX_CALL_GROUP_VARIANT+29, 00173 00174 GX_CALL_CREATEVARIANTN = GX_CALL_GROUP_VARIANT+30, 00175 GX_CALL_UPDATEVARIANTN = GX_CALL_GROUP_VARIANT+31, 00176 GX_CALL_UPDATEVARIANTDATAN = GX_CALL_GROUP_VARIANT+32, 00177 GX_CALL_CHANGEVARIANTNAME = GX_CALL_GROUP_VARIANT+33, 00178 GX_CALL_GETVARIANTINFO = GX_CALL_GROUP_VARIANT+34, 00179 00180 GX_CALL_GETVARIANTITEMN = GX_CALL_GROUP_VARIANT+35, 00181 GX_CALL_CUTVARIANTITEMN = GX_CALL_GROUP_VARIANT+36, 00182 GX_CALL_FINDVARIANTITEMN = GX_CALL_GROUP_VARIANT+37, 00183 GX_CALL_ADDVARIANTITEMN = GX_CALL_GROUP_VARIANT+38, 00184 00185 GX_CALL_GETVARIANTCHILDN = GX_CALL_GROUP_VARIANT+39, 00186 GX_CALL_CUTVARIANTCHILDN = GX_CALL_GROUP_VARIANT+40, 00187 GX_CALL_FINDVARIANTCHILDN = GX_CALL_GROUP_VARIANT+41, 00188 GX_CALL_ADDVARIANTCHILDN = GX_CALL_GROUP_VARIANT+42, 00189 }; 00190 00191 /******************************************************************************/ 00192 00193 /* GX call parameter structures. */ 00194 00195 struct GX_PARM_DUPLICATEVARIANT 00196 { 00197 gxVARIANT source; 00198 gxVARIANT target; 00199 }; 00200 00201 #define GX_PARM_CREATEVARIANT GX_PARM_UPDATEVARIANT 00202 00203 struct GX_PARM_UPDATEVARIANT 00204 { 00205 gxVARIANT variant; 00206 int id; 00207 int type; 00208 int size; 00209 int nitems; 00210 const void *data; 00211 }; 00212 00213 #define GX_PARM_UPDATEVARIANTDATA GX_PARM_UPDATEVARIANT 00214 00215 struct GX_PARM_UPDATEVARIANTID 00216 { 00217 gxVARIANT variant; 00218 int id; 00219 }; 00220 00221 struct GX_PARM_GETVARIANT 00222 { 00223 gxVARIANT variant; 00224 int id; 00225 int type; 00226 int size; 00227 int nitems; 00228 int nchildren; 00229 }; 00230 00231 struct GX_PARM_CONVERTVARIANT 00232 { 00233 gxVARIANT variant; 00234 int id; 00235 int type; 00236 int size; 00237 int nitems; 00238 void *target; 00239 int tgtlen; 00240 }; 00241 00242 struct GX_PARM_GETVARIANTITEM 00243 { 00244 gxVARIANT list; 00245 int flags; 00246 int id; 00247 int ix; 00248 gxVARIANT target; 00249 }; 00250 00251 #define GX_PARM_CUTVARIANTITEM GX_PARM_GETVARIANTITEM 00252 00253 struct GX_PARM_FINDVARIANTITEM 00254 { 00255 gxVARIANT list; 00256 gxVARIANT item; 00257 int id; 00258 int ix; 00259 }; 00260 00261 struct GX_PARM_ADDVARIANTITEM 00262 { 00263 gxVARIANT list; 00264 int flags; 00265 int id; 00266 int ix; 00267 gxVARIANT item; 00268 }; 00269 00270 struct GX_PARM_REMOVEVARIANTITEM 00271 { 00272 gxVARIANT list; 00273 int flags; 00274 int id; 00275 int ix; 00276 }; 00277 00278 struct GX_PARM_GETVARIANTCHILD 00279 { 00280 gxVARIANT parent; 00281 int flags; 00282 int id; 00283 int ix; 00284 gxVARIANT target; 00285 }; 00286 00287 #define GX_PARM_CUTVARIANTCHILD GX_PARM_GETVARIANTCHILD 00288 00289 struct GX_PARM_FINDVARIANTCHILD 00290 { 00291 gxVARIANT parent; 00292 gxVARIANT child; 00293 int id; 00294 int ix; 00295 }; 00296 00297 struct GX_PARM_ADDVARIANTCHILD 00298 { 00299 gxVARIANT parent; 00300 int flags; 00301 int id; 00302 int ix; 00303 gxVARIANT child; 00304 }; 00305 00306 struct GX_PARM_REMOVEVARIANTCHILD 00307 { 00308 gxVARIANT parent; 00309 int flags; 00310 int id; 00311 int ix; 00312 }; 00313 00314 struct GX_PARM_GETVARIANTVALUE 00315 { 00316 gxVARIANT array; 00317 int size; 00318 int type; 00319 int ix; 00320 int nitems; 00321 void *target; 00322 int tgtlen; 00323 }; 00324 00325 #define GX_PARM_CUTVARIANTVALUE GX_PARM_GETVARIANTVALUE 00326 00327 struct GX_PARM_ADDVARIANTVALUE 00328 { 00329 gxVARIANT array; 00330 int size; 00331 int type; 00332 int ix; 00333 int nitems; 00334 const void *data; 00335 }; 00336 00337 struct GX_PARM_REMOVEVARIANTVALUE 00338 { 00339 gxVARIANT array; 00340 int ix; 00341 int nitems; 00342 }; 00343 00344 struct GX_PARM_GETVARIANTBYPATH 00345 { 00346 gxVARIANT root; 00347 const wchar_t *path; 00348 gxVARIANT item; 00349 }; 00350 00351 struct GX_PARM_GETVARIANTBYPATHA 00352 { 00353 gxVARIANT root; 00354 const char *path; 00355 gxVARIANT item; 00356 }; 00357 00358 struct GX_PARM_CONVERTVARIANTBYPATH 00359 { 00360 gxVARIANT root; 00361 const wchar_t *path; 00362 int id; 00363 int type; 00364 int size; 00365 int nitems; 00366 void *target; 00367 int tgtlen; 00368 }; 00369 00370 struct GX_PARM_CONVERTVARIANTBYPATHA 00371 { 00372 gxVARIANT root; 00373 const char *path; 00374 int id; 00375 int type; 00376 int size; 00377 int nitems; 00378 void *target; 00379 int tgtlen; 00380 }; 00381 00382 #endif /* GX_SWIGIF GX_MANUAL */ 00383 /******************************************************************************/ 00384 #ifdef GX_DOTNET 00385 #pragma unmanaged 00386 #endif 00387 /******************************************************************************/ 00388 #if !defined(NO_GX_FUNCTIONS) && !defined(GX_SWIGIF) 00389 /******************************************************************************/ 00390 00395 /******************************************************************************/ 00407 inline int gx_refvariant(gxVARIANT variant) 00408 { 00409 gxHANDLE nullhandle = { 0 }; 00410 assert(variant); 00411 return gx_call(nullhandle, GX_CALL_REFVARIANT, variant); 00412 } 00413 00414 /******************************************************************************/ 00425 inline int gx_unrefvariant(gxVARIANT variant) 00426 { 00427 gxHANDLE nullhandle = { 0 }; 00428 return gx_call(nullhandle, GX_CALL_UNREFVARIANT, variant); 00429 } 00430 00431 /******************************************************************************/ 00442 inline int gx_leavevariant(gxVARIANT *variant) 00443 { 00444 gxHANDLE nullhandle = { 0 }; 00445 int st; 00446 assert(variant); 00447 st = gx_call(nullhandle, GX_CALL_UNREFVARIANT, *variant); 00448 if(st) { 00449 *variant = (gxVARIANT)0; 00450 } 00451 return st; 00452 } 00453 00454 #define gx_disposevariant gx_leavevariant 00455 00456 /******************************************************************************/ 00470 inline int gx_duplicatevariant(gxVARIANT *target, gxVARIANT source) 00471 { 00472 gxHANDLE nullhandle = { 0 }; 00473 struct GX_PARM_DUPLICATEVARIANT dv; 00474 int st; 00475 assert(target); 00476 dv.source = source; 00477 st = gx_call(nullhandle, GX_CALL_DUPLICATEVARIANT, &dv); 00478 if(st) { 00479 *target = dv.target; 00480 } 00481 return st; 00482 } 00483 00489 /******************************************************************************/ 00505 inline int gx_createvariant(gxVARIANT *variant, int id, int type, int size, int nitems, const void *data) 00506 { 00507 gxHANDLE nullhandle = { 0 }; 00508 struct GX_PARM_CREATEVARIANT cv; 00509 int st; 00510 assert(variant); 00511 cv.variant = (gxVARIANT)0; 00512 cv.id = id; 00513 cv.type = type; 00514 cv.size = size; 00515 cv.nitems = nitems; 00516 cv.data = data; 00517 st = gx_call(nullhandle, GX_CALL_CREATEVARIANT, &cv); 00518 if(st) { 00519 *variant = cv.variant; 00520 } 00521 return st; 00522 } 00523 00524 /******************************************************************************/ 00538 inline int gx_updatevariant(gxVARIANT *variant, int id, int type, int size, int nitems, const void *data) 00539 { 00540 gxHANDLE nullhandle = { 0 }; 00541 struct GX_PARM_UPDATEVARIANT uv; 00542 int st; 00543 uv.variant = *variant; 00544 uv.id = id; 00545 uv.type = type; 00546 uv.size = size; 00547 uv.nitems = nitems; 00548 uv.data = data; 00549 st = gx_call(nullhandle, GX_CALL_UPDATEVARIANT, &uv); 00550 *variant = uv.variant; 00551 return st; 00552 } 00553 00554 /******************************************************************************/ 00574 inline int gx_updatevariantdata(gxVARIANT variant, int id, int type, int size, int nitems, const void *data) 00575 { 00576 gxHANDLE nullhandle = { 0 }; 00577 struct GX_PARM_UPDATEVARIANTDATA uv; 00578 assert(variant); 00579 uv.variant = variant; 00580 uv.id = id; 00581 uv.type = type; 00582 uv.size = size; 00583 uv.nitems = nitems; 00584 uv.data = data; 00585 return gx_call(nullhandle, GX_CALL_UPDATEVARIANTDATA, &uv); 00586 } 00587 00588 /******************************************************************************/ 00599 inline int gx_changevariantid(gxVARIANT variant, int id) 00600 { 00601 gxHANDLE nullhandle = { 0 }; 00602 struct GX_PARM_UPDATEVARIANTID uv; 00603 assert(variant); 00604 uv.variant = variant; 00605 uv.id = id; 00606 return gx_call(nullhandle, GX_CALL_UPDATEVARIANTID, &uv); 00607 } 00608 00609 #define gx_updatevariantid gx_changevariantid 00610 00611 /******************************************************************************/ 00624 inline int gx_getvariant(gxVARIANT variant, int *id, int *type, int *size, 00625 int *nitems, int *nchildren) 00626 { 00627 gxHANDLE nullhandle = { 0 }; 00628 struct GX_PARM_GETVARIANT gv; 00629 int st; 00630 gv.variant = variant; 00631 st = gx_call(nullhandle, GX_CALL_GETVARIANT, &gv); 00632 if(st) { 00633 if(id) *id = gv.id; 00634 if(type) *type = gv.type; 00635 if(size) *size = gv.size; 00636 if(nitems) *nitems = gv.nitems; 00637 if(nchildren) *nchildren = gv.nchildren; 00638 } 00639 return st; 00640 } 00641 00642 /******************************************************************************/ 00657 inline int gx_convertvariant(gxVARIANT variant, int *id, int type, int *size, int *nitems, 00658 void *target, int tgtlen) 00659 { 00660 gxHANDLE nullhandle = { 0 }; 00661 struct GX_PARM_CONVERTVARIANT cv; 00662 int st; 00663 assert(variant); 00664 cv.variant = variant; 00665 cv.type = type; 00666 cv.size = size ? *size : tgtlen; 00667 cv.nitems = nitems ? *nitems : 1; 00668 cv.target = target; 00669 cv.tgtlen = tgtlen; 00670 st = gx_call(nullhandle, GX_CALL_CONVERTVARIANT, &cv); 00671 if(st) { 00672 if(id) *id = cv.id; 00673 if(size) *size = cv.size; 00674 if(nitems) *nitems = cv.nitems; 00675 } 00676 return st; 00677 } 00678 00684 /******************************************************************************/ 00699 inline int gx_getvariantitem(gxVARIANT list, int flags, int *id, int *ix, gxVARIANT *target) 00700 { 00701 gxHANDLE nullhandle = { 0 }; 00702 struct GX_PARM_GETVARIANTITEM gi; 00703 int st; 00704 assert(list && target); 00705 gi.list = list; 00706 gi.flags = flags; 00707 gi.id = id ? *id : 0; 00708 gi.ix = ix ? *ix : 0; 00709 st = gx_call(nullhandle, GX_CALL_GETVARIANTITEM, &gi); 00710 if(st) { 00711 if(id) *id = gi.id; 00712 if(ix) *ix = gi.ix; 00713 *target = gi.target; 00714 } 00715 return st; 00716 } 00717 00718 #ifdef __cplusplus 00719 /******************************************************************************/ 00733 inline int gx_getvariantitem(gxVARIANT list, int flags, int id, int ix, gxVARIANT *target) 00734 { 00735 return gx_getvariantitem(list, flags, &id, &ix, target); 00736 } 00737 #endif 00738 00739 /******************************************************************************/ 00754 inline int gx_cutvariantitem(gxVARIANT list, int flags, int id, int ix, gxVARIANT *target) 00755 { 00756 gxHANDLE nullhandle = { 0 }; 00757 struct GX_PARM_CUTVARIANTITEM ci; 00758 int st; 00759 assert(list); 00760 ci.list = list; 00761 ci.flags = flags; 00762 ci.id = id; 00763 ci.ix = ix; 00764 st = gx_call(nullhandle, GX_CALL_CUTVARIANTITEM, &ci); 00765 if(st) { 00766 if(target) *target = ci.target; 00767 else gx_leavevariant(&ci.target); 00768 } 00769 return st; 00770 } 00771 00772 /******************************************************************************/ 00781 inline int gx_findvariantitem(gxVARIANT list, gxVARIANT item, int *id, int *ix) 00782 { 00783 gxHANDLE nullhandle = { 0 }; 00784 struct GX_PARM_FINDVARIANTITEM fi; 00785 int st; 00786 assert(list && item); 00787 fi.list = list; 00788 fi.item = item; 00789 st = gx_call(nullhandle, GX_CALL_FINDVARIANTITEM, &fi); 00790 if(st) { 00791 if(id) *id = fi.id; 00792 if(ix) *ix = fi.ix; 00793 } 00794 return st; 00795 } 00796 00797 /******************************************************************************/ 00810 inline int gx_addvariantitem(gxVARIANT list, int flags, int id, int ix, gxVARIANT item) 00811 { 00812 gxHANDLE nullhandle = { 0 }; 00813 struct GX_PARM_ADDVARIANTITEM iv; 00814 assert(list && item); 00815 iv.list = list; 00816 iv.flags = flags; 00817 iv.id = id; 00818 iv.ix = ix; 00819 iv.item = item; 00820 return gx_call(nullhandle, GX_CALL_ADDVARIANTITEM, &iv); 00821 } 00822 00823 /******************************************************************************/ 00832 inline int gx_removevariantitem(gxVARIANT list, int flags, int id, int ix) 00833 { 00834 gxHANDLE nullhandle = { 0 }; 00835 struct GX_PARM_REMOVEVARIANTITEM ri; 00836 ri.list = list; 00837 ri.flags = flags; 00838 ri.id = id; 00839 ri.ix = ix; 00840 return gx_call(nullhandle, GX_CALL_REMOVEVARIANTITEM, &ri); 00841 } 00842 00843 /******************************************************************************/ 00860 inline int gx_createvariantitem(gxVARIANT *variant, int id, int type, int size, 00861 int nitems, const void *data, gxVARIANT list) 00862 { 00863 gxVARIANT tmp; 00864 if(!variant) variant = &tmp; 00865 *variant = 0; 00866 if(!gx_createvariant(variant, id, type, size, nitems, data)) return 0; 00867 if(!gx_addvariantitem(list, _GX_VARIANT_LAST, 0, 0, *variant)) { 00868 gx_pusherror(); 00869 gx_leavevariant(variant); 00870 gx_poperror(); 00871 return 0; 00872 } 00873 return gx_unrefvariant(*variant); 00874 } 00875 00876 /******************************************************************************/ 00892 inline int gx_convertvariantitem(gxVARIANT variant, int id, int ix, int type, 00893 int *size, int *nitems, void *target, int tgtlen) 00894 { 00895 gxVARIANT fval = 0; 00896 int st; 00897 assert(target && tgtlen>0); 00898 if(!gx_getvariantitem(variant, _GX_VARIANT_BY_ORDER_AND_ID, &id, &ix, &fval)) return 0; 00899 st = gx_convertvariant(fval, 0, type, size, nitems, target, tgtlen); 00900 if(!st) gx_pusherror(); 00901 gx_leavevariant(&fval); 00902 if(!st) gx_poperror(); 00903 return st; 00904 } 00905 00911 /******************************************************************************/ 00926 inline int gx_getvariantchild(gxVARIANT parent, int flags, int *id, int *ix, gxVARIANT *target) 00927 { 00928 gxHANDLE nullhandle = { 0 }; 00929 struct GX_PARM_GETVARIANTCHILD gc; 00930 int st; 00931 assert(parent && target); 00932 gc.parent = parent; 00933 gc.flags = flags; 00934 gc.id = id ? *id : 0; 00935 gc.ix = ix ? *ix : 0; 00936 st = gx_call(nullhandle, GX_CALL_GETVARIANTCHILD, &gc); 00937 if(st) { 00938 if(id) *id = gc.id; 00939 if(ix) *ix = gc.ix; 00940 *target = gc.target; 00941 } 00942 return st; 00943 } 00944 00945 #ifdef __cplusplus 00946 /******************************************************************************/ 00960 inline int gx_getvariantchild(gxVARIANT parent, int flags, int id, int ix, gxVARIANT *target) 00961 { 00962 return gx_getvariantchild(parent, flags, &id, &ix, target); 00963 } 00964 #endif 00965 00966 /******************************************************************************/ 00981 inline int gx_cutvariantchild(gxVARIANT parent, int flags, int id, int ix, gxVARIANT *target) 00982 { 00983 gxHANDLE nullhandle = { 0 }; 00984 struct GX_PARM_CUTVARIANTCHILD cc; 00985 int st; 00986 assert(parent); 00987 cc.parent = parent; 00988 cc.flags = flags; 00989 cc.id = id; 00990 cc.ix = ix; 00991 st = gx_call(nullhandle, GX_CALL_CUTVARIANTCHILD, &cc); 00992 if(st) { 00993 if(target) *target = cc.target; 00994 else gx_leavevariant(&cc.target); 00995 } 00996 return st; 00997 } 00998 00999 /******************************************************************************/ 01008 inline int gx_findvariantchild(gxVARIANT parent, gxVARIANT child, int *id, int *ix) 01009 { 01010 gxHANDLE nullhandle = { 0 }; 01011 struct GX_PARM_FINDVARIANTCHILD fc; 01012 int st; 01013 assert(parent && child); 01014 fc.parent = parent; 01015 fc.child = child; 01016 st = gx_call(nullhandle, GX_CALL_FINDVARIANTCHILD, &fc); 01017 if(st) { 01018 if(id) *id = fc.id; 01019 if(ix) *ix = fc.ix; 01020 } 01021 return st; 01022 } 01023 01024 /******************************************************************************/ 01037 inline int gx_addvariantchild(gxVARIANT parent, int flags, int id, int ix, gxVARIANT child) 01038 { 01039 gxHANDLE nullhandle = { 0 }; 01040 struct GX_PARM_ADDVARIANTCHILD ic; 01041 assert(parent && child); 01042 ic.parent = parent; 01043 ic.flags = flags; 01044 ic.id = id; 01045 ic.ix = ix; 01046 ic.child = child; 01047 return gx_call(nullhandle, GX_CALL_ADDVARIANTCHILD, &ic); 01048 } 01049 01050 /******************************************************************************/ 01059 inline int gx_removevariantchild(gxVARIANT parent, int flags, int id, int ix) 01060 { 01061 gxHANDLE nullhandle = { 0 }; 01062 struct GX_PARM_REMOVEVARIANTCHILD rc; 01063 rc.parent = parent; 01064 rc.flags = flags; 01065 rc.id = id; 01066 rc.ix = ix; 01067 return gx_call(nullhandle, GX_CALL_REMOVEVARIANTCHILD, &rc); 01068 } 01069 01070 /******************************************************************************/ 01087 inline int gx_createvariantchild(gxVARIANT *variant, int id, int type, int size, 01088 int nitems, const void *data, gxVARIANT parent) 01089 { 01090 gxVARIANT tmp; 01091 if(!variant) variant = &tmp; 01092 *variant = 0; 01093 if(!gx_createvariant(variant, id, type, size, nitems, data)) return 0; 01094 if(!gx_addvariantchild(parent, _GX_VARIANT_LAST, 0, 0, *variant)) { 01095 gx_pusherror(); 01096 gx_leavevariant(variant); 01097 gx_poperror(); 01098 return 0; 01099 } 01100 return gx_unrefvariant(*variant); 01101 } 01102 01103 /******************************************************************************/ 01119 inline int gx_convertvariantchild(gxVARIANT variant, int id, int ix, int type, 01120 int *size, int *nitems, void *target, int tgtlen) 01121 { 01122 gxVARIANT fval = 0; 01123 int st; 01124 assert(target && tgtlen>0); 01125 if(!gx_getvariantchild(variant, _GX_VARIANT_BY_ORDER_AND_ID, &id, &ix, &fval)) return 0; 01126 st = gx_convertvariant(fval, 0, type, size, nitems, target, tgtlen); 01127 if(!st) gx_pusherror(); 01128 gx_leavevariant(&fval); 01129 if(!st) gx_poperror(); 01130 return st; 01131 } 01132 01134 #ifdef GX_DOTNET 01135 #define GX_VARIANT_TYPES int 01136 #endif 01137 01141 /******************************************************************************/ 01154 inline int gx_getvariantvalue(gxVARIANT varray, int size, GX_VARIANT_TYPES type, int ix, int nitems, 01155 void *target, int tgtlen) 01156 { 01157 gxHANDLE nullhandle = { 0 }; 01158 struct GX_PARM_GETVARIANTVALUE gv; 01159 assert(varray); 01160 gv.array = varray; 01161 gv.size = size; 01162 gv.type = type; 01163 gv.ix = ix; 01164 gv.nitems = nitems; 01165 gv.target = target; 01166 gv.tgtlen = tgtlen; 01167 return gx_call(nullhandle, GX_CALL_GETVARIANTVALUE, &gv); 01168 } 01169 01170 /******************************************************************************/ 01184 inline int gx_cutvariantvalue(gxVARIANT varray, int size, GX_VARIANT_TYPES type, int ix, int nitems, 01185 void *target GX_DEFARG(0), int tgtlen GX_DEFARG(0)) 01186 { 01187 gxHANDLE nullhandle = { 0 }; 01188 struct GX_PARM_CUTVARIANTVALUE gv; 01189 assert(varray); 01190 gv.array = varray; 01191 gv.size = size; 01192 gv.type = type; 01193 gv.ix = ix; 01194 gv.nitems = nitems; 01195 gv.target = target; 01196 gv.tgtlen = tgtlen; 01197 return gx_call(nullhandle, GX_CALL_CUTVARIANTVALUE, &gv); 01198 } 01199 01200 /******************************************************************************/ 01211 inline int gx_addvariantvalue(gxVARIANT varray, int size, GX_VARIANT_TYPES type, int ix, int nitems, 01212 const void *data) 01213 { 01214 gxHANDLE nullhandle = { 0 }; 01215 struct GX_PARM_ADDVARIANTVALUE av; 01216 assert(varray); 01217 av.array = varray; 01218 av.size = size; 01219 av.type = type; 01220 av.ix = ix; 01221 av.nitems = nitems; 01222 av.data = data; 01223 return gx_call(nullhandle, GX_CALL_ADDVARIANTVALUE, &av); 01224 } 01225 01226 /******************************************************************************/ 01234 inline int gx_removevariantvalue(gxVARIANT array, int ix, int nitems) 01235 { 01236 gxHANDLE nullhandle = { 0 }; 01237 struct GX_PARM_REMOVEVARIANTVALUE rv; 01238 rv.array = array; 01239 rv.ix = ix; 01240 rv.nitems = nitems; 01241 return gx_call(nullhandle, GX_CALL_REMOVEVARIANTVALUE, &rv); 01242 } 01243 01245 #ifdef GX_DOTNET 01246 #undef GX_VARIANT_TYPES 01247 #endif 01248 01252 /******************************************************************************/ 01294 inline int gx_getvariantbypath(gxVARIANT root, const wchar_t *path, gxVARIANT *item) 01295 { 01296 gxHANDLE nullhandle = { 0 }; 01297 struct GX_PARM_GETVARIANTBYPATH gp; 01298 int st; 01299 assert(root && item); 01300 gp.root = root; 01301 gp.path = path; 01302 st = gx_call(nullhandle, GX_CALL_GETVARIANTBYPATH, &gp); 01303 if(st) { 01304 *item = gp.item; 01305 } 01306 return st; 01307 } 01308 01309 /******************************************************************************/ 01351 inline int gx_getvariantbypatha(gxVARIANT root, const char *path, gxVARIANT *item) 01352 { 01353 gxHANDLE nullhandle = { 0 }; 01354 struct GX_PARM_GETVARIANTBYPATHA gp; 01355 int st; 01356 assert(root && item); 01357 gp.root = root; 01358 gp.path = path; 01359 st = gx_call(nullhandle, GX_CALL_GETVARIANTBYPATHA, &gp); 01360 if(st) { 01361 *item = gp.item; 01362 } 01363 return st; 01364 } 01365 01366 #ifdef __cplusplus 01367 01376 inline int gx_getvariantbypath(gxVARIANT root, const char *path, gxVARIANT *item) 01377 { 01378 return gx_getvariantbypatha(root, path, item); 01379 } 01380 #endif 01381 01382 /******************************************************************************/ 01431 inline int gx_convertvariantbypath(gxVARIANT root, const wchar_t *path, int *id, 01432 int type, int *size, int *nitems, void *target, int tgtlen) 01433 { 01434 gxHANDLE nullhandle = { 0 }; 01435 struct GX_PARM_CONVERTVARIANTBYPATH cp; 01436 int st; 01437 assert(root && target && tgtlen>0); 01438 cp.root = root; 01439 cp.path = path; 01440 cp.type = type; 01441 cp.size = size ? *size : tgtlen; 01442 cp.nitems = nitems ? *nitems : 1; 01443 cp.target = target; 01444 cp.tgtlen = tgtlen; 01445 st = gx_call(nullhandle, GX_CALL_CONVERTVARIANTBYPATH, &cp); 01446 if(st) { 01447 if(id) *id = cp.id; 01448 if(size) *size = cp.size; 01449 if(nitems) *nitems = cp.nitems; 01450 } 01451 return st; 01452 } 01453 01454 /******************************************************************************/ 01503 inline int gx_convertvariantbypatha(gxVARIANT root, const char *path, int *id, 01504 int type, int *size, int *nitems, void *target, int tgtlen) 01505 { 01506 gxHANDLE nullhandle = { 0 }; 01507 struct GX_PARM_CONVERTVARIANTBYPATHA cp; 01508 int st; 01509 assert(root && target && tgtlen>0); 01510 cp.root = root; 01511 cp.path = path; 01512 cp.type = type; 01513 cp.size = size ? *size : tgtlen; 01514 cp.nitems = nitems ? *nitems : 1; 01515 cp.target = target; 01516 cp.tgtlen = tgtlen; 01517 st = gx_call(nullhandle, GX_CALL_CONVERTVARIANTBYPATHA, &cp); 01518 if(st) { 01519 if(id) *id = cp.id; 01520 if(size) *size = cp.size; 01521 if(nitems) *nitems = cp.nitems; 01522 } 01523 return st; 01524 } 01525 01526 #ifdef __cplusplus 01527 01542 inline int gx_convertvariantbypath(gxVARIANT root, const char *path, int *id, 01543 int type, int *size, int *nitems, void *target, int tgtlen) 01544 { 01545 return gx_convertvariantbypatha(root, path, id, type, size, nitems, target, tgtlen); 01546 } 01547 #endif 01548 01551 #endif 01552 01553 /******************************************************************************/ 01554 #ifdef GX_DOTNET 01555 #pragma managed 01556 #endif 01557 /******************************************************************************/ 01558 01559 /******************************************************************************/ 01560 #if !defined(NO_GX_CLASSES) && !defined(ANDROID) 01561 /******************************************************************************/ 01562 #ifndef GX_EXT_MODULE 01563 /******************************************************************************/ 01565 GX_CLASS gxVariant 01566 #ifdef GX_DOTNET 01567 : public System::IDisposable 01568 #endif 01569 { 01570 public: 01571 01572 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL) 01573 01574 #ifdef GX_DOTNET 01575 #ifndef GX_DOTNET_20 01576 private public: 01577 #else 01578 internal: 01579 #endif 01580 #endif 01581 gxVARIANT _variant; 01582 #endif /* GX_SWIGIF */ 01583 #ifndef GX_SWIGIF 01584 01587 inline explicit gxVariant(gxVARIANT source) { 01588 if(!gx_refvariant(source)) gxthrow; 01589 _variant = source; 01590 } 01591 #endif 01592 01593 #ifdef GX_DOTNET 01594 public: 01600 inline gxOutPtr _get_variant(void) GX_CONST { 01601 return GX_PUTPTR(_variant); 01602 } 01608 inline void _set_variant(gxInPtr ptr) { 01609 _variant = (gxVARIANT)GX_GETPTR(ptr); 01610 } 01611 #endif 01612 01613 public: 01615 inline gxVariant() { 01616 _variant = (gxVARIANT)0; 01617 } 01618 01619 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) 01620 01623 inline gxVariant(gxVariant &source) { 01624 if(!gx_refvariant(source)) gxthrow; 01625 _variant = source._variant; 01626 } 01627 #endif 01628 01629 inline ~gxVariant() gxFuncThrowsError { 01630 _Dispose(); 01631 } 01632 #ifdef GX_DOTNET_20 01633 inline !gxVariant() gxFuncThrowsError { 01634 _Dispose(); 01635 } 01636 #else 01637 01638 inline void Dispose(void) { 01639 #ifdef GX_DOTNET 01640 System::GC::SuppressFinalize(this); 01641 #endif 01642 _Dispose(); 01644 } 01645 #endif 01646 01647 private: 01648 01650 inline void _Dispose(void) { 01651 gxVARIANT t = _variant; 01652 if(t && !gx_disposevariant(&t)) gxthrow; 01653 _variant = 0; 01654 } 01655 01656 public: 01657 01661 inline bool Ref(void) gxFuncThrowsError { 01662 bool st = gx_refvariant(_variant) ? true : false; 01663 gxcondthrow(!st); 01664 return st; 01665 } 01666 01670 inline bool Unref(void) gxFuncThrowsError { 01671 bool st = gx_unrefvariant(_variant) ? true : false; 01672 gxcondthrow(!st); 01673 return st; 01674 } 01675 01676 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) 01677 01681 gxVariant& operator = (gxVariant source) gxFuncThrowsError { 01682 if(!gx_refvariant(source)) gxthrow; 01683 if(_variant && !gx_unrefvariant(_variant)) { 01684 gx_pusherror(); 01685 gx_unrefvariant(source); 01686 gx_poperror(); 01687 gxthrow; 01688 } 01689 _variant = source._variant; 01690 return *this; 01691 } 01692 #endif 01693 01694 #if !defined(GX_SWIG) && !defined(GX_DOTNET) 01695 01703 inline bool Create(int id, int type, int size, int nitems, const void *data) gxFuncThrowsError { 01704 if(_variant && !gx_disposevariant(&_variant)) { 01705 gxthrow; 01706 return false; 01707 } 01708 bool st = gx_createvariant(&_variant, id, type, size, nitems, data) ? true : false; 01709 gxcondthrow(!st); 01710 return st; 01711 } 01712 #else 01713 01718 inline bool Create(int id, gxInData data) gxFuncThrowsError { 01719 GX_GETDATA(data); 01720 gxVARIANT t = _variant; 01721 if(t && !gx_disposevariant(&t)) { 01722 gxthrow; 01723 return false; 01724 } 01725 bool st = gx_createvariant(&t, id, (int)GX_ENUM_PATH(GX_VARIANT_TYPES) GX_VARIANT_UINTARRAY, 1, GX_DATALEN(data), GX_DATAPTR(data)) ? true : false; 01726 gxcondthrow(!st); 01727 _variant = t; 01728 return st; 01729 } 01730 #endif 01731 01737 inline bool CreateEmpty(int id, int type) gxFuncThrowsError { 01738 gxVARIANT t = _variant; 01739 if(t && !gx_disposevariant(&t)) { 01740 gxthrow; 01741 return false; 01742 } 01743 bool st = gx_createvariant(&t, id, type, 0, 0, (const void *)0) ? true : false; 01744 gxcondthrow(!st); 01745 _variant = t; 01746 return st; 01747 } 01748 01749 #if !defined(GX_SWIG) && !defined(GX_DOTNET) 01750 01756 inline bool Create(int id, const void *data, int size) gxFuncThrowsError { 01757 if(_variant && !gx_disposevariant(&_variant)) { 01758 gxthrow; 01759 return false; 01760 } 01761 bool st = gx_createvariant(&_variant, id, GX_VARIANT_BINARY, size, 1, data) ? true : false; 01762 gxcondthrow(!st); 01763 return st; 01764 } 01765 01771 inline bool Create(int id, gxi8 data) gxFuncThrowsError { 01772 if(_variant && !gx_disposevariant(&_variant)) { 01773 gxthrow; 01774 return false; 01775 } 01776 bool st = gx_createvariant(&_variant, id, GX_VARIANT_INT, sizeof(data), 1, &data) ? true : false; 01777 gxcondthrow(!st); 01778 return st; 01779 } 01780 01786 inline bool Create(int id, gxi16 data) gxFuncThrowsError { 01787 if(_variant && !gx_disposevariant(&_variant)) { 01788 gxthrow; 01789 return false; 01790 } 01791 bool st = gx_createvariant(&_variant, id, GX_VARIANT_INT, sizeof(data), 1, &data) ? true : false; 01792 gxcondthrow(!st); 01793 return st; 01794 } 01795 01801 inline bool Create(int id, gxi32 data) gxFuncThrowsError { 01802 if(_variant && !gx_disposevariant(&_variant)) { 01803 gxthrow; 01804 return false; 01805 } 01806 bool st = gx_createvariant(&_variant, id, GX_VARIANT_INT, sizeof(data), 1, &data) ? true : false; 01807 gxcondthrow(!st); 01808 return st; 01809 } 01810 01816 inline bool Create(int id, gxi64 data) gxFuncThrowsError { 01817 if(_variant && !gx_disposevariant(&_variant)) { 01818 gxthrow; 01819 return false; 01820 } 01821 bool st = gx_createvariant(&_variant, id, GX_VARIANT_INT, sizeof(data), 1, &data) ? true : false; 01822 gxcondthrow(!st); 01823 return st; 01824 } 01825 01831 inline bool Create(int id, gxu8 data) gxFuncThrowsError { 01832 if(_variant && !gx_disposevariant(&_variant)) { 01833 gxthrow; 01834 return false; 01835 } 01836 bool st = gx_createvariant(&_variant, id, GX_VARIANT_UINT, sizeof(data), 1, &data) ? true : false; 01837 gxcondthrow(!st); 01838 return st; 01839 } 01840 01846 inline bool Create(int id, gxu16 data) gxFuncThrowsError { 01847 if(_variant && !gx_disposevariant(&_variant)) { 01848 gxthrow; 01849 return false; 01850 } 01851 bool st = gx_createvariant(&_variant, id, GX_VARIANT_UINT, sizeof(data), 1, &data) ? true : false; 01852 gxcondthrow(!st); 01853 return st; 01854 } 01855 01861 inline bool Create(int id, gxu32 data) gxFuncThrowsError { 01862 if(_variant && !gx_disposevariant(&_variant)) { 01863 gxthrow; 01864 return false; 01865 } 01866 bool st = gx_createvariant(&_variant, id, GX_VARIANT_UINT, sizeof(data), 1, &data) ? true : false; 01867 gxcondthrow(!st); 01868 return st; 01869 } 01870 01876 inline bool Create(int id, gxu64 data) gxFuncThrowsError { 01877 if(_variant && !gx_disposevariant(&_variant)) { 01878 gxthrow; 01879 return false; 01880 } 01881 bool st = gx_createvariant(&_variant, id, GX_VARIANT_UINT, sizeof(data), 1, &data) ? true : false; 01882 gxcondthrow(!st); 01883 return st; 01884 } 01885 01891 inline bool Create(int id, gxf32 data) gxFuncThrowsError { 01892 if(_variant && !gx_disposevariant(&_variant)) { 01893 gxthrow; 01894 return false; 01895 } 01896 bool st = gx_createvariant(&_variant, id, GX_VARIANT_FLOAT, sizeof(data), 1, &data) ? true : false; 01897 gxcondthrow(!st); 01898 return st; 01899 } 01900 01906 inline bool Create(int id, gxf64 data) gxFuncThrowsError { 01907 if(_variant && !gx_disposevariant(&_variant)) { 01908 gxthrow; 01909 return false; 01910 } 01911 bool st = gx_createvariant(&_variant, id, GX_VARIANT_FLOAT, sizeof(data), 1, &data) ? true : false; 01912 gxcondthrow(!st); 01913 return st; 01914 } 01915 #else 01916 01921 inline bool Create(int id, int data) gxFuncThrowsError { 01922 gxVARIANT t = _variant; 01923 if(t && !gx_disposevariant(&t)) { 01924 gxthrow; 01925 return false; 01926 } 01927 bool st = gx_createvariant(&t, id, (int)GX_ENUM_PATH(GX_VARIANT_TYPES) GX_VARIANT_INT, sizeof(data), 1, &data) ? true : false; 01928 gxcondthrow(!st); 01929 _variant = t; 01930 return st; 01931 } 01937 inline bool Create(int id, double data) gxFuncThrowsError { 01938 gxVARIANT t = _variant; 01939 if(t && !gx_disposevariant(&t)) { 01940 gxthrow; 01941 return false; 01942 } 01943 bool st = gx_createvariant(&t, id, (int)GX_ENUM_PATH(GX_VARIANT_TYPES) GX_VARIANT_FLOAT, sizeof(data), 1, &data) ? true : false; 01944 gxcondthrow(!st); 01945 _variant = t; 01946 return st; 01947 } 01948 #endif 01949 01950 #if !defined(GX_SWIG) && !defined(GX_DOTNET) 01951 01956 inline bool Create(int id, const char *ascii) gxFuncThrowsError { 01957 if(_variant && !gx_disposevariant(&_variant)) { 01958 gxthrow; 01959 return false; 01960 } 01961 int l = ascii ? 1+(int)(int)strlen(ascii) : 0; 01962 bool st = gx_createvariant(&_variant, id, GX_VARIANT_ASCII, l, 1, ascii) ? true : false; 01963 gxcondthrow(!st); 01964 return st; 01965 } 01966 01972 inline bool Create(int id, const wchar_t *unicode) gxFuncThrowsError { 01973 if(_variant && !gx_disposevariant(&_variant)) { 01974 gxthrow; 01975 return false; 01976 } 01977 int l = unicode ? 1+(int)(int)wcslen(unicode) : 0; 01978 bool st = gx_createvariant(&_variant, id, GX_VARIANT_UNICODE, l, 1, unicode) ? true : false; 01979 gxcondthrow(!st); 01980 return st; 01981 } 01982 #endif 01983 01984 #ifdef GX_ASCII 01985 01990 inline bool Create(int id, gxInAStr ascii) gxFuncThrowsError { 01991 GX_GETASTRING(_ascii, ascii); 01992 if(_variant && !gx_disposevariant(&_variant)) { 01993 gxthrow; 01994 return false; 01995 } 01996 int l = _ascii ? 1+(int)strlen(_ascii) : 0; 01997 bool st = gx_createvariant(&_variant, id, GX_VARIANT_ASCII, l, 1, _ascii) ? true : false; 01998 gxcondthrow(!st); 01999 return st; 02000 } 02001 #endif 02002 #ifdef GX_UNICODE 02003 02008 inline bool Create(int id, gxInStr unicode) gxFuncThrowsError { 02009 GX_GETSTRING(_unicode, unicode); 02010 gxVARIANT t = _variant; 02011 if(t && !gx_disposevariant(&t)) { 02012 gxthrow; 02013 return false; 02014 } 02015 int l = _unicode ? 1+(int)wcslen(_unicode) : 0; 02016 bool st = gx_createvariant(&t, id, (int)GX_ENUM_PATH(GX_VARIANT_TYPES) GX_VARIANT_UNICODE, l, 1, _unicode) ? true : false; 02017 gxcondthrow(!st); 02018 _variant = t; 02019 return st; 02020 } 02021 #endif 02022 02028 inline bool Create(int id, gxPG4 frame) gxFuncThrowsError { 02029 int nitems = 8; 02030 gxVARIANT t = _variant; 02031 if(t && !gx_disposevariant(&t)) { 02032 gxthrow; 02033 return false; 02034 } 02035 bool st = gx_createvariant(&t, id, (int)GX_ENUM_PATH(GX_VARIANT_TYPES) GX_VARIANT_INTARRAY, sizeof(int), nitems, &frame) ? true : false; 02036 gxcondthrow(!st); 02037 _variant = t; 02038 return st; 02039 } 02040 02041 #if !defined(GX_SWIG) && !defined(GX_DOTNET) 02042 02048 inline bool CreateArray(int id, const gxi8 *array, int nitems) gxFuncThrowsError { 02049 if(_variant && !gx_disposevariant(&_variant)) { 02050 gxthrow; 02051 return false; 02052 } 02053 bool st = gx_createvariant(&_variant, id, GX_VARIANT_INTARRAY, sizeof(gxi8), nitems, array) ? true : false; 02054 gxcondthrow(!st); 02055 return st; 02056 } 02057 02064 inline bool CreateArray(int id, const gxi16 *array, int nitems) gxFuncThrowsError { 02065 if(_variant && !gx_disposevariant(&_variant)) { 02066 gxthrow; 02067 return false; 02068 } 02069 bool st = gx_createvariant(&_variant, id, GX_VARIANT_INTARRAY, sizeof(gxi16), nitems, array) ? true : false; 02070 gxcondthrow(!st); 02071 return st; 02072 } 02073 02080 inline bool CreateArray(int id, const gxi32 *array, int nitems) gxFuncThrowsError { 02081 if(_variant && !gx_disposevariant(&_variant)) { 02082 gxthrow; 02083 return false; 02084 } 02085 bool st = gx_createvariant(&_variant, id, GX_VARIANT_INTARRAY, sizeof(gxi32), nitems, array) ? true : false; 02086 gxcondthrow(!st); 02087 return st; 02088 } 02089 02096 inline bool CreateArray(int id, const gxi64 *array, int nitems) gxFuncThrowsError { 02097 if(_variant && !gx_disposevariant(&_variant)) { 02098 gxthrow; 02099 return false; 02100 } 02101 bool st = gx_createvariant(&_variant, id, GX_VARIANT_INTARRAY, sizeof(gxi64), nitems, array) ? true : false; 02102 gxcondthrow(!st); 02103 return st; 02104 } 02105 02112 inline bool CreateArray(int id, const gxu8 *array, int nitems) gxFuncThrowsError { 02113 if(_variant && !gx_disposevariant(&_variant)) { 02114 gxthrow; 02115 return false; 02116 } 02117 bool st = gx_createvariant(&_variant, id, GX_VARIANT_UINTARRAY, sizeof(gxu8), nitems, array) ? true : false; 02118 gxcondthrow(!st); 02119 return st; 02120 } 02121 02128 inline bool CreateArray(int id, const gxu16 *array, int nitems) gxFuncThrowsError { 02129 if(_variant && !gx_disposevariant(&_variant)) { 02130 gxthrow; 02131 return false; 02132 } 02133 bool st = gx_createvariant(&_variant, id, GX_VARIANT_UINTARRAY, sizeof(gxu16), nitems, array) ? true : false; 02134 gxcondthrow(!st); 02135 return st; 02136 } 02137 02144 inline bool CreateArray(int id, const gxu32 *array, int nitems) gxFuncThrowsError { 02145 if(_variant && !gx_disposevariant(&_variant)) { 02146 gxthrow; 02147 return false; 02148 } 02149 bool st = gx_createvariant(&_variant, id, GX_VARIANT_UINTARRAY, sizeof(gxu32), nitems, array) ? true : false; 02150 gxcondthrow(!st); 02151 return st; 02152 } 02153 02160 inline bool CreateArray(int id, const gxu64 *array, int nitems) gxFuncThrowsError { 02161 if(_variant && !gx_disposevariant(&_variant)) { 02162 gxthrow; 02163 return false; 02164 } 02165 bool st = gx_createvariant(&_variant, id, GX_VARIANT_UINTARRAY, sizeof(gxu64), nitems, array) ? true : false; 02166 gxcondthrow(!st); 02167 return st; 02168 } 02169 02170 02177 inline bool CreateArray(int id, const gxf32 *array, int nitems) gxFuncThrowsError { 02178 if(_variant && !gx_disposevariant(&_variant)) { 02179 gxthrow; 02180 return false; 02181 } 02182 bool st = gx_createvariant(&_variant, id, GX_VARIANT_FLOATARRAY, sizeof(gxf32), nitems, array) ? true : false; 02183 gxcondthrow(!st); 02184 return st; 02185 } 02186 02193 inline bool CreateArray(int id, const gxf64 *array, int nitems) gxFuncThrowsError { 02194 if(_variant && !gx_disposevariant(&_variant)) { 02195 gxthrow; 02196 return false; 02197 } 02198 bool st = gx_createvariant(&_variant, id, GX_VARIANT_FLOATARRAY, sizeof(gxf64), nitems, array) ? true : false; 02199 gxcondthrow(!st); 02200 return st; 02201 } 02202 #endif 02203 02208 inline bool CreateEmptyList(int id) gxFuncThrowsError { 02209 gxVARIANT t = _variant; 02210 if(t && !gx_disposevariant(&t)) { 02211 gxthrow; 02212 return false; 02213 } 02214 bool st = gx_createvariant(&t, id, (int)GX_ENUM_PATH(GX_VARIANT_TYPES) GX_VARIANT_LIST, 0, 0, 0) ? true : false; 02215 gxcondthrow(!st); 02216 _variant = t; 02217 return st; 02218 } 02219 02220 #if !defined(GX_SWIG) && !defined(GX_DOTNET) 02221 02225 inline bool Create(gxVARIANT source) gxFuncThrowsError { 02226 if(_variant && !gx_disposevariant(&_variant)) { 02227 gxthrow; 02228 return false; 02229 } 02230 bool st = gx_duplicatevariant(&_variant, source) ? true : false; 02231 gxcondthrow(!st); 02232 return st; 02233 } 02234 #endif 02235 02240 inline bool Create(gxVariant GX_REF_CLASS(source)) gxFuncThrowsError { 02241 gxVARIANT t = _variant; 02242 gxVARIANT s = source GX_M _variant; 02243 if(t && !gx_disposevariant(&t)) { 02244 gxthrow; 02245 return false; 02246 } 02247 bool st = gx_duplicatevariant(&t, s) ? true : false; 02248 gxcondthrow(!st); 02249 _variant = t; 02250 return st; 02251 } 02252 02253 /******************************************************************************/ 02254 02255 #if !defined(GX_MANUAL) 02256 #if !defined(GX_SWIG) && !defined(GX_DOTNET) 02257 inline bool _Get(int *id, int *type, int *size, int *nitems, int *nchildren) gxFuncThrowsError { 02258 bool st = gx_getvariant(_variant, id, type, size, nitems, nchildren) ? true : false; 02259 gxcondthrow(!st); 02260 return st; 02261 } 02262 #endif 02263 #endif 02264 02266 inline int GetID(void) gxFuncThrowsError { 02267 int ret = -1; 02268 if(!gx_getvariant(_variant, &ret, 0, 0, 0, 0)) gxthrow; 02269 return ret; 02270 } 02271 02273 inline int GetType(void) gxFuncThrowsError { 02274 int ret = 0; 02275 if(!gx_getvariant(_variant, 0, &ret, 0, 0, 0)) gxthrow; 02276 return ret; 02277 } 02278 02280 inline int GetSize(void) gxFuncThrowsError { 02281 int ret = 0; 02282 if(!gx_getvariant(_variant, 0, 0, &ret, 0, 0)) gxthrow; 02283 return ret; 02284 } 02285 02287 inline int GetNItems(void) gxFuncThrowsError { 02288 int ret = 0; 02289 if(!gx_getvariant(_variant, 0, 0, 0, &ret, 0)) gxthrow; 02290 return ret; 02291 } 02292 02294 inline int GetNChildren(void) gxFuncThrowsError { 02295 int ret = 0; 02296 if(!gx_getvariant(_variant, 0, 0, 0, 0, &ret)) gxthrow; 02297 return ret; 02298 } 02299 02301 inline int GetInt(void) gxFuncThrowsError { 02302 int size = sizeof(int), nitems = 1, ret = 0; 02303 if(!gx_convertvariant(_variant, 0, (int)GX_ENUM_PATH(GX_VARIANT_TYPES) GX_VARIANT_INT, &size, &nitems, &ret, sizeof(ret))) gxthrow; 02304 return ret; 02305 } 02306 02308 inline unsigned int GetUInt(void) gxFuncThrowsError { 02309 int size = sizeof(int), nitems = 1; 02310 unsigned int ret = 0; 02311 if(!gx_convertvariant(_variant, 0, (int)GX_ENUM_PATH(GX_VARIANT_TYPES) GX_VARIANT_UINT, &size, &nitems, &ret, sizeof(ret))) gxthrow; 02312 return ret; 02313 } 02314 02316 inline gxu64 GetULInt(void) gxFuncThrowsError { 02317 int size = sizeof(gxu64), nitems = 1; 02318 gxu64 ret = 0; 02319 if(!gx_convertvariant(_variant, 0, (int)GX_ENUM_PATH(GX_VARIANT_TYPES) GX_VARIANT_UINT, &size, &nitems, &ret, sizeof(ret))) gxthrow; 02320 return ret; 02321 } 02322 02323 02325 inline double GetFloat(void) gxFuncThrowsError { 02326 int size = sizeof(double), nitems = 1; 02327 double ret = 0; 02328 if(!gx_convertvariant(_variant, 0, (int)GX_ENUM_PATH(GX_VARIANT_TYPES) GX_VARIANT_FLOAT, &size, &nitems, &ret, sizeof(ret))) gxthrow; 02329 return ret; 02330 } 02331 02332 #if !defined(GX_SWIG) && !defined(GX_DOTNET) 02333 02338 inline int GetASCII(char *target, int tgtlen) gxFuncThrowsError { 02339 int size = tgtlen, nitems = 1; 02340 if(!gx_convertvariant(_variant, 0, GX_VARIANT_ASCII, &size, &nitems, target, tgtlen)) gxthrow; 02341 return size; 02342 } 02343 02349 inline int GetUnicode(wchar_t *target, int tgtlen) gxFuncThrowsError { 02350 int size = tgtlen, nitems = 1; 02351 if(!gx_convertvariant(_variant, 0, GX_VARIANT_UNICODE, &size, &nitems, target, tgtlen*sizeof(wchar_t))) gxthrow; 02352 return size; 02353 } 02354 #endif 02355 #ifdef GX_UNICODE 02356 02360 inline gxOutStr GetUnicode(int tgtlen) gxFuncThrowsError { 02361 wchar_t *buffer; 02362 int size = tgtlen, nitems = 1; 02363 if(tgtlen < 1) return GX_PUTSTRING_NONE; 02364 if(!gx_globalalloc((void **)(void *)&buffer, sizeof(wchar_t)*(tgtlen+1))) { 02365 gxthrow; 02366 return GX_PUTSTRING_NONE; 02367 } 02368 if(!gx_convertvariant(_variant, 0, (int)GX_ENUM_PATH(GX_VARIANT_TYPES) GX_VARIANT_UNICODE, &size, &nitems, buffer, tgtlen*sizeof(wchar_t))) { 02369 gx_globalfree(buffer); 02370 gxthrow; 02371 return GX_PUTSTRING_NONE; 02372 } 02373 buffer[tgtlen] = 0; 02374 gxOutStr ret = GX_PUTSTRING(buffer); 02375 gx_globalfree(buffer); 02376 return ret; 02377 } 02378 #endif 02379 #ifdef GX_ASCII 02380 02384 inline gxOutAStr GetASCII(int tgtlen) gxFuncThrowsError { 02385 char *buffer; 02386 int size = tgtlen, nitems = 1; 02387 if(tgtlen < 1) return GX_PUTASTRING_NONE; 02388 if(!gx_globalalloc((void **)(void *)&buffer, sizeof(char)*(tgtlen+1))) { 02389 gxthrow; 02390 return GX_PUTASTRING_NONE; 02391 } 02392 if(!gx_convertvariant(_variant, 0, GX_VARIANT_ASCII, &size, &nitems, buffer, tgtlen*sizeof(char))) { 02393 gx_globalfree(buffer); 02394 gxthrow; 02395 return GX_PUTASTRING_NONE; 02396 } 02397 buffer[tgtlen] = 0; 02398 gxOutAStr ret = GX_PUTASTRING(buffer); 02399 gx_globalfree(buffer); 02400 return ret; 02401 } 02402 #endif 02403 02404 #if defined(GX_SWIG) || defined(GX_DOTNET) 02405 inline gxOutData GetByteArray() gxFuncThrowsError { 02406 02407 int size, nitems, tgtlen; 02408 02409 if(!gx_getvariant(_variant, 0, 0, &size, &nitems, 0)) { 02410 gxthrow; 02411 return GX_PUTDATA_NONE; 02412 } 02413 if(!(tgtlen=nitems*=size)) { 02414 return GX_PUTDATA_NONE; 02415 } 02416 size = 1; 02417 gxu8 *target = (gxu8*)malloc(nitems); 02418 if(!target) { 02419 gx_seterror((int)GX_ENUM_PATH(GX_ERROR_CODES) GX_ENOMEM); 02420 gxthrow; 02421 return GX_PUTDATA_NONE; 02422 } 02423 if(!gx_convertvariant(_variant, 0, (int)GX_ENUM_PATH(GX_VARIANT_TYPES) GX_VARIANT_UINTARRAY, &size, &nitems, target, tgtlen)) { 02424 free(target); 02425 gxthrow; 02426 return GX_PUTDATA_NONE; 02427 } 02428 gxOutData ret = GX_PUTDATA(target, tgtlen); 02429 free(target); 02430 return ret; 02431 } 02432 #endif 02433 02434 #if !defined(GX_SWIG) && !defined(GX_DOTNET) 02435 02443 inline int Convert(int type, int *size, int *nitems, void *target, int tgtlen) gxFuncThrowsError { 02444 int ret = 0; 02445 if(!gx_convertvariant(_variant, 0, type, size, nitems, target, tgtlen)) { 02446 gxthrow; 02447 } else { 02448 ret = nitems ? *nitems : 0; 02449 } 02450 return ret; 02451 } 02452 #endif 02453 02454 /******************************************************************************/ 02455 02466 inline bool GetItem(gxVariant GX_REF_CLASS(target), int flags, int id, int ix) gxFuncThrowsError { 02467 gxVARIANT t; 02468 bool st = gx_getvariantitem(_variant, flags, &id, &ix, &t)!=0; 02469 gxcondthrow(!st); 02470 if(st) { 02471 gxVARIANT t2 = target GX_M _variant; 02472 if(t2 && !gx_disposevariant(&t2)) { 02473 st = false; 02474 } else { 02475 st = gx_duplicatevariant(&t2, t) ? true : false; 02476 } 02477 if(st) { 02478 st = gx_disposevariant(&t) ? true : false; 02479 } 02480 gxcondthrow(!st); 02481 target GX_M _variant = t2; 02482 } 02483 return st; 02484 } 02485 02496 inline bool CutItem(gxVariant GX_REF_CLASS(target), int flags, int id, int ix) gxFuncThrowsError { 02497 gxVARIANT t; 02498 bool st = gx_cutvariantitem(_variant, flags, id, ix, &t)!=0; 02499 gxcondthrow(!st); 02500 if(st) { 02501 gxVARIANT t2 = target GX_M _variant; 02502 if(t2 && !gx_disposevariant(&t2)) { 02503 st = false; 02504 } else { 02505 st = gx_duplicatevariant(&t2, t) ? true : false; 02506 } 02507 if(st) { 02508 st = gx_disposevariant(&t) ? true : false; 02509 } 02510 gxcondthrow(!st); 02511 target GX_M _variant = t2; 02512 } 02513 return st; 02514 } 02515 02520 inline int FindItem(gxVariant GX_REF_CLASS(item)) { 02521 int ix,id; 02522 gxVARIANT t = item GX_M _variant; 02523 int st = gx_findvariantitem(_variant, t, &id, &ix); 02524 gxcondthrow(!st); 02525 return st ? ix : -1; 02526 } 02527 02535 inline bool AddItem(int flags, int id, int ix, gxVariant GX_REF_CLASS(item)) { 02536 bool st = gx_addvariantitem(_variant, flags, id, ix, item GX_M _variant) ? true : false; 02537 gxcondthrow(!st); 02538 return st; 02539 } 02540 02547 inline bool RemoveItem(int flags, int id, int ix) gxFuncThrowsError { 02548 bool st = gx_removevariantitem(_variant, flags, id, ix) ? true : false; 02549 gxcondthrow(!st); 02550 return st; 02551 } 02552 02553 /******************************************************************************/ 02554 02562 inline bool GetChild(gxVariant GX_REF_CLASS(target), int flags, int id, int ix) gxFuncThrowsError { 02563 gxVARIANT t; 02564 bool st = gx_getvariantchild(_variant, flags, id, ix, &t) ? true : false; 02565 gxcondthrow(!st); 02566 if(st) { 02567 gxVARIANT t2 = target GX_M _variant; 02568 if(t2 && !gx_disposevariant(&t2)) { 02569 st = false; 02570 } else { 02571 st = gx_duplicatevariant(&t2, t) ? true : false; 02572 } 02573 if(st) { 02574 st = gx_disposevariant(&t) ? true : false; 02575 } 02576 gxcondthrow(!st); 02577 target GX_M _variant = t2; 02578 } 02579 return st; 02580 } 02581 02589 inline bool CutChild(gxVariant GX_REF_CLASS(target), int flags, int id, int ix) gxFuncThrowsError { 02590 gxVARIANT t; 02591 bool st = gx_cutvariantchild(_variant, flags, id, ix, &t) ? true : false; 02592 gxcondthrow(!st); 02593 if(st) { 02594 gxVARIANT t2 = target GX_M _variant; 02595 if(t2 && !gx_disposevariant(&t2)) { 02596 st = false; 02597 } else { 02598 st = gx_duplicatevariant(&t2, t) ? true : false; 02599 } 02600 if(st) { 02601 st = gx_disposevariant(&t) ? true : false; 02602 } 02603 gxcondthrow(!st); 02604 target GX_M _variant = t2; 02605 } 02606 return st; 02607 } 02608 02613 inline int FindChild(gxVariant GX_REF_CLASS(item)) { 02614 int ix,id; 02615 gxVARIANT t = item GX_M _variant; 02616 int st = gx_findvariantchild(_variant, t, &id, &ix); 02617 gxcondthrow(!st); 02618 return st ? ix : -1; 02619 } 02620 02628 inline bool AddChild(int flags, int id, int ix, gxVariant GX_REF_CLASS(item)) { 02629 bool st = gx_addvariantchild(_variant, flags, id, ix, item GX_M _variant) ? true : false; 02630 gxcondthrow(!st); 02631 return st; 02632 } 02633 02640 inline bool RemoveChild(int flags, int id, int ix) gxFuncThrowsError { 02641 bool st = gx_removevariantitem(_variant, flags, id, ix) ? true : false; 02642 gxcondthrow(!st); 02643 return st; 02644 } 02645 02646 /******************************************************************************/ 02647 #ifndef GX_DOTNET 02648 02654 inline bool CreateList(int id, ...) gxFuncThrowsError { 02655 if(_variant && !gx_disposevariant(&_variant)) { 02656 gxthrow; 02657 return false; 02658 } 02659 02660 bool st = gx_createvariant(&_variant, id, GX_VARIANT_LIST, 0, 0, 0) ? true : false; 02661 if(!st) { 02662 gxthrow; 02663 return false; 02664 } 02665 02666 va_list(args); 02667 va_start(args, id); 02668 gxVARIANT val; 02669 int itype=0, iid, isize, initems; 02670 const void *idata; 02671 while(itype >= 0) { 02672 itype = va_arg(args, int); 02673 if(itype < 0) break; 02674 iid = va_arg(args, int); 02675 isize = va_arg(args, int); 02676 initems = va_arg(args, int); 02677 idata = va_arg(args, const void *); 02678 02679 st = gx_createvariant(&val, iid, itype, isize, initems, idata) ? true : false; 02680 if(!st) { 02681 va_end(args); 02682 gxthrow; 02683 return false; 02684 } 02685 02686 st = gx_addvariantitem(_variant, GX_VARIANT_LAST, 0, 0, val) ? true : false; 02687 gx_disposevariant(&val); 02688 if(!st) { 02689 va_end(args); 02690 gxthrow; 02691 return false; 02692 } 02693 } 02694 va_end(args); 02695 return true; 02696 } 02697 02698 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) 02699 02700 inline operator gxVARIANT & () gxFuncThrowsError { 02701 return _variant; 02702 } 02703 #endif 02704 /* 02705 inline operator gxVARIANT * () gxFuncThrowsError { 02706 return &_variant; 02707 } 02708 inline operator const gxVARIANT * () const gxFuncThrowsError { 02709 return &_variant; 02710 } 02711 */ 02712 02713 #endif 02714 02715 #if !defined(GX_SWIG) && !defined(GX_DOTNET) 02716 /******************************************************************************/ 02722 inline bool GetIntValue(int ix, int nitems, int *target) gxFuncThrowsError { 02723 bool st = gx_getvariantvalue(_variant, sizeof(int), GX_VARIANT_INT, ix, nitems, 02724 target, sizeof(int)*nitems) ? true : false; 02725 gxcondthrow(!st); 02726 return st; 02727 } 02728 02729 /******************************************************************************/ 02735 inline bool GetUIntValue(int ix, int nitems, unsigned int *target) gxFuncThrowsError { 02736 bool st = gx_getvariantvalue(_variant, sizeof(unsigned int), GX_VARIANT_UINT, ix, nitems, 02737 target, sizeof(unsigned int)*nitems) ? true : false; 02738 gxcondthrow(!st); 02739 return st; 02740 } 02741 02742 /******************************************************************************/ 02748 inline bool GetFloatValue(int ix, int nitems, double *target) gxFuncThrowsError { 02749 bool st = gx_getvariantvalue(_variant, sizeof(double), GX_VARIANT_FLOAT, ix, nitems, 02750 target, sizeof(double)*nitems) ? true : false; 02751 gxcondthrow(!st); 02752 return st; 02753 } 02754 02755 /******************************************************************************/ 02761 inline bool CutIntValue(int ix, int nitems, int *target) gxFuncThrowsError { 02762 bool st = gx_cutvariantvalue(_variant, sizeof(int), GX_VARIANT_INT, ix, nitems, 02763 target, sizeof(int)*nitems) ? true : false; 02764 gxcondthrow(!st); 02765 return st; 02766 } 02767 02768 /******************************************************************************/ 02774 inline bool CutUIntValue(int ix, int nitems, unsigned int *target) gxFuncThrowsError { 02775 bool st = gx_cutvariantvalue(_variant, sizeof(unsigned int), GX_VARIANT_UINT, ix, nitems, 02776 target, sizeof(unsigned int)*nitems) ? true : false; 02777 gxcondthrow(!st); 02778 return st; 02779 } 02780 02781 /******************************************************************************/ 02787 inline bool CutFloatValue(int ix, int nitems, double *target) gxFuncThrowsError { 02788 bool st = gx_cutvariantvalue(_variant, sizeof(double), GX_VARIANT_FLOAT, ix, nitems, 02789 target, sizeof(double)*nitems) ? true : false; 02790 gxcondthrow(!st); 02791 return st; 02792 } 02793 02794 /******************************************************************************/ 02800 inline bool AddIntValue(int ix, int nitems, const int *data) gxFuncThrowsError { 02801 bool st = gx_addvariantvalue(_variant, sizeof(int), GX_VARIANT_INT, ix, nitems, data) ? true : false; 02802 gxcondthrow(!st); 02803 return st; 02804 } 02805 02811 inline bool AddUIntValue(int ix, int nitems, const unsigned int *data) gxFuncThrowsError { 02812 bool st = gx_addvariantvalue(_variant, sizeof(int), GX_VARIANT_UINT, ix, nitems, data) ? true : false; 02813 gxcondthrow(!st); 02814 return st; 02815 } 02816 02822 inline bool AddFloatValue(int ix, int nitems, const double *data) gxFuncThrowsError { 02823 bool st = gx_addvariantvalue(_variant, sizeof(double), GX_VARIANT_FLOAT, ix, nitems, data) ? true : false; 02824 gxcondthrow(!st); 02825 return st; 02826 } 02827 02828 02833 inline bool RemoveValue(int ix, int nitems) gxFuncThrowsError { 02834 bool st = gx_removevariantvalue(_variant, ix, nitems) ? true : false; 02835 gxcondthrow(!st); 02836 return st; 02837 } 02838 02839 #endif 02840 02841 /******************************************************************************/ 02843 inline gxPG4 GetGxPG4() gxFuncThrowsError { 02844 int val[8]; 02845 memset(val, 0, sizeof(val)); 02846 int size = sizeof(int); 02847 int nitems = 8; 02848 bool st = gx_convertvariant(_variant, 0, (int)GX_ENUM_PATH(GX_VARIANT_TYPES) GX_VARIANT_INTARRAY, &size, &nitems, 02849 val, sizeof(val)) ? true : false; 02850 gxcondthrow(!st); 02851 if(!st) st = false; 02852 gxPG4 pg4; 02853 pg4.x1 = val[0]; 02854 pg4.y1 = val[1]; 02855 pg4.x2 = val[2]; 02856 pg4.y2 = val[3]; 02857 pg4.x3 = val[4]; 02858 pg4.y3 = val[5]; 02859 pg4.x4 = val[6]; 02860 pg4.y4 = val[7]; 02861 return pg4; 02862 } 02863 02864 /******************************************************************************/ 02865 02866 #if !defined(GX_SWIG) && !defined(GX_DOTNET) 02867 02893 inline bool GetItemByPath(gxVariant &target, const wchar_t *path) gxFuncThrowsError { 02894 gxVARIANT t; 02895 bool st = gx_getvariantbypath(_variant, path, &t)!=0; 02896 gxcondthrow(!st); 02897 if(st) { 02898 gxVARIANT t2 = target._variant; 02899 if(t2 && !gx_disposevariant(&t2)) { 02900 st = false; 02901 } else { 02902 st = gx_duplicatevariant(&t2, t) ? true : false; 02903 } 02904 if(st) { 02905 st = gx_disposevariant(&t) ? true : false; 02906 } 02907 gxcondthrow(!st); 02908 target._variant = t2; 02909 } 02910 return st; 02911 } 02912 02939 inline bool GetItemByPath(gxVariant &target, const char *path) gxFuncThrowsError { 02940 gxVARIANT t; 02941 bool st = gx_getvariantbypath(_variant, path, &t)!=0; 02942 gxcondthrow(!st); 02943 if(st) { 02944 gxVARIANT t2 = target._variant; 02945 if(t2 && !gx_disposevariant(&t2)) { 02946 st = false; 02947 } else { 02948 st = gx_duplicatevariant(&t2, t) ? true : false; 02949 } 02950 if(st) { 02951 st = gx_disposevariant(&t) ? true : false; 02952 } 02953 gxcondthrow(!st); 02954 target._variant = t2; 02955 } 02956 return st; 02957 } 02958 #endif 02959 02960 #ifdef GX_UNICODE 02961 02987 inline bool GetItemByPath(gxVariant GX_REF_CLASS(target), gxInStr path) gxFuncThrowsError { 02988 gxVARIANT t; 02989 GX_GETSTRING(_path, path); 02990 bool st = gx_getvariantbypath(_variant, _path, &t)!=0; 02991 gxcondthrow(!st); 02992 if(st) { 02993 gxVARIANT t2 = target GX_M _variant; 02994 if(t2 && !gx_disposevariant(&t2)) { 02995 st = false; 02996 } else { 02997 st = gx_duplicatevariant(&t2, t) ? true : false; 02998 } 02999 if(st) { 03000 st = gx_disposevariant(&t) ? true : false; 03001 } 03002 gxcondthrow(!st); 03003 target GX_M _variant = t2; 03004 } 03005 return st; 03006 } 03007 #endif 03008 03009 #ifdef GX_ASCII 03010 03036 inline bool GetItemByPath(gxVariant &target, gxInAStr path) gxFuncThrowsError { 03037 gxVARIANT t; 03038 GX_GETASTRING(_path, path); 03039 bool st = gx_getvariantbypath(_variant, _path, &t)!=0; 03040 gxcondthrow(!st); 03041 if(st) { 03042 gxVARIANT t2 = target._variant; 03043 if(t2 && !gx_disposevariant(&t2)) { 03044 st = false; 03045 } else { 03046 st = gx_duplicatevariant(&t2, t) ? true : false; 03047 } 03048 if(st) { 03049 st = gx_disposevariant(&t) ? true : false; 03050 } 03051 gxcondthrow(!st); 03052 target._variant = t2; 03053 } 03054 return st; 03055 } 03056 #endif 03057 03058 }; 03059 /******************************************************************************/ 03060 #endif /* GX_EXT_MODULE */ 03061 /******************************************************************************/ 03062 #endif /* NO_GX_CLASSES && !ANDROID */ 03063 /******************************************************************************/ 03064 #ifdef GX_NAMESPACES 03065 } /* namespace */ 03066 #endif 03067 #ifdef __BORLANDC__ 03068 #pragma warn .rch 03069 #endif 03070 /******************************************************************************/ 03071 #endif 03072 /******************************************************************************/