![]() |
![]() |
00001 /******************************************************************************* 00002 * GX PROPERTY header file - V7.2.12 00003 * 00004 * 2004-2015 (c) Adaptive Recognition (https://adaptiverecognition.com) 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) /* truncated debug info */ 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 /* GX_SWIGIF GX_MANUAL )*/ 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 /******************************************************************************/