00001
00002
00003
00004
00005
00015
00016 #ifndef GX_PROPERTY_INCL
00017 #define GX_PROPERTY_INCL
00018
00019 #ifdef _MSC_VER
00020 #pragma warning(push)
00021 #pragma warning(disable : 4786)
00022 #endif
00023
00024 #include "gxsd.h"
00025 #include <wchar.h>
00026
00027 #ifdef GX_NAMESPACES
00028 namespace gx {
00029 #endif
00030
00031 #ifdef GX_DOTNET
00032 #pragma managed
00033 #endif
00034
00036 GX_ENUM GX_PROPERTYTYPES {
00037 GX_PROPERTY_INVALID = 0,
00038 GX_PROPERTY_NOVALUE = 1,
00039 GX_PROPERTY_DIRECT = 2,
00040 GX_PROPERTY_INHERIT = 3,
00041 GX_PROPERTY_DEFAULT = 4
00042 };
00043
00044 #ifdef GX_DOTNET
00045 #pragma unmanaged
00046 #endif
00047
00048 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL)
00049
00050 enum {
00051 GX_CALL_GETPROPERTY = GX_CALL_GROUP_GX_PROPERTY | 0x0000,
00052 #ifndef ANDROID
00053 GX_CALL_GETPROPERTYA,
00054 #endif
00055 GX_CALL_SETPROPERTY,
00056 #ifndef ANDROID
00057 GX_CALL_SETPROPERTYA,
00058 #endif
00059 GX_CALL_GETPROPERTYTYPE,
00060 #ifndef ANDROID
00061 GX_CALL_GETPROPERTYTYPEA,
00062 #endif
00063 GX_CALL_RMPROPERTIES,
00064 #ifndef ANDROID
00065 GX_CALL_RMPROPERTIESA,
00066 #endif
00067 GX_CALL_GETPROPERTIES,
00068 #ifndef ANDROID
00069 GX_CALL_GETPROPERTIESA,
00070 #endif
00071 GX_CALL_GETALLPROPERTIES,
00072 #ifndef ANDROID
00073 GX_CALL_GETALLPROPERTIESA,
00074 #endif
00075 GX_CALL_GETPROPERTYPARENT,
00076 #ifndef ANDROID
00077 GX_CALL_GETPROPERTYPARENTA,
00078 #endif
00079 GX_CALL_SETPROPERTYPARENT,
00080 #ifndef ANDROID
00081 GX_CALL_SETPROPERTYPARENTA,
00082 #endif
00083
00084 GX_CALL_LOADPROPERTIES = GX_CALL_GROUP_GX_PROPERTY | 0x1000,
00085 #ifndef ANDROID
00086 GX_CALL_LOADPROPERTIESA,
00087 #endif
00088 GX_CALL_SAVEPROPERTIES,
00089 #ifndef ANDROID
00090 GX_CALL_SAVEPROPERTIESA,
00091 #endif
00092 GX_CALL_FLUSHPROPERTIES
00093 };
00094
00095
00097 struct GX_PARM_GETPROPERTY {
00098 const wchar_t *name;
00099 wchar_t *string;
00100 int maxlen;
00101 };
00102
00103 #ifndef ANDROID
00104
00105 struct GX_PARM_GETPROPERTYA {
00106 const char *name;
00107 char *string;
00108 int maxlen;
00109 };
00110 #endif
00111
00113 struct GX_PARM_SETPROPERTY {
00114 const wchar_t *name;
00115 const wchar_t *string;
00116 };
00117
00118 #ifndef ANDROID
00119
00120 struct GX_PARM_SETPROPERTYA {
00121 const char *name;
00122 const char *string;
00123 };
00124 #endif
00125
00127 struct GX_PARM_GETPROPERTYTYPE {
00128 const wchar_t *name;
00129 int type;
00130 };
00131
00132 #ifndef ANDROID
00133
00134 struct GX_PARM_GETPROPERTYTYPEA {
00135 const char *name;
00136 int type;
00137 };
00138 #endif
00139
00141 struct GX_PARM_RMPROPERTIES {
00142 const wchar_t *name;
00143 };
00144
00145 #ifndef ANDROID
00146
00147 struct GX_PARM_RMPROPERTIESA {
00148 const char *name;
00149 };
00150 #endif
00151
00153 struct GX_PARM_GETPROPERTIES {
00154 const wchar_t *name;
00155 wchar_t *string;
00156 int maxlen;
00157 };
00158
00159 #ifndef ANDROID
00160
00161 struct GX_PARM_GETPROPERTIESA {
00162 const char *name;
00163 char *string;
00164 int maxlen;
00165 };
00166 #endif
00167
00169 struct GX_PARM_GETALLPROPERTIES {
00170 const wchar_t *name;
00171 wchar_t *string;
00172 int maxlen;
00173 };
00174
00175 #ifndef ANDROID
00176
00177 struct GX_PARM_GETALLPROPERTIESA {
00178 const char *name;
00179 char *string;
00180 int maxlen;
00181 };
00182 #endif
00183
00185 struct GX_PARM_GETPROPERTYPARENT {
00186 const wchar_t *name;
00187 wchar_t *string;
00188 int maxlen;
00189 };
00190
00191 #ifndef ANDROID
00192
00193 struct GX_PARM_GETPROPERTYPARENTA {
00194 const char *name;
00195 char *string;
00196 int maxlen;
00197 };
00198 #endif
00199
00201 struct GX_PARM_SETPROPERTYPARENT {
00202 const wchar_t *name;
00203 const wchar_t *string;
00204 };
00205
00206 #ifndef ANDROID
00207
00208 struct GX_PARM_SETPROPERTYPARENTA {
00209 const char *name;
00210 const char *string;
00211 };
00212 #endif
00213
00215 struct GX_PARM_LOADPROPERTIES {
00216 const wchar_t *filename;
00217 };
00218
00219 #ifndef ANDROID
00220
00221 struct GX_PARM_LOADPROPERTIESA {
00222 const char *filename;
00223 };
00224 #endif
00225
00227 struct GX_PARM_SAVEPROPERTIES {
00228 const wchar_t *filename;
00229 int unicode;
00230 };
00231
00232 #ifndef ANDROID
00233
00234 struct GX_PARM_SAVEPROPERTIESA {
00235 const char *filename;
00236 int unicode;
00237 };
00238 #endif
00239 #endif
00240
00241
00242 #if !defined(NO_GX_FUNCTIONS) && !defined(GX_SWIGIF)
00243
00244
00245
00249
00250
00251
00264 inline int gx_getproperty(gxHANDLE handle, const wchar_t *name,
00265 wchar_t *string, int maxlen) {
00266
00267 struct GX_PARM_GETPROPERTY gp;
00268 gp.name = name;
00269 gp.string = string;
00270 gp.maxlen = maxlen;
00271 return gx_call(handle, GX_CALL_GETPROPERTY, &gp);
00272 }
00273
00274 #ifndef ANDROID
00275
00288 inline int gx_getpropertya(gxHANDLE handle, const char *name,
00289 char *string, int maxlen) {
00290
00291 struct GX_PARM_GETPROPERTYA gp;
00292 gp.name = name;
00293 gp.string = string;
00294 gp.maxlen = maxlen;
00295 return gx_call(handle, GX_CALL_GETPROPERTYA, &gp);
00296 }
00297
00298 #ifdef __cplusplus
00299
00312 inline int gx_getproperty(gxHANDLE handle, const char *name,
00313 char *string, int maxlen) {
00314 return gx_getpropertya(handle, name, string, maxlen);
00315 }
00316 #endif
00317 #endif
00318
00330 inline int gx_getpropertyint(gxHANDLE handle, const wchar_t *name, int *ivalue) {
00331 wchar_t ibuf[GX_MAXLEN_INT];
00332 ibuf[GX_MAXLEN_INT-1] = 0;
00333 if(!gx_getproperty(handle, name, ibuf, GX_MAXLEN_INT-1)) return false;
00334 if(ivalue) *ivalue = gx_wcstol(ibuf, 0, 10);
00335 return true;
00336 }
00337
00338 #ifdef __cplusplus
00339
00351 inline int gx_getproperty(gxHANDLE handle, const wchar_t *name, int *ivalue) {
00352 return gx_getpropertyint(handle, name, ivalue);
00353 }
00354 #endif
00355
00356 #ifndef ANDROID
00357
00369 inline int gx_getpropertyinta(gxHANDLE handle, const char *name, int *ivalue) {
00370 char ibuf[GX_MAXLEN_INT];
00371 ibuf[GX_MAXLEN_INT-1] = 0;
00372 if(!gx_getpropertya(handle, name, ibuf, GX_MAXLEN_INT-1)) return false;
00373 if(ivalue) *ivalue = atoi(ibuf);
00374 return true;
00375 }
00376
00377 #ifdef __cplusplus
00378
00390 inline int gx_getproperty(gxHANDLE handle, const char *name, int *ivalue) {
00391 return gx_getpropertyinta(handle, name, ivalue);
00392 }
00393
00394
00406 inline int gx_getpropertyint(gxHANDLE handle, const char *name, int *ivalue) {
00407 return gx_getpropertyinta(handle, name, ivalue);
00408 }
00409 #endif
00410 #endif
00411
00423 inline int gx_getpropertyfloat(gxHANDLE handle, const wchar_t *name, double *fvalue) {
00424 wchar_t fbuf[GX_MAXLEN_FLOAT];
00425 fbuf[GX_MAXLEN_FLOAT-1] = 0;
00426 if(!gx_getproperty(handle, name, fbuf, GX_MAXLEN_FLOAT-1)) return false;
00427 if(fvalue) *fvalue = wcstod(fbuf, 0);
00428 return true;
00429 }
00430
00431 #ifdef __cplusplus
00432
00444 inline int gx_getproperty(gxHANDLE handle, const wchar_t *name, double *fvalue) {
00445 return gx_getpropertyfloat(handle, name, fvalue);
00446 }
00447 #endif
00448
00449 #ifndef ANDROID
00450
00462 inline int gx_getpropertyfloata(gxHANDLE handle, const char *name, double *fvalue) {
00463 char fbuf[GX_MAXLEN_FLOAT];
00464 fbuf[GX_MAXLEN_FLOAT-1] = 0;
00465 if(!gx_getpropertya(handle, name, fbuf, sizeof(fbuf)-1)) return false;
00466 if(fvalue) *fvalue = atof(fbuf);
00467 return true;
00468 }
00469
00470 #ifdef __cplusplus
00471
00483 inline int gx_getproperty(gxHANDLE handle, const char *name, double *fvalue) {
00484 return gx_getpropertyfloata(handle, name, fvalue);
00485 }
00486
00487
00499 inline int gx_getpropertyfloat(gxHANDLE handle, const char *name, double *fvalue) {
00500 return gx_getpropertyfloata(handle, name, fvalue);
00501 }
00502 #endif
00503 #endif
00504
00515 inline int gx_setproperty(gxHANDLE handle, const wchar_t *name, const wchar_t *string) {
00516 struct GX_PARM_SETPROPERTY sp;
00517 sp.name = name;
00518 sp.string = string;
00519 return gx_call(handle, GX_CALL_SETPROPERTY, &sp);
00520 }
00521
00522 #ifndef ANDROID
00523
00534 inline int gx_setpropertya(gxHANDLE handle, const char *name, const char *string) {
00535 struct GX_PARM_SETPROPERTYA sp;
00536 sp.name = name;
00537 sp.string = string;
00538 return gx_call(handle, GX_CALL_SETPROPERTYA, &sp);
00539 }
00540
00541 #ifdef __cplusplus
00542
00553 inline int gx_setproperty(gxHANDLE handle, const char *name, const char *string) {
00554 return gx_setpropertya(handle, name, string);
00555 }
00556 #endif
00557 #endif
00558
00571 inline int gx_setpropertyint(gxHANDLE handle, const wchar_t *name, int ivalue) {
00572 wchar_t ibuf[GX_MAXLEN_INT];
00573 gx_snwprintf(ibuf, GX_MAXLEN_INT, L"%i", ivalue);
00574 ibuf[GX_MAXLEN_INT-1] = 0;
00575 return gx_setproperty(handle, name, ibuf);
00576 }
00577
00578 #ifdef __cplusplus
00579
00592 inline int gx_setproperty(gxHANDLE handle, const wchar_t *name, int ivalue) {
00593 return gx_setpropertyint(handle, name, ivalue);
00594 }
00595 #endif
00596
00597 #ifndef ANDROID
00598
00611 inline int gx_setpropertyinta(gxHANDLE handle, const char *name, int ivalue) {
00612 char ibuf[GX_MAXLEN_INT];
00613 gx_snprintf(ibuf, GX_MAXLEN_INT, "%i", ivalue);
00614 ibuf[GX_MAXLEN_INT-1] = 0;
00615 return gx_setpropertya(handle, name, ibuf);
00616 }
00617
00618 #ifdef __cplusplus
00619
00632 inline int gx_setproperty(gxHANDLE handle, const char *name, int ivalue) {
00633 return gx_setpropertyinta(handle, name, ivalue);
00634 }
00635
00636
00649 inline int gx_setpropertyint(gxHANDLE handle, const char *name, int ivalue) {
00650 return gx_setpropertyinta(handle, name, ivalue);
00651 }
00652 #endif
00653 #endif
00654
00667 inline int gx_setpropertyfloat(gxHANDLE handle, const wchar_t *name, double fvalue) {
00668 wchar_t fbuf[GX_MAXLEN_FLOAT];
00669 gx_snwprintf(fbuf, GX_MAXLEN_FLOAT, L"%f", fvalue);
00670 fbuf[GX_MAXLEN_FLOAT-1] = 0;
00671 return gx_setproperty(handle, name, fbuf);
00672 }
00673
00674 #ifdef __cplusplus
00675
00688 inline int gx_setproperty(gxHANDLE handle, const wchar_t *name, double fvalue) {
00689 return gx_setpropertyfloat(handle, name, fvalue);
00690 }
00691 #endif
00692
00693 #ifndef ANDROID
00694
00707 inline int gx_setpropertyfloata(gxHANDLE handle, const char *name, double fvalue) {
00708 char fbuf[GX_MAXLEN_FLOAT];
00709 gx_snprintf(fbuf, sizeof(fbuf), "%f", fvalue);
00710 fbuf[GX_MAXLEN_FLOAT-1] = 0;
00711 return gx_setpropertya(handle, name, fbuf);
00712 }
00713
00714 #ifdef __cplusplus
00715
00728 inline int gx_setproperty(gxHANDLE handle, const char *name, double fvalue) {
00729 return gx_setpropertyfloata(handle, name, fvalue);
00730 }
00731
00732
00745 inline int gx_setpropertyfloat(gxHANDLE handle, const char *name, double fvalue) {
00746 return gx_setpropertyfloata(handle, name, fvalue);
00747 }
00748 #endif
00749 #endif
00750
00758 inline int gx_getpropertytype(gxHANDLE handle, const wchar_t *name, int *type) {
00759 struct GX_PARM_GETPROPERTYTYPE pt;
00760 int ret;
00761 pt.name = name;
00762 ret = gx_call(handle, GX_CALL_GETPROPERTYTYPE, &pt);
00763 if(ret) *type = pt.type;
00764 return ret;
00765 }
00766
00767 #ifndef ANDROID
00768
00776 inline int gx_getpropertytypea(gxHANDLE handle, const char *name, int *type) {
00777 struct GX_PARM_GETPROPERTYTYPEA pt;
00778 int ret;
00779 pt.name = name;
00780 ret = gx_call(handle, GX_CALL_GETPROPERTYTYPEA, &pt);
00781 if(ret) *type = pt.type;
00782 return ret;
00783 }
00784
00785 #ifdef __cplusplus
00786
00794 inline int gx_getpropertytype(gxHANDLE handle, const char *name, int *type) {
00795 return gx_getpropertytypea(handle, name, type);
00796 }
00797 #endif
00798 #endif
00799
00807 inline int gx_rmproperties(gxHANDLE handle, const wchar_t *name) {
00808 struct GX_PARM_RMPROPERTIES rm;
00809 rm.name = name;
00810 return gx_call(handle, GX_CALL_RMPROPERTIES, &rm);
00811 }
00812
00813 #ifndef ANDROID
00814
00822 inline int gx_rmpropertiesa(gxHANDLE handle, const char *name) {
00823 struct GX_PARM_RMPROPERTIESA rm;
00824 rm.name = name;
00825 return gx_call(handle, GX_CALL_RMPROPERTIESA, &rm);
00826 }
00827
00828 #ifdef __cplusplus
00829
00837 inline int gx_rmproperties(gxHANDLE handle, const char *name) {
00838 return gx_rmpropertiesa(handle, name);
00839 }
00840 #endif
00841 #endif
00842
00843
00854 inline int gx_getproperties(gxHANDLE handle, const wchar_t *name, wchar_t *string, int maxlen) {
00855 struct GX_PARM_GETPROPERTIES gp;
00856 gp.name = name;
00857 gp.string = string;
00858 gp.maxlen = maxlen;
00859 return gx_call(handle, GX_CALL_GETPROPERTIES, &gp);
00860 }
00861
00862 #ifndef ANDROID
00863
00874 inline int gx_getpropertiesa(gxHANDLE handle, const char *name, char *string, int maxlen) {
00875 struct GX_PARM_GETPROPERTIESA gp;
00876 gp.name = name;
00877 gp.string = string;
00878 gp.maxlen = maxlen;
00879 return gx_call(handle, GX_CALL_GETPROPERTIESA, &gp);
00880 }
00881
00882 #ifdef __cplusplus
00883
00894 inline int gx_getproperties(gxHANDLE handle, const char *name, char *string, int maxlen) {
00895 return gx_getpropertiesa(handle, name, string, maxlen);
00896 }
00897 #endif
00898 #endif
00899
00900
00901
00913 inline int gx_getallproperties(gxHANDLE handle, const wchar_t *name, wchar_t *string, int maxlen) {
00914 struct GX_PARM_GETALLPROPERTIES ap;
00915 ap.name = name;
00916 ap.string = string;
00917 ap.maxlen = maxlen;
00918 return gx_call(handle, GX_CALL_GETALLPROPERTIES, &ap);
00919 }
00920
00921 #ifndef ANDROID
00922
00934 inline int gx_getallpropertiesa(gxHANDLE handle, const char *name, char *string, int maxlen) {
00935 struct GX_PARM_GETALLPROPERTIESA ap;
00936 ap.name = name;
00937 ap.string = string;
00938 ap.maxlen = maxlen;
00939 return gx_call(handle, GX_CALL_GETALLPROPERTIESA, &ap);
00940 }
00941
00942 #ifdef __cplusplus
00943
00955 inline int gx_getallproperties(gxHANDLE handle, const char *name, char *string, int maxlen) {
00956 return gx_getallpropertiesa(handle, name, string, maxlen);
00957 }
00958 #endif
00959 #endif
00960
00961
00962
00970 inline int gx_setpropertyparent(gxHANDLE handle, const wchar_t *name, const wchar_t *string) {
00971 struct GX_PARM_SETPROPERTYPARENT pd;
00972 pd.name = name;
00973 pd.string = string;
00974 return gx_call(handle, GX_CALL_SETPROPERTYPARENT, &pd);
00975 }
00976
00977 #ifndef ANDROID
00978
00986 inline int gx_setpropertyparenta(gxHANDLE handle, const char *name, const char *string) {
00987 struct GX_PARM_SETPROPERTYPARENTA pd;
00988 pd.name = name;
00989 pd.string = string;
00990 return gx_call(handle, GX_CALL_SETPROPERTYPARENTA, &pd);
00991 }
00992
00993 #ifdef __cplusplus
00994
01002 inline int gx_setpropertyparent(gxHANDLE handle, const char *name, const char *string) {
01003 return gx_setpropertyparenta(handle, name, string);
01004 }
01005 #endif
01006 #endif
01007
01008
01017 inline int gx_getpropertyparent(gxHANDLE handle, const wchar_t *name, wchar_t *string, int maxlen) {
01018 struct GX_PARM_GETPROPERTYPARENT gd;
01019 gd.name = name;
01020 gd.string = string;
01021 gd.maxlen = maxlen;
01022 return gx_call(handle, GX_CALL_GETPROPERTYPARENT, &gd);
01023 }
01024
01025 #ifndef ANDROID
01026
01035 inline int gx_getpropertyparenta(gxHANDLE handle, const char *name, char *string, int maxlen) {
01036 struct GX_PARM_GETPROPERTYPARENTA gd;
01037 gd.name = name;
01038 gd.string = string;
01039 gd.maxlen = maxlen;
01040 return gx_call(handle, GX_CALL_GETPROPERTYPARENTA, &gd);
01041 }
01042
01043 #ifdef __cplusplus
01044
01053 inline int gx_getpropertyparent(gxHANDLE handle, const char *name, char *string, int maxlen) {
01054 return gx_getpropertyparenta(handle, name, string, maxlen);
01055 }
01056 #endif
01057 #endif
01058
01065 inline int gx_loadproperties(gxHANDLE handle, const wchar_t *name) {
01066 struct GX_PARM_LOADPROPERTIES lp;
01067 lp.filename = name;
01068 return gx_call(handle, GX_CALL_LOADPROPERTIES, &lp);
01069 }
01070
01071 #ifndef ANDROID
01072
01079 inline int gx_loadpropertiesa(gxHANDLE handle, const char *name) {
01080 struct GX_PARM_LOADPROPERTIESA lp;
01081 lp.filename = name;
01082 return gx_call(handle, GX_CALL_LOADPROPERTIESA, &lp);
01083 }
01084
01085 #ifdef __cplusplus
01086
01093 inline int gx_loadproperties(gxHANDLE handle, const char *name) {
01094 return gx_loadpropertiesa(handle, name);
01095 }
01096 #endif
01097 #endif
01098
01106 inline int gx_saveproperties(gxHANDLE handle, const wchar_t *name, int unicode) {
01107 struct GX_PARM_SAVEPROPERTIES sp;
01108 sp.filename = name;
01109 sp.unicode = unicode;
01110 return gx_call(handle, GX_CALL_SAVEPROPERTIES, &sp);
01111 }
01112
01113 #ifdef __cplusplus
01114
01121 inline int gx_saveproperties(gxHANDLE handle, const wchar_t *name) {
01122 return gx_saveproperties(handle, name, false);
01123 }
01124 #endif
01125
01126 #ifndef ANDROID
01127
01135 inline int gx_savepropertiesa(gxHANDLE handle, const char *name, int unicode GX_DEFARG(false)) {
01136 struct GX_PARM_SAVEPROPERTIESA sp;
01137 sp.filename = name;
01138 sp.unicode = unicode;
01139 return gx_call(handle, GX_CALL_SAVEPROPERTIESA, &sp);
01140 }
01141
01142 #ifdef __cplusplus
01143
01151 inline int gx_saveproperties(gxHANDLE handle, const char *name, int unicode GX_DEFARG(false)) {
01152 return gx_savepropertiesa(handle, name, unicode);
01153 }
01154 #endif
01155 #endif
01156
01162 inline int gx_flushproperties(gxHANDLE handle) {
01163 return gx_call(handle, GX_CALL_FLUSHPROPERTIES, (void *)0);
01164 }
01165
01166 #ifdef __cplusplus
01167
01179 inline int gx_getproperty(const wchar_t *name, wchar_t *string, int maxlen) {
01180 return gx_getproperty(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, string, maxlen);
01181 }
01182
01183 #ifndef ANDROID
01184
01196 inline int gx_getproperty(const char *name, char *string, int maxlen) {
01197 return gx_getproperty(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, string, maxlen);
01198 }
01199 #endif
01200
01211 inline int gx_getproperty(const wchar_t *name, int *ivalue) {
01212 return gx_getproperty(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, ivalue);
01213 }
01214
01215 #ifndef ANDROID
01216
01227 inline int gx_getproperty(const char *name, int *ivalue) {
01228 return gx_getproperty(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, ivalue);
01229 }
01230 #endif
01231
01242 inline int gx_getproperty(const wchar_t *name, double *fvalue) {
01243 return gx_getproperty(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, fvalue);
01244 }
01245
01246 #ifndef ANDROID
01247
01258 inline int gx_getproperty(const char *name, double *fvalue) {
01259 return gx_getproperty(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, fvalue);
01260 }
01261 #endif
01262
01263
01273 inline int gx_setproperty(const wchar_t *name, const wchar_t *string) {
01274 return gx_setproperty(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, string);
01275 }
01276
01277 #ifndef ANDROID
01278
01288 inline int gx_setproperty(const char *name, const char *string) {
01289 return gx_setproperty(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, string);
01290 }
01291 #endif
01292
01304 inline int gx_setproperty(const wchar_t *name, int ivalue) {
01305 return gx_setproperty(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, ivalue);
01306 }
01307
01308 #ifndef ANDROID
01309
01321 inline int gx_setproperty(const char *name, int ivalue) {
01322 return gx_setproperty(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, ivalue);
01323 }
01324 #endif
01325
01337 inline int gx_setproperty(const wchar_t *name, double fvalue) {
01338 return gx_setproperty(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, fvalue);
01339 }
01340
01341 #ifndef ANDROID
01342
01354 inline int gx_setproperty(const char *name, double fvalue) {
01355 return gx_setproperty(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, fvalue);
01356 }
01357 #endif
01358
01365 inline int gx_getpropertytype(const wchar_t *name, int *type) {
01366 return gx_getpropertytype(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, type);
01367 }
01368
01369 #ifndef ANDROID
01370
01377 inline int gx_getpropertytype(const char *name, int *type) {
01378 return gx_getpropertytype(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, type);
01379 }
01380 #endif
01381
01388 inline int gx_rmproperties(const wchar_t *name) {
01389 return gx_rmproperties(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name);
01390 }
01391
01392 #ifndef ANDROID
01393
01400 inline int gx_rmproperties(const char *name) {
01401 return gx_rmproperties(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name);
01402 }
01403 #endif
01404
01405
01415 inline int gx_getproperties(const wchar_t *name, wchar_t *string, int maxlen) {
01416 return gx_getproperties(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, string, maxlen);
01417 }
01418 #ifndef ANDROID
01419
01429 inline int gx_getproperties(const char *name, char *string, int maxlen) {
01430 return gx_getproperties(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, string, maxlen);
01431 }
01432 #endif
01433
01434
01445 inline int gx_getallproperties(const wchar_t *name, wchar_t *string, int maxlen) {
01446 return gx_getallproperties(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, string, maxlen);
01447 }
01448
01449 #ifndef ANDROID
01450
01461 inline int gx_getallproperties(const char *name, char *string, int maxlen) {
01462 return gx_getallproperties(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, string, maxlen);
01463 }
01464 #endif
01465
01466
01473 inline int gx_setpropertyparent(const wchar_t *name, const wchar_t *string) {
01474 return gx_setpropertyparent(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, string);
01475 }
01476
01477 #ifndef ANDROID
01478
01485 inline int gx_setpropertyparent(const char *name, const char *string) {
01486 return gx_setpropertyparent(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, string);
01487 }
01488 #endif
01489
01490
01498 inline int gx_getpropertyparent(const wchar_t *name, wchar_t *string, int maxlen) {
01499 return gx_getpropertyparent(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, string, maxlen);
01500 }
01501
01502 #ifndef ANDROID
01503
01511 inline int gx_getpropertyparent(const char *name, char *string, int maxlen) {
01512 return gx_getpropertyparent(gx_direct(GX_CALL_GROUP_GX_PROPERTY), name, string, maxlen);
01513 }
01514 #endif
01515
01520 inline int gx_flushproperties(void) {
01521 return gx_flushproperties(gx_direct(GX_CALL_GROUP_GX_PROPERTY));
01522 }
01523 #endif
01524 #endif
01525
01526
01528
01529
01530 #ifdef GX_DOTNET
01531 #pragma managed
01532 #endif
01533
01534
01535
01536 #if !defined(NO_GX_CLASSES) && !defined(ANDROID)
01537
01539 GX_CLASS gxProperty : public gxHandle {
01540 public:
01542 inline gxProperty() gxFuncThrowsError {
01543 #ifndef GX_DOTNET
01544 if(!gx_openmodule(this, L"gxproperty", L"")) gxthrow;
01545 #else
01546 GX_GETHANDLE(h);
01547 if(!gx_openmodule(&h, L"gxproperty", L"")) gxthrow;
01548 _set_handle(h.handle);
01549 #endif
01550 }
01551
01552 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
01553
01559 inline gxProperty(int groupcode) gxFuncThrowsError : gxHandle(groupcode) {
01560 }
01561
01565 inline gxProperty(const wchar_t *modname) gxFuncThrowsError {
01566 if(!gx_openmodule(this, modname ? modname : L"gxproperty", L"")) gxthrow;
01567 }
01568
01572 inline gxProperty(const char *modname) gxFuncThrowsError {
01573 if(!gx_openmodulea(this, modname ? modname : "gxproperty", "")) gxthrow;
01574 }
01575 #endif
01576 #ifdef GX_UNICODE
01577
01580 inline gxProperty(gxInStr modname) gxFuncThrowsError {
01581 GX_GETSTRING(_modname, modname);
01582 #ifndef GX_DOTNET
01583 if(!gx_openmodule(this, _modname, L"")) gxthrow;
01584 #else
01585 GX_GETHANDLE(h);
01586 if(!gx_openmodule(&h, _modname, L"")) gxthrow;
01587 _set_handle(h.handle);
01588 #endif
01589 }
01590 #endif
01591 #ifdef GX_ASCII
01592
01595 inline gxProperty(gxInAStr modname) gxFuncThrowsError {
01596 GX_GETASTRING(_modname, modname);
01597 if(!gx_openmodulea(this, _modname, "")) gxthrow;
01598 }
01599 #endif
01600
01601 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
01602
01606 inline bool Load(const wchar_t *name) gxFuncThrowsError {
01607 bool st = gx_loadproperties(*this, name) ? true : false;
01608 gxcondthrow(!st);
01609 return st;
01610 }
01611
01616 inline bool Load(const char *name) gxFuncThrowsError {
01617 bool st = gx_loadproperties(*this, name) ? true : false;
01618 gxcondthrow(!st);
01619 return st;
01620 }
01621 #endif // !GX_SWIGIF && !GX_DOTNET
01622
01623 #ifdef GX_UNICODE
01624
01628 inline bool Load(gxInStr name) gxFuncThrowsError {
01629 GX_GETSTRING(_name, name);
01630 GX_GETHANDLE(h);
01631 bool st = gx_loadproperties(h, _name) ? true : false;
01632 gxcondthrow(!st);
01633 return st;
01634 }
01635 #endif
01636 #ifdef GX_ASCII
01637
01641 inline bool Load(gxInAStr name) gxFuncThrowsError {
01642 GX_GETASTRING(_name, name);
01643 bool st = gx_loadpropertiesa(*this, _name) ? true : false;
01644 gxcondthrow(!st);
01645 return st;
01646 }
01647 #endif
01648
01649 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
01650
01655 inline bool Save(const wchar_t *name, bool unicode = false) gxFuncThrowsError {
01656 bool st = gx_saveproperties(*this, name, (int)unicode) ? true : false;
01657 gxcondthrow(!st);
01658 return st;
01659 }
01660
01666 inline bool Save(const char *name, bool unicode = false) gxFuncThrowsError {
01667 bool st = gx_saveproperties(*this, name, (int)unicode) ? true : false;
01668 gxcondthrow(!st);
01669 return st;
01670 }
01671 #endif // !GX_SWIGIF && !GX_DOTNET
01672
01673 #ifdef GX_UNICODE
01674
01679 inline bool Save(gxInStr name, bool unicode) gxFuncThrowsError {
01680 GX_GETSTRING(_name, name);
01681 GX_GETHANDLE(h);
01682 bool st = gx_saveproperties(h, _name, (int)unicode) ? true : false;
01683 gxcondthrow(!st);
01684 return st;
01685 }
01686
01691 inline bool Save(gxInStr name) gxFuncThrowsError {
01692 GX_GETSTRING(_name, name);
01693 GX_GETHANDLE(h);
01694 bool st = gx_saveproperties(h, _name, false) ? true : false;
01695 gxcondthrow(!st);
01696 return st;
01697 }
01698 #endif // GX_UNICODE
01699
01700 #ifdef GX_ASCII
01701
01706 inline bool Save(gxInAStr name, bool unicode) gxFuncThrowsError {
01707 GX_GETASTRING(_name, name);
01708 bool st = gx_saveproperties(*this, _name, (int)unicode) ? true : false;
01709 gxcondthrow(!st);
01710 return st;
01711 }
01712
01717 inline bool Save(gxInAStr name) gxFuncThrowsError {
01718 GX_GETASTRING(_name, name);
01719 bool st = gx_savepropertiesa(*this, _name, false) ? true : false;
01720 gxcondthrow(!st);
01721 return st;
01722 }
01723 #endif
01724
01728 inline bool Flush(void) gxFuncThrowsError {
01729 GX_GETHANDLE(h);
01730 bool st = gx_flushproperties(h) ? true : false;
01731 gxcondthrow(!st);
01732 return st;
01733 }
01734
01735 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
01736
01746 inline bool GetProperty(const wchar_t *name, wchar_t *string, int maxlen) gxFuncThrowsError {
01747 bool st = gx_getproperty(*this, name, string, maxlen) ? true : false;
01748 gxcondthrow(!st);
01749 return st;
01750 }
01751
01752 #if !defined(GX_SWIG) && !defined(NO_GX_STL)
01753
01762 inline std::wstring GetProperty(const wchar_t *name) gxFuncThrowsError {
01763 wchar_t buf[GX_MAXLEN_PROPVALUE+1];
01764 if(!gx_getproperty(*this, name, buf, GX_MAXLEN_PROPVALUE)) {
01765 gxthrow;
01766 buf[0] = 0;
01767 }
01768 buf[GX_MAXLEN_PROPVALUE] = 0;
01769 return std::wstring(buf);
01770 }
01771 #endif
01772
01783 inline bool GetProperty(const char *name, char *string, int maxlen) gxFuncThrowsError {
01784 bool st = gx_getproperty(*this, name, string, maxlen) ? true : false;
01785 gxcondthrow(!st);
01786 return st;
01787 }
01788
01789 #if !defined(GX_SWIG) && !defined(NO_GX_STL)
01790
01799 inline std::string GetProperty(const char *name) gxFuncThrowsError {
01800 char buf[GX_MAXLEN_PROPVALUE+1];
01801 if(!gx_getproperty(*this, name, buf, GX_MAXLEN_PROPVALUE)) {
01802 gxthrow;
01803 buf[0] = 0;
01804 }
01805 buf[GX_MAXLEN_PROPVALUE] = 0;
01806 return std::string(buf);
01807 }
01808 #endif
01809
01810 #endif
01811 #ifdef GX_UNICODE
01812
01821 inline gxOutStr GetProperty(gxInStr name) gxFuncThrowsError {
01822 wchar_t buf[GX_MAXLEN_PROPVALUE+1];
01823 GX_GETSTRING(_name, name);
01824 GX_GETHANDLE(h);
01825 if(!gx_getproperty(h, _name, buf, GX_MAXLEN_PROPVALUE)) {
01826 gxthrow;
01827 return GX_PUTSTRING_NONE;
01828 }
01829 buf[GX_MAXLEN_PROPVALUE] = 0;
01830 return GX_PUTSTRING(buf);
01831 }
01832 #endif
01833
01834 #ifdef GX_ASCII
01835
01844 inline gxOutAStr GetProperty(gxInAStr name) gxFuncThrowsError {
01845 char buf[GX_MAXLEN_PROPVALUE+1];
01846 GX_GETASTRING(_name, name);
01847 if(!gx_getpropertya(*this, _name, buf, GX_MAXLEN_PROPVALUE)) {
01848 gxthrow;
01849 return GX_PUTASTRING_NONE;
01850 }
01851 buf[GX_MAXLEN_PROPVALUE] = 0;
01852 return GX_PUTASTRING(buf);
01853 }
01854 #endif
01855
01856 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
01857
01866 inline bool GetProperty(const wchar_t *name, int *ivalue) gxFuncThrowsError {
01867 bool st = gx_getpropertyint(*this, name, ivalue) ? true : false;
01868 gxcondthrow(!st);
01869 return st;
01870 }
01871
01881 inline bool GetProperty(const char *name, int *ivalue) gxFuncThrowsError {
01882 bool st = gx_getpropertyinta(*this, name, ivalue) ? true : false;
01883 gxcondthrow(!st);
01884 return st;
01885 }
01886 #endif
01887
01888 #ifdef GX_UNICODE
01889
01898 inline int GetPropertyInt(gxInStr name) gxFuncThrowsError {
01899 int ret = -1;
01900 GX_GETSTRING(_name, name);
01901 GX_GETHANDLE(h);
01902 if(!gx_getpropertyint(h, _name, &ret)) gxthrow;
01903 return ret;
01904 }
01905 #endif
01906
01907 #ifdef GX_ASCII
01908
01917 inline int GetPropertyInt(gxInAStr name) gxFuncThrowsError {
01918 int ret = -1;
01919 GX_GETASTRING(_name, name);
01920 if(!gx_getpropertyinta(*this, _name, &ret)) gxthrow;
01921 return ret;
01922 }
01923 #endif
01924
01925 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
01926
01935 inline bool GetProperty(const wchar_t *name, double *fvalue) gxFuncThrowsError {
01936 bool st = gx_getpropertyfloat(*this, name, fvalue) ? true : false;
01937 gxcondthrow(!st);
01938 return st;
01939 }
01940
01947 inline bool GetProperty(const char *name, double *fvalue) gxFuncThrowsError {
01948 bool st = gx_getpropertyfloata(*this, name, fvalue) ? true : false;
01949 gxcondthrow(!st);
01950 return st;
01951 }
01952 #endif // !GX_SWIGIF && !GX_DOTNET
01953
01954 #ifdef GX_UNICODE
01955
01964 inline double GetPropertyFloat(gxInStr name) gxFuncThrowsError {
01965 double ret = -1;
01966 GX_GETSTRING(_name, name);
01967 GX_GETHANDLE(h);
01968 if(!gx_getpropertyfloat(h, _name, &ret)) gxthrow;
01969 return ret;
01970 }
01971 #endif
01972
01973 #ifdef GX_ASCII
01974
01983 inline double GetPropertyFloat(gxInAStr name) gxFuncThrowsError {
01984 double ret = -1;
01985 GX_GETASTRING(_name, name);
01986 if(!gx_getpropertyfloata(*this, _name, &ret)) gxthrow;
01987 return ret;
01988 }
01989 #endif
01990
01991 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
01992
02000 inline bool SetProperty(const wchar_t *name, const wchar_t *string) gxFuncThrowsError {
02001 bool st = gx_setproperty(*this, name, string) ? true : false;
02002 gxcondthrow(!st);
02003 return st;
02004 }
02005
02014 inline bool SetProperty(const char *name, const char *string) gxFuncThrowsError {
02015 bool st = gx_setpropertya(*this, name, string) ? true : false;
02016 gxcondthrow(!st);
02017 return st;
02018 }
02019
02026 inline bool ClearProperty(const wchar_t *name) gxFuncThrowsError {
02027 bool st = gx_setproperty(*this, name, (const wchar_t *)0) ? true : false;
02028 gxcondthrow(!st);
02029 return st;
02030 }
02031
02038 inline bool ClearProperty(const char *name) gxFuncThrowsError {
02039 bool st = gx_setpropertya(*this, name, (const char *)0) ? true : false;
02040 gxcondthrow(!st);
02041 return st;
02042 }
02043 #endif // !GX_SWIGIF && !GX_DOTNET
02044
02045 #ifdef GX_UNICODE
02046
02054 inline bool SetProperty(gxInStr name, gxInStr str) gxFuncThrowsError {
02055 GX_GETSTRING(_name, name);
02056 GX_GETSTRING(_str, str);
02057 GX_GETHANDLE(h);
02058 bool st = gx_setproperty(h, _name, _str) ? true : false;
02059 gxcondthrow(!st);
02060 return st;
02061 }
02062
02069 inline bool SetProperty(gxInStr name) gxFuncThrowsError {
02070 GX_GETSTRING(_name, name);
02071 GX_GETHANDLE(h);
02072 bool st = gx_setproperty(h, _name, (const wchar_t *)0) ? true : false;
02073 gxcondthrow(!st);
02074 return st;
02075 }
02076
02081 inline bool ClearProperty(gxInStr name) gxFuncThrowsError {
02082 GX_GETSTRING(_name, name);
02083 GX_GETHANDLE(h);
02084 bool st = gx_setproperty(h, _name, (const wchar_t *)0) ? true : false;
02085 gxcondthrow(!st);
02086 return st;
02087 }
02088 #endif // GX_UNICODE
02089
02090 #ifdef GX_ASCII
02091
02099 inline bool SetProperty(gxInAStr name, gxInAStr str) gxFuncThrowsError {
02100 GX_GETASTRING(_name, name);
02101 GX_GETASTRING(_str, str);
02102 bool st = gx_setpropertya(*this, _name, _str) ? true : false;
02103 gxcondthrow(!st);
02104 return st;
02105 }
02106
02113 inline bool SetProperty(gxInAStr name) gxFuncThrowsError {
02114 GX_GETASTRING(_name, name);
02115 bool st = gx_setpropertya(*this, _name, (const char *)0) ? true : false;
02116 gxcondthrow(!st);
02117 return st;
02118 }
02119
02124 inline bool ClearProperty(gxInAStr name) gxFuncThrowsError {
02125 GX_GETASTRING(_name, name);
02126 bool st = gx_setpropertya(*this, _name, (const char *)0) ? true : false;
02127 gxcondthrow(!st);
02128 return st;
02129 }
02130 #endif
02131
02132 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
02133
02143 inline bool SetProperty(const wchar_t *name, int ivalue) gxFuncThrowsError {
02144 bool st = gx_setpropertyint(*this, name, ivalue) ? true : false;
02145 gxcondthrow(!st);
02146 return st;
02147 }
02148
02159 inline bool SetProperty(const char *name, int ivalue) gxFuncThrowsError {
02160 bool st = gx_setpropertyinta(*this, name, ivalue) ? true : false;
02161 gxcondthrow(!st);
02162 return st;
02163 }
02164 #endif
02165
02166 #ifdef GX_UNICODE
02167
02177 inline bool SetProperty(gxInStr name, int ivalue) gxFuncThrowsError {
02178 GX_GETSTRING(_name, name);
02179 GX_GETHANDLE(h);
02180 bool st = gx_setpropertyint(h, _name, ivalue) ? true : false;
02181 gxcondthrow(!st);
02182 return st;
02183 }
02184 #endif
02185 #ifdef GX_ASCII
02186
02196 inline bool SetProperty(gxInAStr name, int ivalue) gxFuncThrowsError {
02197 GX_GETASTRING(_name, name);
02198 bool st = gx_setpropertyinta(*this, _name, ivalue) ? true : false;
02199 gxcondthrow(!st);
02200 return st;
02201 }
02202 #endif
02203
02204 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
02205
02215 inline bool SetProperty(const wchar_t *name, double fvalue) gxFuncThrowsError {
02216 bool st = gx_setpropertyfloat(*this, name, fvalue) ? true : false;
02217 gxcondthrow(!st);
02218 return st;
02219 }
02220
02231 inline bool SetProperty(const char *name, double fvalue) gxFuncThrowsError {
02232 bool st = gx_setproperty(*this, name, fvalue) ? true : false;
02233 gxcondthrow(!st);
02234 return st;
02235 }
02236 #endif // !GX_SWIGIF && !GX_DOTNET
02237
02238 #ifdef GX_UNICODE
02239
02249 inline bool SetProperty(gxInStr name, double fvalue) gxFuncThrowsError {
02250 GX_GETSTRING(_name, name);
02251 GX_GETHANDLE(h);
02252 bool st = gx_setpropertyfloat(h, _name, fvalue) ? true : false;
02253 gxcondthrow(!st);
02254 return st;
02255 }
02256 #endif
02257
02258 #ifdef GX_ASCII
02259
02269 inline bool SetProperty(gxInAStr name, double fvalue) gxFuncThrowsError {
02270 GX_GETASTRING(_name, name);
02271 bool st = gx_setpropertyfloata(*this, _name, fvalue) ? true : false;
02272 gxcondthrow(!st);
02273 return st;
02274 }
02275 #endif
02276
02277 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
02278
02283 inline bool GetPropertyType(const wchar_t *name, int *type) gxFuncThrowsError {
02284 bool st = gx_getpropertytype(*this, name, type) ? true : false;
02285 gxcondthrow(!st);
02286 return st;
02287 }
02288
02294 inline bool GetPropertyType(const char *name, int *type) gxFuncThrowsError {
02295 bool st = gx_getpropertytypea(*this, name, type) ? true : false;
02296 gxcondthrow(!st);
02297 return st;
02298 }
02299
02305 inline int GetPropertyType(const wchar_t *name) gxFuncThrowsError {
02306 int type = -1;
02307 if(!gx_getpropertytype(*this, name, &type)) gxthrow;
02308 return type;
02309 }
02310
02316 inline int GetPropertyType(const char *name) gxFuncThrowsError {
02317 int type = -1;
02318 if(!gx_getpropertytypea(*this, name, &type)) gxthrow;
02319 return type;
02320 }
02321 #endif // !GX_SWIGIF && !GX_DOTNET
02322
02323 #ifdef GX_UNICODE
02324
02329 inline int GetPropertyType(gxInStr name) gxFuncThrowsError {
02330 int type = -1;
02331 GX_GETSTRING(_name, name);
02332 GX_GETHANDLE(h);
02333 if(!gx_getpropertytype(h, _name, &type)) gxthrow;
02334 return type;
02335 }
02336 #endif
02337
02338 #ifdef GX_ASCII
02339
02344 inline int GetPropertyType(gxInAStr name) gxFuncThrowsError {
02345 int type = -1;
02346 GX_GETASTRING(_name, name);
02347 if(!gx_getpropertytype(*this, _name, &type)) gxthrow;
02348 return type;
02349 }
02350 #endif
02351
02352 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
02353
02358 inline bool RmProperties(const wchar_t *name) gxFuncThrowsError {
02359 bool st = gx_rmproperties(*this, name) ? true : false;
02360 gxcondthrow(!st);
02361 return st;
02362 }
02363
02369 inline bool RmProperties(const char *name) gxFuncThrowsError {
02370 bool st = gx_rmpropertiesa(*this, name) ? true : false;
02371 gxcondthrow(!st);
02372 return st;
02373 }
02374 #endif // !GX_SWIGIF && !GX_DOTNET
02375
02376 #ifdef GX_UNICODE
02377
02382 inline bool RmProperties(gxInStr name) gxFuncThrowsError {
02383 GX_GETSTRING(_name, name);
02384 GX_GETHANDLE(h);
02385 bool st = gx_rmproperties(h, _name) ? true : false;
02386 gxcondthrow(!st);
02387 return st;
02388 }
02389 #endif
02390
02391 #ifdef GX_ASCII
02392
02397 inline bool RmProperties(gxInAStr name) gxFuncThrowsError {
02398 GX_GETASTRING(_name, name);
02399 bool st = gx_rmpropertiesa(*this, _name) ? true : false;
02400 gxcondthrow(!st);
02401 return st;
02402 }
02403 #endif
02404
02405 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
02406
02414 inline bool GetProperties(const wchar_t *name, wchar_t *string, int maxlen) gxFuncThrowsError {
02415 bool st = gx_getproperties(*this, name, string, maxlen) ? true : false;
02416 gxcondthrow(!st);
02417 return st;
02418 }
02419
02428 inline bool GetProperties(const char *name, char *string, int maxlen) gxFuncThrowsError {
02429 bool st = gx_getpropertiesa(*this, name, string, maxlen) ? true : false;
02430 gxcondthrow(!st);
02431 return st;
02432 }
02433
02434 #if !defined(GX_SWIG) && !defined(NO_GX_STL)
02435
02440 inline std::vector<std::wstring> GetProperties(const wchar_t *name) gxFuncThrowsError {
02441 std::vector<std::wstring> array;
02442 bool st;
02443 __gx_func_strarray(st, wchar_t, array, name, wcslen, gx_getproperties);
02444 return array;
02445 }
02446
02452 inline std::vector<std::string> GetProperties(const char *name) gxFuncThrowsError {
02453 std::vector<std::string> array;
02454 bool st;
02455 __gx_func_strarray(st, char, array, name, strlen, gx_getpropertiesa);
02456 return array;
02457 }
02458 #endif
02459 #endif // !GX_SWIGIF && !GX_DOTNET
02460
02461 #ifdef GX_UNICODE
02462
02467 inline gxOutStrArray GetProperties(gxInStr name) gxFuncThrowsError {
02468 GX_GETSTRING(_name, name);
02469 gxOutStrArray _array;
02470 int st;
02471 #ifdef GX_DOTNET
02472 GX_GETHANDLE(h);
02473 #endif
02474 __gx_func_outstrarray(st, _array, _name, gx_getproperties);
02475 return _array;
02476 }
02477 #endif // GX_UNICODE
02478 #ifdef GX_ASCII
02479
02484 inline gxOutAStrArray GetProperties(gxInAStr name) gxFuncThrowsError {
02485 GX_GETASTRING(_name, name);
02486 gxOutAStrArray array;
02487 bool st;
02488 __gx_func_outastrarray(st, array, _name, gx_getpropertiesa);
02489 return array;
02490 }
02491 #endif
02492
02493 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
02494
02503 inline bool GetAllProperties(const wchar_t *name, wchar_t *string, int maxlen) gxFuncThrowsError {
02504 bool st = gx_getallproperties(*this, name, string, maxlen) ? true : false;
02505 gxcondthrow(!st);
02506 return st;
02507 }
02508
02518 inline bool GetAllProperties(const char *name, char *string, int maxlen) gxFuncThrowsError {
02519 bool st = gx_getallproperties(*this, name, string, maxlen) ? true : false;
02520 gxcondthrow(!st);
02521 return st;
02522 }
02523
02524 #if !defined(GX_SWIG) && !defined(NO_GX_STL)
02525
02531 inline std::vector<std::wstring> GetAllProperties(const wchar_t *name) gxFuncThrowsError {
02532 std::vector<std::wstring> array;
02533 bool st;
02534 __gx_func_strarray(st, wchar_t, array, name, wcslen, gx_getallproperties);
02535 return array;
02536 }
02537
02544 inline std::vector<std::string> GetAllProperties(const char *name) gxFuncThrowsError {
02545 std::vector<std::string> array;
02546 bool st;
02547 __gx_func_strarray(st, char, array, name, strlen, gx_getallpropertiesa);
02548 return array;
02549 }
02550 #endif
02551 #endif // !GX_SWIGIF && !GX_DOTNET
02552
02553 #ifdef GX_UNICODE
02554
02560 inline gxOutStrArray GetAllProperties(gxInStr name) gxFuncThrowsError {
02561 GX_GETSTRING(_name, name);
02562 gxOutStrArray _array;
02563 int st;
02564 #ifdef GX_DOTNET
02565 GX_GETHANDLE(h);
02566 #endif
02567 __gx_func_outstrarray(st, _array, _name, gx_getallproperties);
02568 return _array;
02569 }
02570 #endif
02571 #ifdef GX_ASCII
02572
02578 inline gxOutAStrArray GetAllProperties(gxInAStr name) gxFuncThrowsError {
02579 GX_GETASTRING(_name, name);
02580 gxOutAStrArray array;
02581 bool st;
02582 __gx_func_outastrarray(st, array, _name, gx_getallproperties);
02583 return array;
02584 }
02585 #endif
02586
02587 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
02588
02593 inline bool SetPropertyParent(const wchar_t *name, const wchar_t *string) gxFuncThrowsError {
02594 bool st = gx_setpropertyparent(*this, name, string) ? true : false;
02595 gxcondthrow(!st);
02596 return st;
02597 }
02598
02604 inline bool SetPropertyParent(const char *name, const char *string) gxFuncThrowsError {
02605 bool st = gx_setpropertyparent(*this, name, string) ? true : false;
02606 gxcondthrow(!st);
02607 return st;
02608 }
02609 #endif
02610
02611 #ifdef GX_UNICODE
02612
02617 inline bool SetPropertyParent(gxInStr name, gxInStr str) gxFuncThrowsError {
02618 GX_GETSTRING(_name, name);
02619 GX_GETSTRING(_str, str);
02620 GX_GETHANDLE(h);
02621 bool st = gx_setpropertyparent(h, _name, _str) ? true : false;
02622 gxcondthrow(!st);
02623 return st;
02624 }
02625 #endif
02626 #ifdef GX_ASCII
02627
02632 inline bool SetPropertyParent(gxInAStr name, gxInAStr str) gxFuncThrowsError {
02633 GX_GETASTRING(_name, name);
02634 GX_GETASTRING(_str, str);
02635 bool st = gx_setpropertyparenta(*this, _name, _str) ? true : false;
02636 gxcondthrow(!st);
02637 return st;
02638 }
02639 #endif
02640
02641 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
02642
02648 inline bool GetPropertyParent(const wchar_t *name, wchar_t *string, int maxlen) gxFuncThrowsError {
02649 bool st = gx_getpropertyparent(*this, name, string, maxlen) ? true : false;
02650 gxcondthrow(!st);
02651 return st;
02652 }
02653
02654 #if !defined(GX_SWIG) && !defined(NO_GX_STL)
02655
02660 inline std::wstring GetPropertyParent(const wchar_t *name) gxFuncThrowsError {
02661 wchar_t buf[GX_MAXLEN_PROPVALUE+1];
02662 if(!gx_getpropertyparent(*this, name, buf, GX_MAXLEN_PROPVALUE)) {
02663 gxthrow;
02664 buf[0] = 0;
02665 }
02666 buf[GX_MAXLEN_PROPVALUE] = 0;
02667 return std::wstring(buf);
02668 }
02669 #endif
02670
02677 inline bool GetPropertyParent(const char *name, char *string, int maxlen) gxFuncThrowsError {
02678 bool st = gx_getpropertyparenta(*this, name, string, maxlen) ? true : false;
02679 gxcondthrow(!st);
02680 return st;
02681 }
02682
02683 #if !defined(GX_SWIG) && !defined(NO_GX_STL)
02684
02689 inline std::string GetPropertyParent(const char *name) gxFuncThrowsError {
02690 char buf[GX_MAXLEN_PROPVALUE+1];
02691 if(!gx_getpropertyparent(*this, name, buf, GX_MAXLEN_PROPVALUE)) {
02692 gxthrow;
02693 buf[0] = 0;
02694 }
02695 buf[GX_MAXLEN_PROPVALUE] = 0;
02696 return std::string(buf);
02697 }
02698 #endif
02699 #endif // !GX_SWIGIF && !GX_DOTNET
02700
02701 #ifdef GX_UNICODE
02702
02707 inline gxOutStr GetPropertyParent(gxInStr name) gxFuncThrowsError {
02708 wchar_t buf[GX_MAXLEN_PROPVALUE+1];
02709 GX_GETSTRING(_name, name);
02710 GX_GETHANDLE(h);
02711 if(!gx_getpropertyparent(h, _name, buf, GX_MAXLEN_PROPVALUE)) {
02712 gxthrow;
02713 return GX_PUTSTRING_NONE;
02714 }
02715 buf[GX_MAXLEN_PROPVALUE] = 0;
02716 return GX_PUTSTRING(buf);
02717 }
02718 #endif
02719 #ifdef GX_ASCII
02720
02725 inline gxOutAStr GetPropertyParent(gxInAStr name) gxFuncThrowsError {
02726 char buf[GX_MAXLEN_PROPVALUE+1];
02727 GX_GETASTRING(_name, name);
02728 int st = gx_getpropertyparent(*this, _name, buf, GX_MAXLEN_PROPVALUE);
02729 if(!st) {
02730 gxthrow;
02731 return GX_PUTASTRING_NONE;
02732 }
02733 buf[GX_MAXLEN_PROPVALUE] = 0;
02734 return GX_PUTASTRING(buf);
02735 }
02736 #endif
02737
02738 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
02739
02743 inline bool ClearPropertyParent(const wchar_t *name) gxFuncThrowsError {
02744 bool st = gx_setpropertyparent(*this, name, (const wchar_t *)0) ? true : false;
02745 gxcondthrow(!st);
02746 return st;
02747 }
02748
02753 inline bool ClearPropertyParent(const char *name) gxFuncThrowsError {
02754 bool st = gx_setpropertyparent(*this, name, (const char *)0) ? true : false;
02755 gxcondthrow(!st);
02756 return st;
02757 }
02758 #endif
02759
02760 #ifdef GX_UNICODE
02761
02765 inline bool ClearPropertyParent(gxInStr name) gxFuncThrowsError {
02766 GX_GETSTRING(_name, name);
02767 GX_GETHANDLE(h);
02768 bool st = gx_setpropertyparent(h, _name, (const wchar_t *)0) ? true : false;
02769 gxcondthrow(!st);
02770 return st;
02771 }
02772 #endif
02773 #ifdef GX_ASCII
02774
02778 inline bool ClearPropertyParent(gxInAStr name) gxFuncThrowsError {
02779 GX_GETASTRING(_name, name);
02780 bool st = gx_setpropertyparenta(*this, _name, (const char *)0) ? true : false;
02781 gxcondthrow(!st);
02782 return st;
02783 }
02784 #endif
02785
02786 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
02787
02793 inline bool GetModuleProperty(const wchar_t *name, wchar_t *string, int maxlen) gxFuncThrowsError {
02794 bool st = gx_getmoduleproperty(*this, name, string, maxlen) ? true : false;
02795 gxcondthrow(!st);
02796 return st;
02797 }
02798
02799 #if !defined(GX_SWIG) && !defined(NO_GX_STL)
02800
02805 inline std::wstring GetModuleProperty(const wchar_t *name) gxFuncThrowsError {
02806 wchar_t buf[GX_MAXLEN_PROPVALUE+1];
02807 if(!gx_getmoduleproperty(*this, name, buf, GX_MAXLEN_PROPVALUE)) {
02808 gxthrow;
02809 buf[0] = 0;
02810 }
02811 buf[GX_MAXLEN_PROPVALUE] = 0;
02812 return std::wstring(buf);
02813 }
02814 #endif
02815
02822 inline bool GetModuleProperty(const char *name, char *string, int maxlen) gxFuncThrowsError {
02823 bool st = gx_getmoduleproperty(*this, name, string, maxlen) ? true : false;
02824 gxcondthrow(!st);
02825 return st;
02826 }
02827
02828 #if !defined(GX_SWIG) && !defined(NO_GX_STL)
02829
02834 inline std::string GetModuleProperty(const char *name) gxFuncThrowsError {
02835 char buf[GX_MAXLEN_PROPVALUE+1];
02836 if(!gx_getmoduleproperty(*this, name, buf, GX_MAXLEN_PROPVALUE)) {
02837 gxthrow;
02838 buf[0] = 0;
02839 }
02840 buf[GX_MAXLEN_PROPVALUE] = 0;
02841 return std::string(buf);
02842 }
02843 #endif
02844 #endif
02845
02846 #ifdef GX_UNICODE
02847
02852 inline gxOutStr GetModuleProperty(gxInStr name) gxFuncThrowsError {
02853 wchar_t buf[GX_MAXLEN_PROPVALUE+1];
02854 GX_GETSTRING(_name, name);
02855 GX_GETHANDLE(h);
02856 if(!gx_getmoduleproperty(h, _name, buf, GX_MAXLEN_PROPVALUE)) {
02857 gxthrow;
02858 return GX_PUTSTRING_NONE;
02859 }
02860 buf[GX_MAXLEN_PROPVALUE] = 0;
02861 return GX_PUTSTRING(buf);
02862 }
02863 #endif
02864
02865 #ifdef GX_ASCII
02866
02871 inline gxOutAStr GetModuleProperty(gxInAStr name) gxFuncThrowsError {
02872 char buf[GX_MAXLEN_PROPVALUE+1];
02873 GX_GETASTRING(_name, name);
02874 int st = gx_getmodulepropertya(*this, _name, buf, GX_MAXLEN_PROPVALUE);
02875 if(!st) {
02876 gxthrow;
02877 return GX_PUTASTRING_NONE;
02878 }
02879 buf[GX_MAXLEN_PROPVALUE] = 0;
02880 return GX_PUTASTRING(buf);
02881 }
02882 #endif
02883
02884 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
02885
02890 inline bool GetModuleProperty(const wchar_t *name, int *ivalue) gxFuncThrowsError {
02891 bool st = gx_getmodulepropertyint(*this, name, ivalue) ? true : false;
02892 gxcondthrow(!st);
02893 return st;
02894 }
02895
02901 inline int GetModulePropertyInt(const wchar_t *name) gxFuncThrowsError {
02902 int ret = -1;
02903 if(!gx_getmodulepropertyint(*this, name, &ret)) gxthrow;
02904 return ret;
02905 }
02906
02912 inline bool GetModuleProperty(const char *name, int *ivalue) gxFuncThrowsError {
02913 bool st = gx_getmodulepropertyinta(*this, name, ivalue) ? true : false;
02914 gxcondthrow(!st);
02915 return st;
02916 }
02917
02923 inline int GetModulePropertyInt(const char *name) gxFuncThrowsError {
02924 int ret = -1;
02925 if(!gx_getmodulepropertyinta(*this, name, &ret)) gxthrow;
02926 return ret;
02927 }
02928 #endif
02929
02930 #ifdef GX_UNICODE
02931
02936 inline int GetModulePropertyInt(gxInStr name) gxFuncThrowsError {
02937 int ret = -1;
02938 GX_GETSTRING(_name, name);
02939 GX_GETHANDLE(h);
02940 if(!gx_getmodulepropertyint(h, _name, &ret)) gxthrow;
02941 return ret;
02942 }
02943 #endif
02944 #ifdef GX_ASCII
02945
02950 inline int GetModulePropertyInt(gxInAStr name) gxFuncThrowsError {
02951 int ret = -1;
02952 GX_GETASTRING(_name, name);
02953 if(!gx_getmodulepropertyinta(*this, _name, &ret)) gxthrow;
02954 return ret;
02955 }
02956 #endif
02957
02958 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
02959
02964 inline bool GetModuleProperty(const wchar_t *name, double *fvalue) gxFuncThrowsError {
02965 bool st = gx_getmodulepropertyfloat(*this, name, fvalue) ? true : false;
02966 gxcondthrow(!st);
02967 return st;
02968 }
02969
02975 inline double GetModulePropertyFloat(const wchar_t *name) gxFuncThrowsError {
02976 double ret = -1;
02977 if(!gx_getmodulepropertyfloat(*this, name, &ret)) gxthrow;
02978 return ret;
02979 }
02980
02986 inline bool GetModuleProperty(const char *name, double *fvalue) gxFuncThrowsError {
02987 bool st = gx_getmodulepropertyfloata(*this, name, fvalue) ? true : false;
02988 gxcondthrow(!st);
02989 return st;
02990 }
02991
02997 inline double GetModulePropertyFloat(const char *name) gxFuncThrowsError {
02998 double ret = -1;
02999 if(!gx_getmodulepropertyfloata(*this, name, &ret)) gxthrow;
03000 return ret;
03001 }
03002 #endif // !GX_SWIGIF && !GX_DOTNET
03003
03004 #ifdef GX_UNICODE
03005
03010 inline double GetModulePropertyFloat(gxInStr name) gxFuncThrowsError {
03011 double ret = -1;
03012 GX_GETSTRING(_name, name);
03013 GX_GETHANDLE(h);
03014 if(!gx_getmodulepropertyfloat(h, _name, &ret)) gxthrow;
03015 return ret;
03016 }
03017 #endif
03018 #ifdef GX_ASCII
03019
03024 inline double GetModulePropertyFloat(gxInAStr name) gxFuncThrowsError {
03025 double ret = -1;
03026 GX_GETASTRING(_name, name);
03027 if(!gx_getmodulepropertyfloata(*this, _name, &ret)) gxthrow;
03028 return ret;
03029 }
03030 #endif
03031
03032 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
03033
03038 inline bool SetModuleProperty(const wchar_t *name, const wchar_t *string) gxFuncThrowsError {
03039 bool st = gx_setmoduleproperty(*this, name, string) ? true : false;
03040 gxcondthrow(!st);
03041 return st;
03042 }
03043
03049 inline bool SetModuleProperty(const char *name, const char *string) gxFuncThrowsError {
03050 bool st = gx_setmoduleproperty(*this, name, string) ? true : false;
03051 gxcondthrow(!st);
03052 return st;
03053 }
03054 #endif // !GX_SWIGIF && !GX_DOTNET
03055
03056 #ifdef GX_UNICODE
03057
03062 inline bool SetModuleProperty(gxInStr name, gxInStr str) gxFuncThrowsError {
03063 GX_GETSTRING(_name, name);
03064 GX_GETSTRING(_str, str);
03065 GX_GETHANDLE(h);
03066 bool st = gx_setmoduleproperty(h, _name, _str) ? true : false;
03067 gxcondthrow(!st);
03068 return st;
03069 }
03070 #endif
03071 #ifdef GX_ASCII
03072
03077 inline bool SetModuleProperty(gxInAStr name, gxInAStr str) gxFuncThrowsError {
03078 GX_GETASTRING(_name, name);
03079 GX_GETASTRING(_str, str);
03080 bool st = gx_setmoduleproperty(*this, _name, _str) ? true : false;
03081 gxcondthrow(!st);
03082 return st;
03083 }
03084 #endif
03085
03086 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
03087
03092 inline bool SetModuleProperty(const wchar_t *name, int ivalue) gxFuncThrowsError {
03093 bool st = gx_setmodulepropertyint(*this, name, ivalue) ? true : false;
03094 gxcondthrow(!st);
03095 return st;
03096 }
03097
03103 inline bool SetModuleProperty(const char *name, int ivalue) gxFuncThrowsError {
03104 bool st = gx_setmodulepropertyinta(*this, name, ivalue) ? true : false;
03105 gxcondthrow(!st);
03106 return st;
03107 }
03108 #endif // !GX_SWIGIF && !GX_DOTNET
03109
03110 #ifdef GX_UNICODE
03111
03116 inline bool SetModuleProperty(gxInStr name, int ivalue) gxFuncThrowsError {
03117 GX_GETSTRING(_name, name);
03118 GX_GETHANDLE(h);
03119 bool st = gx_setmodulepropertyint(h, _name, ivalue) ? true : false;
03120 gxcondthrow(!st);
03121 return st;
03122 }
03123 #endif
03124
03125 #ifdef GX_ASCII
03126
03131 inline bool SetModuleProperty(gxInAStr name, int ivalue) gxFuncThrowsError {
03132 GX_GETASTRING(_name, name);
03133 bool st = gx_setmodulepropertyinta(*this, _name, ivalue) ? true : false;
03134 gxcondthrow(!st);
03135 return st;
03136 }
03137 #endif
03138
03139 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
03140
03145 inline bool SetModuleProperty(const wchar_t *name, double fvalue) gxFuncThrowsError {
03146 bool st = gx_setmodulepropertyfloat(*this, name, fvalue) ? true : false;
03147 gxcondthrow(!st);
03148 return st;
03149 }
03150
03156 inline bool SetModuleProperty(const char *name, double fvalue) gxFuncThrowsError {
03157 bool st = gx_setmodulepropertyfloata(*this, name, fvalue) ? true : false;
03158 gxcondthrow(!st);
03159 return st;
03160 }
03161 #endif // !GX_SWIGIF && !GX_DOTNET
03162
03163 #ifdef GX_UNICODE
03164
03169 inline bool SetModuleProperty(gxInStr name, double fvalue) gxFuncThrowsError {
03170 GX_GETSTRING(_name, name);
03171 GX_GETHANDLE(h);
03172 bool st = gx_setmodulepropertyfloat(h, _name, fvalue) ? true : false;
03173 gxcondthrow(!st);
03174 return st;
03175 }
03176 #endif
03177
03178 #ifdef GX_ASCII
03179
03184 inline bool SetModuleProperty(gxInAStr name, double fvalue) gxFuncThrowsError {
03185 GX_GETASTRING(_name, name);
03186 bool st = gx_setmodulepropertyfloata(*this, _name, fvalue) ? true : false;
03187 gxcondthrow(!st);
03188 return st;
03189 }
03190 #endif
03191 };
03192
03193
03195 GX_CLASS gxPropertyFile : public gxProperty {
03196 private:
03198 inline bool Flush(void) {
03199 return false;
03200 }
03201
03202 public:
03204 inline gxPropertyFile() gxFuncThrowsError : gxProperty(L"gxpropfile") {
03205 }
03206
03207 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
03208
03211 inline gxPropertyFile(const wchar_t *modname) gxFuncThrowsError :
03212 gxProperty(modname ? modname : L"gxpropfile") {
03213 }
03214
03218 inline gxPropertyFile(const char *modname) gxFuncThrowsError :
03219 gxProperty(modname) {
03220 }
03221 #endif // !GX_SWIGIF && !GX_DOTNET
03222
03223 #ifdef GX_UNICODE
03224
03227 inline gxPropertyFile(gxInStr modname) gxFuncThrowsError {
03228 GX_GETSTRING(_modname, modname);
03229 #ifndef GX_DOTNET
03230 if(!gx_openmodule(this, _modname, 0)) gxthrow;
03231 #else
03232 GX_GETHANDLE(h);
03233 if(!gx_openmodule(&h, _modname, 0)) gxthrow;
03234 _set_handle(h.handle);
03235 #endif
03236 }
03237 #endif
03238 #ifdef GX_ASCII
03239
03242 inline gxPropertyFile(gxInAStr modname) gxFuncThrowsError {
03243 GX_GETASTRING(_modname, modname);
03244 if(!gx_openmodulea(this, _modname, 0)) gxthrow;
03245 }
03246 #endif
03247
03248 };
03249
03250 #if 0
03251
03252 GX_CLASS gxPropertyClient : public gxProperty {
03253 private:
03254 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
03255
03258 inline bool Load(const wchar_t *name) { return false; }
03262 inline bool Load(const char *name) { return false; }
03267 inline bool Save(const wchar_t *name, bool unicode = false) { return false; }
03272 inline bool Save(const char *name, bool unicode = false) { return false; }
03273 #endif
03274
03275 #ifdef GX_UNICODE
03276
03279 inline bool Load(gxInStr name) { return false; }
03283 inline bool Save(gxInStr name) { return false; }
03284 #endif
03285 #ifdef GX_ASCII
03286
03289 inline bool Load(gxInAStr name) { return false; }
03293 inline bool Save(gxInAStr name) { return false; }
03294 #endif
03295
03296 public:
03298 inline gxPropertyClient() gxFuncThrowsError : gxProperty(L"gxpropclient") {
03299 }
03300
03301 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
03302
03305 inline gxPropertyClient(const wchar_t *modname) gxFuncThrowsError :
03306 gxProperty(modname ? modname : L"gxpropclient") {
03307 }
03308
03312 inline gxPropertyClient(const char *modname) gxFuncThrowsError :
03313 gxProperty(modname) {
03314 }
03315 #endif
03316
03317 #ifdef GX_UNICODE
03318
03321 inline gxPropertyClient(gxInStr modname) gxFuncThrowsError {
03322 GX_GETSTRING(_modname, modname);
03323 #ifndef GX_DOTNET
03324 if(!gx_openmodule(this, _modname, 0)) gxthrow;
03325 #else
03326 GX_GETHANDLE(h);
03327 if(!gx_openmodule(&h, _modname, 0)) gxthrow;
03328 _set_handle(h.handle);
03329 #endif
03330 }
03331 #endif
03332
03333 #ifdef GX_ASCII
03334
03337 inline gxPropertyClient(gxInAStr modname) gxFuncThrowsError {
03338 GX_GETASTRING(_modname, modname);
03339 if(!gx_openmodulea(this, _modname, 0)) gxthrow;
03340 }
03341 #endif
03342
03343 };
03344 #endif
03345
03346 #endif // !NO_GX_CLASSES && __cplusplus && !ANDROID
03347
03348 #ifdef GX_NAMESPACES
03349 }
03350 #endif
03351
03352 #ifdef _MSC_VER
03353 #pragma warning(pop)
03354 #endif
03355
03356 #endif//GXPROPERTY_INCL
03357
