![]() |
![]() |
00001 /******************************************************************************* 00002 * GXSD header file - V7.2.12.1 00003 * 00004 * 2004-2015 (c) Adaptive Recognition (https://adaptiverecognition.com) 00005 ******************************************************************************/ 00048 /******************************************************************************/ 00114 /******************************************************************************/ 00130 /******************************************************************************/ 00131 #ifndef GXSD_INCL 00132 #define GXSD_INCL 00133 /******************************************************************************/ 00134 #include <assert.h> 00135 #include <stdio.h> 00136 #include <wchar.h> 00137 #include <stdlib.h> 00138 #include <stdarg.h> 00139 #include <string.h> 00140 #include "gxtypes.h" 00141 /******************************************************************************/ 00142 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL) /*(*/ 00143 /******************************************************************************/ 00144 #if !defined(gx_strncpy) 00145 /* Visual Studio 8 workaround */ 00146 #if _MSC_VER >= 1400 00147 00148 inline int gx_snwprintf(wchar_t *buffer, size_t count, const wchar_t *format, ...) { 00149 int r; 00150 va_list args; 00151 va_start(args, format); 00152 r = _vsnwprintf_s(buffer,count,_TRUNCATE,format, args); 00153 va_end(args); 00154 return r; 00155 } 00156 00157 inline int gx_snprintf(char *buffer, size_t count, const char *format, ...) { 00158 int r; 00159 va_list args; 00160 va_start(args, format); 00161 r = _vsnprintf_s(buffer,count,_TRUNCATE,format,args); 00162 va_end(args); 00163 return r; 00164 } 00165 #define gx_strncpy(strDest,strSource,count) strncpy_s(strDest,count,strSource,_TRUNCATE) 00166 #define gx_wcsncpy(strDest,strSource,count) wcsncpy_s(strDest,count,strSource,_TRUNCATE) 00167 00168 #define gx_strncat(strDest,strSource,count) strncat_s(strDest,strlen(strDest)+count+1,strSource,_TRUNCATE) 00169 #define gx_wcsncat(strDest,strSource,count) wcsncat_s(strDest,wcslen(strDest)+count+1,strSource,_TRUNCATE) 00170 00171 inline size_t gx_wcstombs(char *mbstr, const wchar_t *wcstr, size_t count) { 00172 size_t pConvertedChars = 0; 00173 wcstombs_s(&pConvertedChars,mbstr,count,wcstr,_TRUNCATE); 00174 return pConvertedChars; 00175 } 00176 inline size_t gx_mbstowcs(wchar_t *wcstr, const char *mbstr, size_t count) { 00177 size_t pConvertedChars = 0; 00178 mbstowcs_s(&pConvertedChars,wcstr,count,mbstr,_TRUNCATE); 00179 return pConvertedChars; 00180 } 00181 00182 #define gx_strdup _strdup 00183 #define gx_wcsdup _wcsdup 00184 #define gx_wcstol wcstol 00185 00186 #if defined(__INTEL_COMPILER) && !defined(_M_X64) 00187 #define __ptr32 00188 #endif 00189 00190 #elif defined(WIN32) 00191 00192 #define gx_snwprintf _snwprintf 00193 #define gx_snprintf _snprintf 00194 #define gx_strncpy strncpy 00195 #define gx_strncat strncat 00196 #define gx_wcsncat wcsncat 00197 #define gx_wcsncpy wcsncpy 00198 #define gx_wcstombs wcstombs 00199 #define gx_mbstowcs mbstowcs 00200 #define gx_strdup _strdup 00201 #define gx_wcsdup _wcsdup 00202 #define gx_wcstol wcstol 00203 00204 #define __ptr32 00205 00206 #else //LINUX 00207 00208 #ifdef ANDROID 00209 #include "unicode/ConvertUTF.h" 00210 #include "androidlog.h" 00211 inline wchar_t *wcsdup(const wchar_t *st) 00212 { 00213 if (!st) return NULL; 00214 wchar_t *pst = (wchar_t *)malloc((wcslen(st)+1)*sizeof(wchar_t)); 00215 if (pst) wcscpy(pst,st); 00216 return pst; 00217 } 00218 inline size_t gx_wcstombs(char *mbstr,const wchar_t *wcstr,size_t count) 00219 { 00220 if (!mbstr || !wcstr || !count) return 0; 00221 size_t l = wcslen(wcstr); 00222 if (l > count) l = count; 00223 memset((void*)mbstr,0,count); 00224 //if (ConvertUTF16toUTF8((const UTF16**)&wcstr,(const UTF16*)(wcstr+wcslen(wcstr)-1),(UTF8**)&mbstr,(UTF8*)(mbstr+count-2),strictConversion) == conversionOK) return l; 00225 for(int i=0;i<l;i++) 00226 { 00227 if (wcstr[i] > 255) mbstr[i]='.'; 00228 else mbstr[i] = (char)(wcstr[i] & 0xff); 00229 } 00230 return l; 00231 } 00232 inline size_t gx_mbstowcs(wchar_t *wcstr,const char *mbstr,size_t count) 00233 { 00234 if (!mbstr || !wcstr || !count) return 0; 00235 size_t l = strlen(mbstr); 00236 if (l > count) l = count; 00237 memset((void*)wcstr,0,count*sizeof(wchar_t)); 00238 //if (ConvertUTF8toUTF16((const UTF8**)&mbstr,(const UTF8*)(mbstr+strlen(mbstr)-1),(UTF16**)&wcstr,(UTF16*)(wcstr+count-2),strictConversion) == conversionOK) return l; 00239 for(int i=0;i<l;i++) 00240 { 00241 wcstr[i] = (wchar_t)mbstr[i]; 00242 } 00243 return l; 00244 } 00245 inline long int gx_wcstol(const wchar_t *wcstr, wchar_t **endptr, int base) 00246 { 00247 size_t s = (wcslen(wcstr)+1)*sizeof(char); 00248 char *pch = (char*)malloc(s); 00249 char *ep = 0; 00250 long int ret = 0; 00251 if (!pch) return 0; 00252 gx_wcstombs(pch,wcstr,s); 00253 ret = strtol(pch,&ep,base); 00254 if (endptr) *endptr = (wchar_t*)wcstr + (int)(ep-pch); 00255 free(pch); 00256 return ret; 00257 } 00258 #else 00259 #define gx_wcstombs wcstombs 00260 #define gx_mbstowcs mbstowcs 00261 #define gx_wcstol wcstol 00262 #endif 00263 00264 #define gx_snwprintf swprintf 00265 #define gx_wcsncpy wcsncpy 00266 #define gx_wcsncat wcsncat 00267 #define gx_wcsdup wcsdup 00268 #define gx_snprintf snprintf 00269 #define gx_strncpy strncpy 00270 #define gx_strncat strncat 00271 #define gx_strdup strdup 00272 #endif 00273 #endif 00274 /******************************************************************************/ 00275 #if defined(WIN32) && !defined(va_copy) 00276 #define va_copy(ap,v) (ap=(v)) 00277 #endif 00278 #if defined(LINUX) && !defined(va_copy) 00279 #define va_copy __va_copy 00280 #endif 00281 #include "gxerror.h" 00282 #include "gxlibsd.h" 00283 /******************************************************************************/ 00284 #ifdef __BORLANDC__ 00285 #pragma warn -rch 00286 #endif 00287 #ifdef _MSC_VER 00288 #pragma warning(disable : 4127) /* truncated debug info */ 00289 #endif 00290 /******************************************************************************/ 00291 #endif /* GX_SWIGIF GX_MANUAL )*/ 00292 /******************************************************************************/ 00293 #ifdef GX_NAMESPACES 00294 namespace gx { 00295 #ifdef GX_DOTNET 00296 /* Unmanaged code for .net */ 00297 #pragma unmanaged 00298 #endif 00299 #endif 00300 /******************************************************************************/ 00301 #ifndef GX_MANUAL 00302 /* .NET workarounds */ 00303 #ifdef GX_DOTNET 00304 #define _GX_ERR_FLAG_CLEAR 0 00305 #define _GX_ERR_FLAG_APPEND 1 00306 #define _GX_ERR_FLAG_PREPEND 2 00307 #else 00308 #define _GX_ERR_FLAG_CLEAR GX_ERR_FLAG_CLEAR 00309 #define _GX_ERR_FLAG_APPEND GX_ERR_FLAG_APPEND 00310 #define _GX_ERR_FLAG_PREPEND GX_ERR_FLAG_PREPEND 00311 #endif 00312 #endif 00313 /******************************************************************************/ 00314 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL) /*(*/ 00315 /****************************************************************************** 00316 * Call groups and codes in the GX system. 00317 ******************************************************************************/ 00319 enum GX_CALL_GROUP_CODES { 00320 /******************************************************************************* 00321 * GXSD groups 00322 ******************************************************************************/ 00323 GX_CALL_GROUP_API = 0x10000000, 00324 GX_CALL_GROUP_API_FIRST = 0x10000000, 00325 GX_CALL_GROUP_API_LAST = 0x10FFFFFF, 00327 GX_CALL_GROUP_ERROR = 0x10010000, 00328 GX_CALL_GROUP_MEMORY = 0x10020000, 00329 GX_CALL_GROUP_MODULE = 0x10030000, 00330 GX_CALL_GROUP_VARIANT = 0x10040000, 00332 /******************************************************************************* 00333 * GX LICENSE operations 00334 ******************************************************************************/ 00335 GX_CALL_GROUP_LICENSE = 0x10900000, 00337 /******************************************************************************* 00338 * GX DEVICE operations 00339 ******************************************************************************/ 00340 GX_CALL_GROUP_GX_DEVICE = 0x10FF0000, 00342 /******************************************************************************* 00343 * GX MODULES (gxImage, gxTrafo, ..) 00344 ******************************************************************************/ 00345 GX_CALL_GROUP_GX = 0x11000000, 00346 GX_CALL_GROUP_GX_FIRST = 0x11000000, 00347 GX_CALL_GROUP_GX_LAST = 0x1FFFFFFF, 00349 GX_CALL_GROUP_GX_PROPERTY = 0x11000000, 00350 GX_CALL_GROUP_GX_LOG = 0x11010000, 00351 GX_CALL_GROUP_GX_STREAM = 0x11020000, 00352 GX_CALL_GROUP_GX_TRAFO = 0x11030000, 00353 GX_CALL_GROUP_GX_IMAGE = 0x11040000, 00354 GX_CALL_GROUP_GX_BMP = 0x11050000, 00355 GX_CALL_GROUP_GX_JPEG = 0x11060000, 00356 GX_CALL_GROUP_GX_WATCHDOG = 0x11070000, 00357 GX_CALL_GROUP_GX_MOTDET = 0x11080000, 00358 GX_CALL_GROUP_GX_JPEG2K = 0x11090000, 00359 GX_CALL_GROUP_GX_ZLIB = 0x110A0000, 00360 GX_CALL_GROUP_GX_PNG = 0x110B0000, 00361 GX_CALL_GROUP_GX_IMGEXT = 0x110C0000, 00362 GX_CALL_GROUP_GX_TEST = 0x110D0000, 00363 GX_CALL_GROUP_GX_PROPFILE = 0x110E0000, 00364 GX_CALL_GROUP_GX_PROPCLIENT = 0x110F0000, 00365 GX_CALL_GROUP_GX_JPEG8 = 0x11100000, 00366 GX_CALL_GROUP_GX_JPEG12 = 0x11110000, 00367 GX_CALL_GROUP_GX_CRYPTO = 0x11120000, 00368 GX_CALL_GROUP_GX_WSQ = 0x11130000, 00369 GX_CALL_GROUP_GX_VIDEO = 0x11140000, 00370 GX_CALL_GROUP_GX_LLJE = 0x11150000, 00372 /******************************************************************************* 00373 * Adaptive Recognition MODULES (Anpr, Fxvd4, Face Ident, Passport Reader) 00374 ******************************************************************************/ 00375 GX_CALL_GROUP_OTHER = 0x20000000, 00376 GX_CALL_GROUP_OTHER_FIRST = 0x20000000, 00377 GX_CALL_GROUP_OTHER_LAST = 0xEFFFFFFF, 00379 /******************************************************************************* 00380 * USER MODULES 00381 ******************************************************************************/ 00382 GX_CALL_GROUP_USER = 0xF0000000, 00383 GX_CALL_GROUP_USER_FIRST = 0xF0000000, 00384 GX_CALL_GROUP_USER_LAST = 0xFFFFFFFF 00385 }; 00386 00387 /******************************************************************************* 00388 * GX call codes 00389 ******************************************************************************/ 00390 00392 enum GX_CALL_DEFMODULE_CODES { 00393 00394 GX_CALL_SENDCOMPVERSION = GX_CALL_GROUP_API | 0x000F, 00395 GX_CALL_LISTMODULES = GX_CALL_GROUP_API | 0x0010, 00396 GX_CALL_LISTMODULESA = GX_CALL_GROUP_API | 0x0011, 00397 }; 00398 00400 #define GX_CURRENT_VERSION 0x07020A01 00401 00403 enum GX_CALL_MODULE_CODES { 00404 GX_CALL_OPENMODULE = GX_CALL_GROUP_MODULE | 0x0000, 00405 #ifndef ANDROID 00406 GX_CALL_OPENMODULEA = GX_CALL_GROUP_MODULE | 0x0001, 00407 #endif 00408 GX_CALL_CLOSEHANDLE = GX_CALL_GROUP_MODULE | 0x0002, 00409 GX_CALL_GETMODULEINFO = GX_CALL_GROUP_MODULE | 0x0004, 00410 GX_CALL_RESERVED = GX_CALL_GROUP_MODULE | 0x0005, 00412 GX_CALL_REFHANDLE = GX_CALL_GROUP_MODULE | 0x0006, 00413 GX_CALL_UNREFHANDLE = GX_CALL_GROUP_MODULE | 0x0007, 00415 GX_CALL_GETMODULEPROPERTY = GX_CALL_GROUP_MODULE | 0x0008, 00416 #ifndef ANDROID 00417 GX_CALL_GETMODULEPROPERTYA = GX_CALL_GROUP_MODULE | 0x0009, 00418 #endif 00419 GX_CALL_SETMODULEPROPERTY = GX_CALL_GROUP_MODULE | 0x000A, 00420 #ifndef ANDROID 00421 GX_CALL_SETMODULEPROPERTYA = GX_CALL_GROUP_MODULE | 0x000B, 00422 #endif 00423 GX_CALL_SAVEMODULEPROPERTIESOLD = GX_CALL_GROUP_MODULE | 0x000C, 00424 #ifndef ANDROID 00425 GX_CALL_SAVEMODULEPROPERTIESOLDA= GX_CALL_GROUP_MODULE | 0x000D, 00426 #endif 00427 GX_CALL_SAVEMODULEPROPERTIES = GX_CALL_GROUP_MODULE | 0x000E, 00428 #ifndef ANDROID 00429 GX_CALL_SAVEMODULEPROPERTIESA = GX_CALL_GROUP_MODULE | 0x000F, 00430 #endif 00431 GX_CALL_MPSTARTTRANSACTION = GX_CALL_GROUP_MODULE | 0x0010, 00432 GX_CALL_MPCOMMIT = GX_CALL_GROUP_MODULE | 0x0011, 00433 }; 00434 00436 enum GX_CALL_ERROR_CODES { 00437 GX_CALL_GETERROR = GX_CALL_GROUP_ERROR | 0x0000, 00438 #ifndef ANDROID 00439 GX_CALL_GETERRORA = GX_CALL_GROUP_ERROR | 0x0001, 00440 #endif 00441 GX_CALL_SETERROR = GX_CALL_GROUP_ERROR | 0x0002, 00442 #ifndef ANDROID 00443 GX_CALL_SETERRORA = GX_CALL_GROUP_ERROR | 0x0003, 00444 #endif 00445 GX_CALL_PUSHERROR = GX_CALL_GROUP_ERROR | 0x0004, 00446 GX_CALL_POPERROR = GX_CALL_GROUP_ERROR | 0x0005, 00447 GX_CALL_UPDATEERRTABLE = GX_CALL_GROUP_ERROR | 0x000F 00448 }; 00449 00451 enum GX_CALL_MEMORY_CODES { 00452 GX_CALL_GLOBALREALLOC = GX_CALL_GROUP_MEMORY | 0x0000, 00453 GX_CALL_GLOBALSIZE = GX_CALL_GROUP_MEMORY | 0x0001, 00454 GX_CALL_GLOBALREALLOC_DBG = GX_CALL_GROUP_MEMORY | 0x0002, 00455 GX_CALL_GLOBALCHECK_DBG = GX_CALL_GROUP_MEMORY | 0x0003, 00456 GX_CALL_GLOBALTESTMEM_DBG = GX_CALL_GROUP_MEMORY | 0x0004, 00457 GX_CALL_CREATEMEMSLOT = GX_CALL_GROUP_MEMORY | 0x0005, 00458 GX_CALL_GETMEMSLOT = GX_CALL_GROUP_MEMORY | 0x0006, 00459 GX_CALL_UNREFMEMSLOT = GX_CALL_GROUP_MEMORY | 0x0007, 00460 }; 00461 00463 enum GX_CALL_DEVICE_CODES { 00464 GX_CALL_LISTDEVICES = GX_CALL_GROUP_GX_DEVICE | 0x0000, 00465 #ifndef ANDROID 00466 GX_CALL_LISTDEVICESA = GX_CALL_GROUP_GX_DEVICE | 0x0001, 00467 #endif 00468 GX_CALL_OPENDEVICE = GX_CALL_GROUP_GX_DEVICE | 0x0002, 00469 #ifndef ANDROID 00470 GX_CALL_OPENDEVICEA = GX_CALL_GROUP_GX_DEVICE | 0x0003, 00471 #endif 00472 GX_CALL_GETDEVICEPROPERTY = GX_CALL_GROUP_GX_DEVICE | 0x0004, 00473 #ifndef ANDROID 00474 GX_CALL_GETDEVICEPROPERTYA = GX_CALL_GROUP_GX_DEVICE | 0x0005, 00475 #endif 00476 GX_CALL_SETDEVICEPROPERTY = GX_CALL_GROUP_GX_DEVICE | 0x0006, 00477 #ifndef ANDROID 00478 GX_CALL_SETDEVICEPROPERTYA = GX_CALL_GROUP_GX_DEVICE | 0x0007, 00479 #endif 00480 GX_CALL_GETDRIVERPROPERTY = GX_CALL_GROUP_GX_DEVICE | 0x0008, 00481 #ifndef ANDROID 00482 GX_CALL_GETDRIVERPROPERTYA = GX_CALL_GROUP_GX_DEVICE | 0x0009, 00483 #endif 00484 GX_CALL_SETDRIVERPROPERTY = GX_CALL_GROUP_GX_DEVICE | 0x000A, 00485 #ifndef ANDROID 00486 GX_CALL_SETDRIVERPROPERTYA = GX_CALL_GROUP_GX_DEVICE | 0x000B, 00487 #endif 00488 GX_CALL_GETSYSTEMINFO = GX_CALL_GROUP_GX_DEVICE | 0x000C, 00489 }; 00490 00491 #endif /* GX_SWIGIF GX_MANUAL )*/ 00492 #ifdef GX_SWIGIF 00493 %define GX_CALL_GROUP_GX_BMP 0x11050000 %enddef 00494 %define GX_CALL_GROUP_GX_JPEG 0x11060000 %enddef 00495 %define GX_CALL_GROUP_GX_JPEG2K 0x11090000 %enddef 00496 %define GX_CALL_GROUP_GX_WSQ 0x11130000 %enddef 00497 #endif 00498 /******************************************************************************/ 00499 00500 /******************************************************************************* 00501 * Types and structures 00502 ******************************************************************************/ 00503 #ifdef GX_DOTNET 00504 /* managed code in the .net */ 00505 #pragma managed 00506 #endif 00507 00508 #ifndef GX_EXT_MODULE /*(*/ 00509 00510 GX_STRUCT gxRCT { 00511 int left; 00512 int top; 00513 int right; 00514 int bottom; 00515 }; 00516 00517 #ifndef __cplusplus 00518 typedef struct gxRCT gxRCT; 00519 #endif 00520 00522 GX_STRUCT gxPNT { 00523 int x; 00524 int y; 00525 }; 00526 00527 #ifndef __cplusplus 00528 typedef struct gxPNT gxPNT; 00529 #endif 00530 00531 #ifdef GX_DOTNET 00532 #ifndef GX_DOTNET_20 00533 typedef gxPNT gxPNT_ARRAY []; 00534 #else 00535 typedef array<gxPNT>^ gxPNT_ARRAY; 00536 #endif 00537 #else 00538 typedef gxPNT gxPNT_ARRAY []; 00539 #endif 00540 00542 GX_STRUCT gxPG2 { 00543 int x1; 00544 int y1; 00545 int x2; 00546 int y2; 00547 }; 00548 00549 #ifndef __cplusplus 00550 typedef struct gxPG2 gxPG2; 00551 #endif 00552 00554 GX_STRUCT gxPG4 { 00555 int x1; 00556 int y1; 00557 int x2; 00558 int y2; 00559 int x3; 00560 int y3; 00561 int x4; 00562 int y4; 00563 }; 00564 00565 #ifndef __cplusplus 00566 typedef struct gxPG4 gxPG4; 00567 #endif 00568 00570 GX_STRUCT gxPNTF { 00571 float x; 00572 float y; 00573 }; 00574 00575 #ifndef __cplusplus 00576 typedef struct gxPNTF gxPNTF; 00577 #endif 00578 00579 #endif /*)*/ 00580 00581 #if defined(GX_DOTNET) && !defined(GX_MANUAL) /*(*/ 00582 #pragma unmanaged 00583 00585 struct _gxRCT { 00586 int left; 00587 int top; 00588 int right; 00589 int bottom; 00590 }; 00591 00593 struct _gxPNT { 00594 int x; 00595 int y; 00596 }; 00597 00599 struct _gxPG2 { 00600 int x1; 00601 int y1; 00602 int x2; 00603 int y2; 00604 }; 00605 00607 struct _gxPG4 { 00608 int x1; 00609 int y1; 00610 int x2; 00611 int y2; 00612 int x3; 00613 int y3; 00614 int x4; 00615 int y4; 00616 }; 00617 00619 struct _gxPNTF { 00620 float x; 00621 float y; 00622 }; 00623 00624 #endif /*)*/ 00625 00626 /******************************************************************************* 00627 * Data structures for error management 00628 ******************************************************************************/ 00629 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL) /*(*/ 00630 00631 struct GX_PARM_GETERROR { 00632 int code; 00633 wchar_t *string; 00634 int maxlen; 00635 }; 00636 00637 #ifndef ANDROID 00638 00639 struct GX_PARM_GETERRORA { 00640 int code; 00641 char *string; 00642 int maxlen; 00643 }; 00644 #endif 00645 #endif /* GX_SWIGIF GX_MANUAL )*/ 00646 00647 #ifndef GX_EXT_MODULE /*(*/ 00648 00649 #ifdef GX_DOTNET 00650 #pragma managed 00651 #endif 00652 00654 GX_ENUM GX_ERROR_FLAGS { 00655 GX_ERR_FLAG_CLEAR = 0, 00656 GX_ERR_FLAG_APPEND = 1, 00657 GX_ERR_FLAG_PREPEND = 2, 00659 GX_ERR_FLAG_APPMODE = (GX_ERR_FLAG_CLEAR | GX_ERR_FLAG_APPEND | GX_ERR_FLAG_PREPEND), 00661 GX_ERR_FLAG_NOARGS = 0x100, 00663 GX_ERR_FLAG_LOCAL = 0x1000, 00664 GX_ERR_FLAG_DIRECT = 0x2000 00665 }; 00666 00667 #ifdef GX_DOTNET 00668 #pragma unmanaged 00669 #endif 00670 00671 #endif /*)*/ 00672 00673 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL) /*(*/ 00674 00675 struct GX_PARM_SETERROR { 00676 int flags; 00677 int code; 00678 const wchar_t *appformat; 00679 va_list arguments; 00680 }; 00681 00682 #ifndef ANDROID 00683 00684 struct GX_PARM_SETERRORA { 00685 int flags; 00686 int code; 00687 const char *appformat; 00688 va_list arguments; 00689 }; 00690 #endif 00691 #endif /* GX_SWIGIF GX_MANUAL )*/ 00692 00693 #if !defined(GX_SWIGIF) && !(defined(GX_DOTNET) && defined(GX_MANUAL)) /*(*/ 00694 00696 struct gxERRITEM { 00697 int code; 00698 wchar_t *string; 00699 }; 00700 00701 #ifndef __cplusplus 00702 typedef struct gxERRITEM gxERRITEM; 00703 #endif 00704 00705 #endif /* GX_SWIGIF GX_DOTNET GX_MANUAL )*/ 00706 00707 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL) /*(*/ 00708 00710 struct GX_PARM_UPDATEERRTABLE { 00711 int nitems; 00712 const gxERRITEM *items; 00713 }; 00714 00715 /******************************************************************************* 00716 * Data structures for memory operations 00717 ******************************************************************************/ 00718 00719 /******************************************************************************/ 00721 struct GX_PARM_GLOBALREALLOC { 00722 void *buffer; 00724 int size; 00725 }; 00726 00727 /******************************************************************************/ 00729 struct GX_PARM_GLOBALSIZE { 00730 void *buffer; 00731 int size; 00732 }; 00733 00734 /******************************************************************************/ 00736 struct GX_PARM_GLOBALREALLOC_DBG { 00737 void *buffer; 00739 int size; 00740 const char *file; 00741 int line; 00742 }; 00743 00745 struct GX_PARM_GLOBALTESTMEM_DBG { 00746 int index; 00747 char *fnbuffer; 00748 int fnbsize; 00749 char *membuffer; 00750 int mbsize; 00751 int line; 00752 int size; 00753 void *address; 00754 }; 00755 00757 struct GX_PARM_CREATEMEMSLOT { 00758 int handle; 00759 void *mem; 00760 }; 00761 00763 struct GX_PARM_GETMEMSLOT { 00764 int handle; 00765 void *mem; 00766 }; 00767 00769 struct GX_PARM_UNREFMEMSLOT { 00770 int handle; 00771 }; 00772 00773 /******************************************************************************* 00774 * Structures of the module handle 00775 ******************************************************************************/ 00777 struct GX_PARM_GETDEFMODULENAME { 00778 int group; 00779 wchar_t *string; 00780 int maxlen; 00781 }; 00782 00783 #ifndef ANDROID 00784 00785 struct GX_PARM_GETDEFMODULENAMEA { 00786 int group; 00787 char *string; 00788 int maxlen; 00789 }; 00790 #endif 00791 00792 struct GX_PARM_SETDEFMODULENAME { 00793 int group; 00794 const wchar_t *string; 00795 }; 00796 00797 #ifndef ANDROID 00798 00799 struct GX_PARM_SETDEFMODULENAMEA { 00800 int group; 00801 const char *string; 00802 }; 00803 #endif 00804 00805 struct GX_PARM_SENDCOMPVERSION { 00806 unsigned int version; 00807 }; 00808 00809 00810 #ifndef ANDROID 00811 00812 struct GX_PARM_LISTMODULESA { 00813 unsigned int flags; 00814 const char *filter; 00815 char **files; 00816 unsigned int *versions; 00817 int nitems; 00818 }; 00819 #endif 00820 00821 struct GX_PARM_LISTMODULES { 00822 unsigned int flags; 00823 const wchar_t *filter; 00824 wchar_t **files; 00825 unsigned int *versions; 00826 int nitems; 00827 }; 00828 00829 00830 #ifdef GX_DOTNET 00831 #define gxHANDLE _gxHANDLE 00832 #endif 00833 00834 #endif /* GX_SWIGIF GX_MANUAL )*/ 00835 00836 /******************************************************************************/ 00837 00838 #if !defined(GX_SWIGIF) && !(defined(GX_DOTNET) && defined(GX_MANUAL)) /*(*/ 00839 00841 struct gxHANDLE { 00842 gxu32 handle; 00843 }; 00844 00845 #ifndef __cplusplus 00846 typedef struct gxHANDLE gxHANDLE; 00847 #endif 00848 00849 #endif /* GX_SWIGIF GX_DOTNET GX_MANUAL )*/ 00850 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL) /*(*/ 00851 00853 struct GX_PARM_OPENMODULE { 00854 const wchar_t *modulename; 00855 const wchar_t *groupname; 00856 gxHANDLE handle; 00857 }; 00858 00859 #ifndef ANDROID 00860 00861 struct GX_PARM_OPENMODULEA { 00862 const char *modulename; 00863 const char *groupname; 00864 gxHANDLE handle; 00865 }; 00866 #endif 00867 00868 struct GX_PARM_CLOSEHANDLE { 00869 gxHANDLE handle; 00870 }; 00871 00872 #endif /* GX_SWIGIF GX_MANUAL )*/ 00873 00874 #if !defined(GX_SWIGIF) /*(*/ 00875 00877 enum GX_INFO_IDS { 00878 GXMODULE_INFO_ID = 0x67780000, 00879 GXUSRDRV_INFO_ID = 0x67786400, 00880 }; 00881 00882 #endif /* GX_SWIGIF )*/ 00883 00884 #if !defined(GX_SWIGIF) && !(defined(GX_DOTNET) && defined(GX_MANUAL)) /*(*/ 00885 00886 #ifdef WIN32 00887 00888 #define GXAPI __stdcall 00889 #endif 00890 #ifdef LINUX 00891 00892 #define GXAPI 00893 #endif 00894 00896 typedef int GXAPI gxmodule_process_t(gxHANDLE mhandle, int function, void *param); 00897 00899 struct gxMODULEINFO { 00900 int id; 00901 int version; 00902 const char *description; 00903 const wchar_t *wdescription; 00905 gxmodule_process_t *process; 00906 }; 00907 00908 #ifndef __cplusplus 00909 typedef struct gxMODULEINFO gxMODULEINFO; 00910 #endif 00911 00912 #endif /* GX_SWIGIF GX_DOTNET GX_MANUAL )*/ 00913 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL) /*(*/ 00914 00916 struct GX_PARM_GETMODULEPROPERTY { 00917 const wchar_t *name; 00918 wchar_t *string; 00919 int maxlen; 00920 }; 00921 00922 #ifndef ANDROID 00923 00924 struct GX_PARM_GETMODULEPROPERTYA { 00925 const char *name; 00926 char *string; 00927 int maxlen; 00928 }; 00929 #endif 00930 00931 struct GX_PARM_SETMODULEPROPERTY { 00932 const wchar_t *name; 00933 const wchar_t *string; 00934 }; 00935 00936 #ifndef ANDROID 00937 00938 struct GX_PARM_SETMODULEPROPERTYA { 00939 const char *name; 00940 const char *string; 00941 }; 00942 #endif 00943 00944 struct GX_PARM_SAVEMODULEPROPERTIES { 00945 const wchar_t *name; 00946 int level; 00947 }; 00948 00949 #ifndef ANDROID 00950 00951 struct GX_PARM_SAVEMODULEPROPERTIESA { 00952 const char *name; 00953 int level; 00954 }; 00955 #endif 00956 #endif /* GX_SWIGIF GX_MANUAL )*/ 00957 00958 #ifdef GX_DOTNET 00959 #pragma managed 00960 #endif 00961 00962 #ifndef GX_EXT_MODULE /*(*/ 00963 /******************************************************************************/ 00965 GX_ENUM GX_DEVICE_FLAGS { 00966 GX_DEVICE_FLAG_TYPE = 1, 00967 GX_DEVICE_FLAG_NAME = 2, 00968 GX_DEVICE_FLAG_SERIAL = 4, 00969 GX_DEVICE_FLAG_SERIAL_NOMSK = 8, 00971 GX_DEVICE_FLAG_EXCLUSIVE = 0x100, 00972 }; 00973 00975 GX_ENUM GX_SYSINFO_FLAGS { 00976 GX_SYSINFO_FLAG_FREEFLOW = 1, 00977 GX_SYSINFO_FLAG_PARKING = 2, 00978 GX_SYSINFO_FLAG_ACCR = 3, 00979 GX_SYSINFO_FLAG_PARKINGLANE = 4, 00980 GX_SYSINFO_FLAG_FACE = 5, 00981 GX_SYSINFO_FLAG_PR = 6, 00982 }; 00983 00984 #endif /*)*/ 00985 00986 #ifdef GX_DOTNET 00987 #pragma unmanaged 00988 #endif 00989 00990 #if !defined(GX_SWIGIF) && !(defined(GX_MANUAL) && defined(GX_DOTNET)) /*(*/ 00991 00993 struct GX_DEVICE_INFO { 00994 wchar_t type[8]; 00995 wchar_t devname[64]; 00996 unsigned int serial; 00997 int priority; 00998 }; 00999 01000 #ifndef __cplusplus 01001 typedef struct GX_DEVICE_INFO GX_DEVICE_INFO; 01002 #endif 01003 01004 #ifndef ANDROID 01005 01006 struct GX_DEVICE_INFOA { 01007 char type[8]; 01008 char devname[64]; 01009 unsigned int serial; 01010 int priority; 01011 }; 01012 #endif 01013 #ifndef __cplusplus 01014 typedef struct GX_DEVICE_INFOA GX_DEVICE_INFOA; 01015 #endif 01016 01018 struct GX_SYSTEM_INFO { 01019 int size; 01020 int cm_ff; 01021 int cm_park; 01022 int cm_accr; 01023 int cm_pl; 01024 int cm_face; 01025 int pr; 01026 }; 01027 01028 #ifndef __cplusplus 01029 typedef struct GX_SYSTEM_INFO GX_SYSTEM_INFO; 01030 #endif 01031 01032 #endif /* GX_SWIGIF GX_MANUAL GX_DOTNET )*/ 01033 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL) /*(*/ 01034 01035 #ifndef ANDROID 01036 01037 struct GX_PARM_LISTDEVICESA { 01038 unsigned int flags; 01039 struct GX_DEVICE_INFOA filter; 01040 int maxitems; 01041 struct GX_DEVICE_INFOA *items; 01042 }; 01043 #endif 01044 01045 struct GX_PARM_LISTDEVICES { 01046 unsigned int flags; 01047 struct GX_DEVICE_INFO filter; 01048 int maxitems; 01049 struct GX_DEVICE_INFO *items; 01050 }; 01051 01053 struct GX_PARM_OPENDEVICE { 01054 unsigned int flags; 01055 struct GX_DEVICE_INFO filter; 01056 int nproperties; 01057 const wchar_t **properties; 01058 int timeoutms; 01059 gxHANDLE handle; 01060 struct GX_DEVICE_INFO info; 01061 }; 01062 01063 #ifndef ANDROID 01064 01065 struct GX_PARM_OPENDEVICEA { 01066 unsigned int flags; 01067 struct GX_DEVICE_INFOA filter; 01068 int nproperties; 01069 const char **properties; 01070 int timeoutms; 01071 gxHANDLE handle; 01072 struct GX_DEVICE_INFOA info; 01073 }; 01075 struct GX_PARM_GETDEVICEPROPERTYA { 01076 const char *name; 01077 int sname; 01078 char *value; 01079 int svalue; 01080 }; 01081 01083 struct GX_PARM_SETDEVICEPROPERTYA { 01084 const char *name; 01085 int sname; 01086 const char *value; 01087 int svalue; 01088 }; 01089 #endif 01090 01092 #define GX_PARM_GETSYSTEMINFO GX_SYSTEM_INFO 01094 #if defined(WIN32) 01095 01098 struct GX_PARM_LISTDEVICESA32 { 01099 unsigned int flags; 01100 struct GX_DEVICE_INFOA filter; 01101 int maxitems; 01102 struct GX_DEVICE_INFOA* __ptr32 items; 01103 }; 01104 01108 struct GX_PARM_LISTDEVICES32 { 01109 unsigned int flags; 01110 struct GX_DEVICE_INFO filter; 01111 int maxitems; 01112 struct GX_DEVICE_INFO* __ptr32 items; 01113 }; 01114 01118 struct GX_PARM_OPENDEVICE32 { 01119 unsigned int flags; 01120 struct GX_DEVICE_INFO filter; 01121 int nproperties; 01122 const wchar_t* __ptr32 * __ptr32 properties; 01123 int timeoutms; 01124 gxHANDLE handle; 01125 struct GX_DEVICE_INFO info; 01126 }; 01127 01131 struct GX_PARM_OPENDEVICEA32 { 01132 unsigned int flags; 01133 struct GX_DEVICE_INFOA filter; 01134 int nproperties; 01135 const char* __ptr32 * __ptr32 properties; 01136 int timeoutms; 01137 gxHANDLE handle; 01138 struct GX_DEVICE_INFOA info; 01139 }; 01140 01144 struct GX_PARM_GETDEVICEPROPERTYA32 { 01145 const char* __ptr32 name; 01146 int sname; 01147 char* __ptr32 value; 01148 int svalue; 01149 }; 01150 01154 struct GX_PARM_SETDEVICEPROPERTYA32 { 01155 const char* __ptr32 name; 01156 int sname; 01157 char* __ptr32 value; 01158 int svalue; 01159 }; 01160 #endif 01161 /******************************************************************************/ 01162 #endif /* GX_SWIGIF GX_MANUAL )*/ 01163 #if !defined(GX_SWIGIF) && !(defined(GX_MANUAL) && defined(GX_DOTNET)) /*(*/ 01164 01165 #ifdef __cplusplus 01166 extern "C" 01167 { 01168 #endif 01169 01181 int GXAPI gx_call(struct gxHANDLE handle, int function, void *params); 01182 #ifdef __cplusplus 01183 } 01184 #endif 01185 01186 #endif /* GX_SWIGIF GX_MANUAL GX_DOTNET )*/ 01187 /******************************************************************************/ 01188 01189 /******************************************************************************/ 01190 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL) /*(*/ 01191 enum GX_MAXLEN_VALUES { 01192 GX_MAXLEN_STRING = 1023, 01193 GX_MAXLEN_ERRVALUE = 255, 01194 GX_MAXLEN_PROPVALUE = 255, 01195 GX_MAXLEN_INT = 32, 01196 GX_MAXLEN_FLOAT = 64, 01197 GX_MAXLEN_VERSION = 20 01198 }; 01199 #endif /* GX_SWIGIF GX_MANUAL )*/ 01200 01201 /******************************************************************************/ 01202 /******************************************************************************/ 01203 #if !defined(GX_SWIGIF) && !defined(NO_GX_FUNCTIONS) /*(*/ 01204 /******************************************************************************* 01205 * Inline functions 01206 ******************************************************************************/ 01207 01208 /******************************************************************************/ 01214 inline gxHANDLE gx_direct(int call_group) { 01215 gxHANDLE ret; 01216 assert((unsigned int)call_group >= (unsigned int)GX_CALL_GROUP_API_FIRST); 01217 ret.handle = (((unsigned int)call_group >> 16) | 0xFFFF0000); 01218 return ret; 01219 } 01220 01221 /******************************************************************************/ 01235 inline int gx_listmodules(unsigned int flags, const wchar_t *filter, wchar_t ***files, 01236 unsigned int **versions, int *nitems) { 01237 gxHANDLE nullhandle = { 0 }; 01238 struct GX_PARM_LISTMODULES m; 01239 int st = 0; 01240 m.flags = flags; 01241 m.filter = filter; 01242 m.files = NULL; 01243 m.versions = NULL; 01244 m.nitems = 0; 01245 01246 st = gx_call(nullhandle, GX_CALL_LISTMODULES, &m); 01247 if(st) { 01248 *files = m.files; 01249 *versions = m.versions; 01250 *nitems = m.nitems; 01251 } else { 01252 *files = NULL; 01253 *versions = NULL; 01254 *nitems = 0; 01255 } 01256 return st; 01257 } 01258 01259 #ifndef ANDROID 01260 /******************************************************************************/ 01274 inline int gx_listmodulesa(unsigned int flags, const char *filter, char ***files, 01275 unsigned int **versions, int *nitems) { 01276 gxHANDLE nullhandle = { 0 }; 01277 struct GX_PARM_LISTMODULESA m; 01278 int st = 0; 01279 m.flags = flags; 01280 m.filter = filter; 01281 m.files = NULL; 01282 m.versions = NULL; 01283 m.nitems = 0; 01284 01285 st = gx_call(nullhandle, GX_CALL_LISTMODULESA, &m); 01286 if(st) { 01287 *files = m.files; 01288 *versions = m.versions; 01289 *nitems = m.nitems; 01290 } else { 01291 *files = NULL; 01292 *versions = NULL; 01293 *nitems = 0; 01294 } 01295 return st; 01296 } 01297 01298 #ifdef __cplusplus 01299 /******************************************************************************/ 01313 inline int gx_listmodules(unsigned int flags, const char *filter, char ***files, 01314 unsigned int **versions, int *nitems) { 01315 return gx_listmodulesa(flags, filter, files, versions, nitems); 01316 } 01317 #endif 01318 #endif 01319 01320 /******************************************************************************* 01321 * Memory operations 01322 ******************************************************************************/ 01323 01324 /******************************************************************************/ 01328 /******************************************************************************/ 01329 01330 /******************************************************************************/ 01342 /******************************************************************************/ 01343 inline int gx_globalrealloc(void **buffer, int sbuffer) { 01344 gxHANDLE nullhandle = { 0 }; 01345 struct GX_PARM_GLOBALREALLOC r; 01346 int ret; 01347 01348 assert(buffer); 01349 assert(sbuffer >= 0); 01350 r.buffer = *buffer; 01351 r.size = sbuffer; 01352 ret = gx_call(nullhandle, GX_CALL_GLOBALREALLOC, &r); 01353 if(ret) *buffer = r.buffer; 01354 return ret; 01355 } 01356 01357 /******************************************************************************/ 01367 inline int gx_globalalloc(void **buffer, int sbuffer) { 01368 assert(buffer); 01369 *buffer = 0; 01370 return gx_globalrealloc(buffer, sbuffer); 01371 } 01372 01373 /******************************************************************************/ 01379 inline int gx_globalfree(void *buffer) { 01380 assert(buffer); 01381 return gx_globalrealloc(&buffer, 0); 01382 } 01383 01384 /******************************************************************************/ 01391 inline int gx_globalsize(int *sbuffer, void *buffer) { 01392 gxHANDLE nullhandle = { 0 }; 01393 struct GX_PARM_GLOBALSIZE s; 01394 int ret; 01395 01396 assert(sbuffer); 01397 assert(buffer); 01398 s.buffer = buffer; 01399 ret = gx_call(nullhandle, GX_CALL_GLOBALSIZE, &s); 01400 if(ret) *sbuffer = s.size; 01401 return ret; 01402 } 01403 01404 /******************************************************************************/ 01418 /******************************************************************************/ 01419 inline int gx_globalrealloc_dbg(void **buffer, int sbuffer, const char *file, int line) { 01420 gxHANDLE nullhandle = { 0 }; 01421 struct GX_PARM_GLOBALREALLOC_DBG r; 01422 int ret; 01423 01424 assert(buffer); 01425 assert(sbuffer >= 0); 01426 r.buffer = *buffer; 01427 r.size = sbuffer; 01428 r.file = file; 01429 r.line = line; 01430 ret = gx_call(nullhandle, GX_CALL_GLOBALREALLOC_DBG, &r); 01431 if(ret) *buffer = r.buffer; 01432 return ret; 01433 } 01434 01435 /******************************************************************************/ 01447 inline int gx_globalalloc_dbg(void **buffer, int sbuffer,const char *file, int line) { 01448 assert(buffer); 01449 *buffer = 0; 01450 return gx_globalrealloc_dbg(buffer, sbuffer, file, line); 01451 } 01452 01453 /******************************************************************************/ 01459 inline int gx_globalcheck_dbg() { 01460 gxHANDLE nullhandle = { 0 }; 01461 return gx_call(nullhandle, GX_CALL_GLOBALCHECK_DBG, 0); 01462 } 01463 01464 /******************************************************************************/ 01478 inline int gx_globaltestmem_dbg(int index, char *fnbuffer, int fnbsize, char *membuffer, int mbsize 01479 , int *line, int *size, void **address) { 01480 01481 gxHANDLE nullhandle = { 0 }; 01482 struct GX_PARM_GLOBALTESTMEM_DBG gtm; 01483 01484 gtm.index = index; 01485 gtm.fnbuffer = fnbuffer; 01486 gtm.fnbsize = fnbsize; 01487 gtm.membuffer = membuffer; 01488 gtm.mbsize = mbsize; 01489 if(!gx_call(nullhandle, GX_CALL_GLOBALTESTMEM_DBG, >m)) return 0; 01490 if(line) *line = gtm.line; 01491 if(size) *size = gtm.size; 01492 if(address) *address = gtm.address; 01493 return true; 01494 } 01495 01496 #if defined(GX_TESTMEMORY) || defined(GX_TESTLEAKS) 01497 01499 #define gx_globalrealloc(buf,sbuf) gx_globalrealloc_dbg(buf,sbuf, __FILE__, __LINE__) 01500 01501 #define gx_globalalloc(buf,sbuf) gx_globalalloc_dbg(buf,sbuf, __FILE__, __LINE__) 01502 01503 #else 01504 01506 #define gx_globalrealloc_dbg(buf,sbuf,f,l) gx_globalrealloc(buf,sbuf) 01507 01508 #define gx_globalalloc_dbg(buf,sbuf,f,l) gx_globalalloc(buf,sbuf) 01509 01510 #endif 01511 01512 /******************************************************************************/ 01521 inline int gx_creatememslot(int *handle,void **mem) { 01522 gxHANDLE nullhandle = { 0 }; 01523 struct GX_PARM_CREATEMEMSLOT cm; 01524 assert(handle && mem); 01525 if(!gx_call(nullhandle, GX_CALL_CREATEMEMSLOT, &cm)) return 0; 01526 if(handle) *handle = cm.handle; 01527 if(mem) *mem = cm.mem; 01528 return true; 01529 } 01530 01531 /******************************************************************************/ 01538 inline int gx_getmemslot(int handle,void **mem) { 01539 gxHANDLE nullhandle = { 0 }; 01540 struct GX_PARM_GETMEMSLOT gm; 01541 assert(mem); 01542 gm.handle = handle; 01543 if(!gx_call(nullhandle, GX_CALL_GETMEMSLOT, &gm)) return 0; 01544 if(mem) *mem = gm.mem; 01545 return true; 01546 } 01547 01548 /******************************************************************************/ 01556 inline int gx_unrefmemslot(int handle) { 01557 gxHANDLE nullhandle = { 0 }; 01558 struct GX_PARM_UNREFMEMSLOT um; 01559 um.handle = handle; 01560 return gx_call(nullhandle, GX_CALL_UNREFMEMSLOT, &um); 01561 } 01562 01563 /******************************************************************************/ 01565 /******************************************************************************/ 01566 01567 /******************************************************************************* 01568 * Module operations 01569 ******************************************************************************/ 01570 01571 /******************************************************************************/ 01575 /******************************************************************************/ 01576 01577 /******************************************************************************/ 01606 inline int gx_openmodule(gxHANDLE *handle, const wchar_t *modulename, const wchar_t *groupname) { 01607 gxHANDLE nullhandle = { 0 }; 01608 struct GX_PARM_OPENMODULE op; 01609 01610 assert(handle); 01611 assert(modulename); 01612 op.modulename = modulename; 01613 op.groupname = groupname; 01614 if(!gx_call(nullhandle, GX_CALL_OPENMODULE, &op)) return false; 01615 *handle = op.handle; 01616 return true; 01617 } 01618 01619 #ifndef ANDROID 01620 /******************************************************************************/ 01649 inline int gx_openmodulea(gxHANDLE *handle, const char *modulename, const char *groupname) { 01650 gxHANDLE nullhandle = { 0 }; 01651 struct GX_PARM_OPENMODULEA op; 01652 01653 assert(handle); 01654 assert(modulename); 01655 op.modulename = modulename; 01656 op.groupname = groupname; 01657 if(!gx_call(nullhandle, GX_CALL_OPENMODULEA, &op)) return false; 01658 *handle = op.handle; 01659 return true; 01660 } 01661 01662 #ifdef __cplusplus 01663 /******************************************************************************/ 01692 inline int gx_openmodule(gxHANDLE *handle, const char *modulename, const char *groupname) { 01693 return gx_openmodulea(handle, modulename, groupname); 01694 } 01695 #endif 01696 #endif 01697 /******************************************************************************/ 01706 inline int gx_closehandle(gxHANDLE *handle) { 01707 gxHANDLE nullhandle = { 0 }; 01708 struct GX_PARM_CLOSEHANDLE cl; 01709 assert(handle); 01710 cl.handle = *handle; 01711 if(!gx_call(nullhandle, GX_CALL_CLOSEHANDLE, &cl)) return false; 01712 handle->handle = 0; /* invalid handle */ 01713 return true; 01714 } 01715 01716 /******************************************************************************/ 01718 /******************************************************************************/ 01722 /******************************************************************************/ 01723 01724 /******************************************************************************/ 01730 inline int gx_refhandle(gxHANDLE handle) { 01731 gxHANDLE nullhandle = { 0 }; 01732 return gx_call(nullhandle, GX_CALL_REFHANDLE, &handle); 01733 } 01734 01735 /******************************************************************************/ 01741 inline int gx_unrefhandle(gxHANDLE *handle) { 01742 gxHANDLE nullhandle = { 0 }; 01743 return gx_call(nullhandle, GX_CALL_UNREFHANDLE, handle); 01744 } 01745 01746 /******************************************************************************/ 01748 /******************************************************************************/ 01749 01750 /******************************************************************************/ 01757 inline int gx_isvalidhandle(gxHANDLE handle) { 01758 return handle.handle ? true : false; 01759 } 01760 01761 /******************************************************************************/ 01765 /******************************************************************************/ 01766 01767 /******************************************************************************/ 01778 inline int gx_getmoduleinfo(gxHANDLE handle, const gxMODULEINFO **moduleinfo) { 01779 assert(moduleinfo); 01780 return gx_call(handle, GX_CALL_GETMODULEINFO, (void *)moduleinfo); 01781 } 01782 01783 /******************************************************************************/ 01785 /******************************************************************************/ 01789 /******************************************************************************/ 01790 01791 /******************************************************************************/ 01807 inline int gx_getmoduleproperty(gxHANDLE handle, const wchar_t *name, wchar_t *string, int maxlen) { 01808 struct GX_PARM_GETMODULEPROPERTY gp; 01809 gp.name = name; 01810 gp.string = string; 01811 gp.maxlen = maxlen; 01812 return gx_call(handle, GX_CALL_GETMODULEPROPERTY, &gp); 01813 } 01814 01815 #ifndef ANDROID 01816 /******************************************************************************/ 01832 inline int gx_getmodulepropertya(gxHANDLE handle, const char *name, char *string, int maxlen) { 01833 struct GX_PARM_GETMODULEPROPERTYA gp; 01834 gp.name = name; 01835 gp.string = string; 01836 gp.maxlen = maxlen; 01837 return gx_call(handle, GX_CALL_GETMODULEPROPERTYA, &gp); 01838 } 01839 01840 #ifdef __cplusplus 01841 /******************************************************************************/ 01857 inline int gx_getmoduleproperty(gxHANDLE handle, const char *name, char *string, int maxlen) { 01858 return gx_getmodulepropertya(handle, name, string, maxlen); 01859 } 01860 #endif 01861 #endif 01862 /******************************************************************************/ 01877 inline int gx_getmodulepropertyint(gxHANDLE handle, const wchar_t *name, int *ivalue) { 01878 wchar_t ibuf[GX_MAXLEN_INT+1]; 01879 int ret; 01880 assert(ivalue); 01881 ibuf[GX_MAXLEN_INT] = 0; 01882 ret = gx_getmoduleproperty(handle, name, ibuf, GX_MAXLEN_INT); 01883 if(ret) { 01884 *ivalue = (int)gx_wcstol(ibuf, 0, 10); 01885 } 01886 return ret; 01887 } 01888 01889 #ifdef __cplusplus 01890 /******************************************************************************/ 01905 inline int gx_getmoduleproperty(gxHANDLE handle, const wchar_t *name, int *ivalue) { 01906 return gx_getmodulepropertyint(handle, name, ivalue); 01907 } 01908 #endif 01909 01910 #ifndef ANDROID 01911 /******************************************************************************/ 01926 inline int gx_getmodulepropertyinta(gxHANDLE handle, const char *name, int *ivalue) { 01927 char ibuf[GX_MAXLEN_INT+1]; 01928 int ret; 01929 assert(ivalue); 01930 ibuf[sizeof(ibuf)-1] = 0; 01931 ret = gx_getmodulepropertya(handle, name, ibuf, sizeof(ibuf)-1); 01932 if(ret) { 01933 *ivalue = atoi(ibuf); 01934 } 01935 return ret; 01936 } 01937 01938 #ifdef __cplusplus 01939 /******************************************************************************/ 01954 inline int gx_getmoduleproperty(gxHANDLE handle, const char *name, int *ivalue) { 01955 return gx_getmodulepropertyinta(handle, name, ivalue); 01956 } 01957 01958 /******************************************************************************/ 01973 inline int gx_getmodulepropertyint(gxHANDLE handle, const char *name, int *ivalue) { 01974 return gx_getmodulepropertyinta(handle, name, ivalue); 01975 } 01976 #endif 01977 #endif 01978 /******************************************************************************/ 01993 inline int gx_getmodulepropertyfloat(gxHANDLE handle, const wchar_t *name, double *fvalue) { 01994 wchar_t fbuf[GX_MAXLEN_FLOAT+1]; 01995 int ret; 01996 assert(fvalue); 01997 fbuf[GX_MAXLEN_FLOAT] = 0; 01998 ret = gx_getmoduleproperty(handle, name, fbuf, GX_MAXLEN_FLOAT); 01999 if(ret) { 02000 *fvalue = (double)wcstod(fbuf, 0); 02001 } 02002 return ret; 02003 } 02004 02005 #ifdef __cplusplus 02006 /******************************************************************************/ 02021 inline int gx_getmoduleproperty(gxHANDLE handle, const wchar_t *name, double *fvalue) { 02022 return gx_getmodulepropertyfloat(handle, name, fvalue); 02023 } 02024 #endif 02025 02026 #ifndef ANDROID 02027 /******************************************************************************/ 02042 inline int gx_getmodulepropertyfloata(gxHANDLE handle, const char *name, double *fvalue) { 02043 char fbuf[GX_MAXLEN_FLOAT+1]; 02044 int ret; 02045 assert(fvalue); 02046 fbuf[sizeof(fbuf)-1] = 0; 02047 ret = gx_getmodulepropertya(handle, name, fbuf, sizeof(fbuf)-1); 02048 if(ret) { 02049 *fvalue = (double)atof(fbuf); 02050 } 02051 return ret; 02052 } 02053 02054 #ifdef __cplusplus 02055 /******************************************************************************/ 02070 inline int gx_getmoduleproperty(gxHANDLE handle, const char *name, double *fvalue) { 02071 return gx_getmodulepropertyfloata(handle, name, fvalue); 02072 } 02073 /******************************************************************************/ 02088 inline int gx_getmodulepropertyfloat(gxHANDLE handle, const char *name, double *fvalue) { 02089 return gx_getmodulepropertyfloata(handle, name, fvalue); 02090 } 02091 #endif 02092 #endif 02093 02094 /******************************************************************************/ 02109 inline int gx_getmodulepropertyversion(gxHANDLE handle, const wchar_t *name, unsigned int *version) { 02110 wchar_t fbuf[GX_MAXLEN_VERSION+1]; 02111 int ret; 02112 assert(version); 02113 fbuf[GX_MAXLEN_VERSION] = 0; 02114 ret = gx_getmoduleproperty(handle, name, fbuf, GX_MAXLEN_VERSION); 02115 if(ret) { 02116 int ix; 02117 unsigned int ver = 0; 02118 wchar_t *s = fbuf; 02119 for(ix = 0; (ix < 4) && *s; ix++) { 02120 ver = (ver << 8) + gx_wcstol(s, &s, 10); 02121 if(*s == '.') s++; 02122 } 02123 *version = ver; 02124 } 02125 return ret; 02126 } 02127 02128 #ifndef ANDROID 02129 /******************************************************************************/ 02144 inline int gx_getmodulepropertyversiona(gxHANDLE handle, const char *name, unsigned int *version) { 02145 char fbuf[GX_MAXLEN_VERSION+1]; 02146 int ret; 02147 fbuf[sizeof(fbuf)-1] = 0; 02148 ret = gx_getmodulepropertya(handle, name, fbuf, sizeof(fbuf)-1); 02149 if(ret) { 02150 int ix; 02151 unsigned int ver = 0; 02152 char *s = fbuf; 02153 for(ix = 0; (ix < 4) && *s; ix++) { 02154 ver = (ver << 8) + strtol(s, &s, 10); 02155 if(*s == '.') s++; 02156 } 02157 *version = ver; 02158 } 02159 return ret; 02160 } 02161 02162 #ifdef __cplusplus 02163 /******************************************************************************/ 02178 inline int gx_getmodulepropertyversion(gxHANDLE handle, const char *name, unsigned int *version) { 02179 return gx_getmodulepropertyversiona(handle, name, version); 02180 } 02181 #endif 02182 #endif 02183 /******************************************************************************/ 02198 inline int gx_setmoduleproperty(gxHANDLE handle, const wchar_t *name, const wchar_t *string) { 02199 struct GX_PARM_SETMODULEPROPERTY sp; 02200 sp.name = name; 02201 sp.string = string; 02202 return gx_call(handle, GX_CALL_SETMODULEPROPERTY, &sp); 02203 } 02204 02205 #ifndef ANDROID 02206 /******************************************************************************/ 02221 inline int gx_setmodulepropertya(gxHANDLE handle, const char *name, const char *string) { 02222 struct GX_PARM_SETMODULEPROPERTYA sp; 02223 sp.name = name; 02224 sp.string = string; 02225 return gx_call(handle, GX_CALL_SETMODULEPROPERTYA, &sp); 02226 } 02227 02228 #ifdef __cplusplus 02229 /******************************************************************************/ 02244 inline int gx_setmoduleproperty(gxHANDLE handle, const char *name, const char *string) { 02245 return gx_setmodulepropertya(handle, name, string); 02246 } 02247 #endif 02248 #endif 02249 /******************************************************************************/ 02264 inline int gx_setmodulepropertyint(gxHANDLE handle, const wchar_t *name, int ivalue) { 02265 wchar_t ibuf[GX_MAXLEN_INT+1]; 02266 gx_snwprintf(ibuf, GX_MAXLEN_INT+1, L"%i", ivalue); 02267 ibuf[GX_MAXLEN_INT] = 0; 02268 return gx_setmoduleproperty(handle, name, ibuf); 02269 } 02270 02271 #ifdef __cplusplus 02272 /******************************************************************************/ 02287 inline int gx_setmoduleproperty(gxHANDLE handle, const wchar_t *name, int ivalue) { 02288 return gx_setmodulepropertyint(handle, name, ivalue); 02289 } 02290 #endif 02291 02292 #ifndef ANDROID 02293 /******************************************************************************/ 02308 inline int gx_setmodulepropertyinta(gxHANDLE handle, const char *name, int ivalue) { 02309 char ibuf[GX_MAXLEN_INT+1]; 02310 gx_snprintf(ibuf, GX_MAXLEN_INT+1, "%i", ivalue); 02311 ibuf[GX_MAXLEN_INT] = 0; 02312 return gx_setmodulepropertya(handle, name, ibuf); 02313 } 02314 02315 #ifdef __cplusplus 02316 /******************************************************************************/ 02331 inline int gx_setmoduleproperty(gxHANDLE handle, const char *name, int ivalue) { 02332 return gx_setmodulepropertyinta(handle, name, ivalue); 02333 } 02334 02335 /******************************************************************************/ 02350 inline int gx_setmodulepropertyint(gxHANDLE handle, const char *name, int ivalue) { 02351 return gx_setmodulepropertyinta(handle, name, ivalue); 02352 } 02353 #endif 02354 #endif 02355 /******************************************************************************/ 02370 inline int gx_setmodulepropertyfloat(gxHANDLE handle, const wchar_t *name, double fvalue) { 02371 wchar_t fbuf[GX_MAXLEN_FLOAT+1]; 02372 gx_snwprintf(fbuf, GX_MAXLEN_FLOAT+1, L"%f", fvalue); 02373 fbuf[GX_MAXLEN_FLOAT] = 0; 02374 return gx_setmoduleproperty(handle, name, fbuf); 02375 } 02376 02377 #ifdef __cplusplus 02378 /******************************************************************************/ 02393 inline int gx_setmoduleproperty(gxHANDLE handle, const wchar_t *name, double fvalue) { 02394 return gx_setmodulepropertyfloat(handle, name, fvalue); 02395 } 02396 #endif 02397 02398 #ifndef ANDROID 02399 /******************************************************************************/ 02414 inline int gx_setmodulepropertyfloata(gxHANDLE handle, const char *name, double fvalue) { 02415 char fbuf[GX_MAXLEN_FLOAT+1]; 02416 gx_snprintf(fbuf, GX_MAXLEN_FLOAT+1, "%f", fvalue); 02417 fbuf[GX_MAXLEN_FLOAT] = 0; 02418 return gx_setmodulepropertya(handle, name, fbuf); 02419 } 02420 02421 #ifdef __cplusplus 02422 /******************************************************************************/ 02437 inline int gx_setmoduleproperty(gxHANDLE handle, const char *name, double fvalue) { 02438 return gx_setmodulepropertyfloata(handle, name, fvalue); 02439 } 02440 02441 /******************************************************************************/ 02456 inline int gx_setmodulepropertyfloat(gxHANDLE handle, const char *name, double fvalue) { 02457 return gx_setmodulepropertyfloata(handle, name, fvalue); 02458 } 02459 #endif 02460 #endif 02461 /******************************************************************************/ 02469 inline int gx_mpstarttransaction(gxHANDLE handle) { 02470 return gx_call(handle, GX_CALL_MPSTARTTRANSACTION, (void *)0); 02471 } 02472 02473 /******************************************************************************/ 02479 inline int gx_mpcommit(gxHANDLE handle) { 02480 return gx_call(handle, GX_CALL_MPCOMMIT, (void *)0); 02481 } 02482 02483 /******************************************************************************/ 02494 inline int gx_savemoduleproperties(gxHANDLE handle, const wchar_t *name, int level GX_DEFARG(0)) { 02495 struct GX_PARM_SAVEMODULEPROPERTIES mp; 02496 mp.name = name; 02497 mp.level = level; 02498 return gx_call(handle, GX_CALL_SAVEMODULEPROPERTIES, &mp); 02499 } 02500 02501 #ifndef ANDROID 02502 /******************************************************************************/ 02513 inline int gx_savemodulepropertiesa(gxHANDLE handle, const char *name, int level GX_DEFARG(0)) { 02514 struct GX_PARM_SAVEMODULEPROPERTIESA mp; 02515 mp.name = name; 02516 mp.level = level; 02517 return gx_call(handle, GX_CALL_SAVEMODULEPROPERTIESA, &mp); 02518 } 02519 02520 #ifdef __cplusplus 02521 /******************************************************************************/ 02532 inline int gx_savemoduleproperties(gxHANDLE handle, const char *name, int level = 0) { 02533 return gx_savemodulepropertiesa(handle, name, level); 02534 } 02535 #endif 02536 #endif 02537 /******************************************************************************/ 02539 /******************************************************************************/ 02543 /******************************************************************************/ 02544 02545 /******************************************************************************* 02546 * ERRORS 02547 ******************************************************************************/ 02548 02549 /******************************************************************************/ 02557 inline int gx_geterror(int *code, wchar_t *string, int maxlen) { 02558 gxHANDLE nullhandle = { 0 }; 02559 struct GX_PARM_GETERROR me; 02560 int err_code; 02561 me.string = string; 02562 me.maxlen = maxlen; 02563 err_code = gx_call(nullhandle, GX_CALL_GETERROR, &me); 02564 if(code) *code = me.code; 02565 return err_code; 02566 } 02567 02568 #ifndef ANDROID 02569 /******************************************************************************/ 02577 inline int gx_geterrora(int *code, char *string, int maxlen) { 02578 gxHANDLE nullhandle = { 0 }; 02579 struct GX_PARM_GETERRORA me; 02580 int err_code; 02581 me.string = string; 02582 me.maxlen = maxlen; 02583 err_code = gx_call(nullhandle, GX_CALL_GETERRORA, &me); 02584 if(code) *code = me.code; 02585 return err_code; 02586 } 02587 /******************************************************************************/ 02588 02589 #ifdef __cplusplus 02590 02597 inline int gx_geterror(int *code, char *string = (char *)0, int maxlen = 0) { 02598 return gx_geterrora(code, string, maxlen); 02599 } 02600 #endif 02601 #endif 02602 /******************************************************************************/ 02606 inline int gx_geterrorcode(void) { 02607 gxHANDLE nullhandle = { 0 }; 02608 return gx_call(nullhandle, GX_CALL_GETERROR, (void *)0); 02609 } 02610 /******************************************************************************/ 02611 #ifdef __cplusplus 02612 02615 inline int gx_geterror(void) { 02616 return gx_geterrorcode(); 02617 } 02618 #endif 02619 02620 /******************************************************************************/ 02631 inline int gx_seterrorfv(int flags, int code, const wchar_t *wformat, va_list args) { 02632 gxHANDLE nullhandle = { 0 }; 02633 struct GX_PARM_SETERROR se; 02634 int st; 02635 se.flags = flags; 02636 se.code = code; 02637 se.appformat = wformat; 02638 if(wformat) va_copy(se.arguments, args); 02639 st = gx_call(nullhandle, GX_CALL_SETERROR, &se); 02640 if(wformat) va_end(se.arguments); 02641 return st; 02642 } 02643 02644 #ifdef __cplusplus 02645 02655 inline int gx_seterrorv(int flags, int code, const wchar_t *wformat, va_list args) { 02656 return gx_seterrorfv(flags, code, wformat, args); 02657 } 02658 #endif 02659 02660 #ifndef ANDROID 02661 /******************************************************************************/ 02672 inline int gx_seterrorafv(int flags, int code, const char *wformat, va_list args) { 02673 gxHANDLE nullhandle = { 0 }; 02674 struct GX_PARM_SETERRORA se; 02675 int st; 02676 se.flags = flags; 02677 se.code = code; 02678 se.appformat = wformat; 02679 if(wformat) va_copy(se.arguments, args); 02680 st = gx_call(nullhandle, GX_CALL_SETERRORA, &se); 02681 if(wformat) va_end(se.arguments); 02682 return st; 02683 } 02684 02685 #ifdef __cplusplus 02686 02696 inline int gx_seterrorv(int flags, int code, const char *wformat, va_list args) { 02697 return gx_seterrorafv(flags, code, wformat, args); 02698 } 02699 #endif 02700 #endif 02701 /******************************************************************************/ 02710 inline int gx_seterrorv(int code, const wchar_t *wformat, va_list args) { 02711 return gx_seterrorfv(_GX_ERR_FLAG_CLEAR, code, wformat, args); 02712 } 02713 02714 #ifndef ANDROID 02715 /******************************************************************************/ 02724 inline int gx_seterrorav(int code, const char *wformat, va_list args) { 02725 return gx_seterrorafv(_GX_ERR_FLAG_CLEAR, code, wformat, args); 02726 } 02727 02728 #ifdef __cplusplus 02729 /******************************************************************************/ 02738 inline int gx_seterrorv(int code, const char *wformat, va_list args) { 02739 return gx_seterrorafv(_GX_ERR_FLAG_CLEAR, code, wformat, args); 02740 } 02741 #endif 02742 #endif 02743 /******************************************************************************/ 02752 inline int gx_appenderrorv(int code, const wchar_t *wformat, va_list args) { 02753 return gx_seterrorfv(_GX_ERR_FLAG_APPEND, code, wformat, args); 02754 } 02755 02756 #ifndef ANDROID 02757 /******************************************************************************/ 02766 inline int gx_appenderrorav(int code, const char *wformat, va_list args) { 02767 return gx_seterrorafv(_GX_ERR_FLAG_APPEND, code, wformat, args); 02768 } 02769 02770 #ifdef __cplusplus 02771 /******************************************************************************/ 02780 inline int gx_appenderrorv(int code, const char *wformat, va_list args) { 02781 return gx_seterrorafv(_GX_ERR_FLAG_APPEND, code, wformat, args); 02782 } 02783 #endif 02784 #endif 02785 /******************************************************************************/ 02794 inline int gx_prependerrorv(int code, const wchar_t *wformat, va_list args) { 02795 return gx_seterrorfv(_GX_ERR_FLAG_PREPEND, code, wformat, args); 02796 } 02797 02798 #ifndef ANDROID 02799 /******************************************************************************/ 02808 inline int gx_prependerrorav(int code, const char *wformat, va_list args) { 02809 return gx_seterrorafv(_GX_ERR_FLAG_PREPEND, code, wformat, args); 02810 } 02811 02812 #ifdef __cplusplus 02813 /******************************************************************************/ 02822 inline int gx_prependerrorv(int code, const char *wformat, va_list args) { 02823 return gx_seterrorafv(_GX_ERR_FLAG_PREPEND, code, wformat, args); 02824 } 02825 #endif 02826 #endif 02827 /******************************************************************************/ 02838 inline int gx_seterrorf(int flags, int code, const wchar_t *wformat, ...) { 02839 va_list args; 02840 int st; 02841 va_start(args, wformat); 02842 st = gx_seterrorfv(flags, code, wformat, args); 02843 va_end(args); 02844 return st; 02845 } 02846 02847 #ifdef __cplusplus 02848 02858 inline int gx_seterror(int flags, int code, const wchar_t *wformat = (const wchar_t *)0, ...) { 02859 va_list args; 02860 int st; 02861 va_start(args, wformat); 02862 st = gx_seterrorfv(flags, code, wformat, args); 02863 va_end(args); 02864 return st; 02865 } 02866 #endif 02867 02868 #ifndef ANDROID 02869 /******************************************************************************/ 02880 inline int gx_seterroraf(int flags, int code, const char *wformat, ...) { 02881 va_list args; 02882 int st; 02883 va_start(args, wformat); 02884 st = gx_seterrorafv(flags, code, wformat, args); 02885 va_end(args); 02886 return st; 02887 } 02888 02889 #ifdef __cplusplus 02890 02900 inline int gx_seterror(int flags, int code, const char *wformat = (const char *)0, ...) { 02901 va_list args; 02902 int st; 02903 va_start(args, wformat); 02904 st = gx_seterrorafv(flags, code, wformat, args); 02905 va_end(args); 02906 return st; 02907 } 02908 #endif 02909 #endif 02910 /******************************************************************************/ 02915 inline int gx_clearerror(void) { 02916 return gx_seterrorf(_GX_ERR_FLAG_CLEAR, 0, L""); 02917 } 02918 02919 /******************************************************************************/ 02928 inline int gx_seterrorcodef(int flags, int code) { 02929 return gx_seterrorf(flags, code, L""); 02930 } 02931 02932 /******************************************************************************/ 02939 inline int gx_seterrorcode(int code) { 02940 return gx_seterrorf(_GX_ERR_FLAG_CLEAR, code, L""); 02941 } 02942 02943 /******************************************************************************/ 02950 inline int gx_appenderrorcode(int code) { 02951 return gx_seterrorf(_GX_ERR_FLAG_APPEND, code, L""); 02952 } 02953 02954 /******************************************************************************/ 02961 inline int gx_prependerrorcode(int code) { 02962 return gx_seterrorf(_GX_ERR_FLAG_PREPEND, code, L""); 02963 } 02964 02965 /******************************************************************************/ 02974 inline int gx_seterror(int code, const wchar_t *wformat, ...) { 02975 va_list args; 02976 int st; 02977 va_start(args, wformat); 02978 st = gx_seterrorv(code, wformat, args); 02979 va_end(args); 02980 return st; 02981 } 02982 02983 /******************************************************************************/ 02984 #ifdef __cplusplus 02985 02991 inline int gx_seterror(int code) { 02992 return gx_seterrorcode(code); 02993 } 02994 #endif 02995 02996 #ifndef ANDROID 02997 /******************************************************************************/ 03006 inline int gx_seterrora(int code, const char *wformat, ...) { 03007 va_list args; 03008 int st; 03009 va_start(args, wformat); 03010 st = gx_seterrorav(code, wformat, args); 03011 va_end(args); 03012 return st; 03013 } 03014 03015 /******************************************************************************/ 03016 #ifdef __cplusplus 03017 03025 inline int gx_seterror(int code, const char *wformat, ...) { 03026 va_list args; 03027 va_start(args, wformat); 03028 int st = gx_seterrorav(code, wformat, args); 03029 va_end(args); 03030 return st; 03031 } 03032 #endif 03033 #endif 03034 03035 /******************************************************************************/ 03044 inline int gx_appenderror(int code, const wchar_t *wformat, ...) { 03045 va_list args; 03046 int st; 03047 va_start(args, wformat); 03048 st = gx_appenderrorv(code, wformat, args); 03049 va_end(args); 03050 return st; 03051 } 03052 03053 /******************************************************************************/ 03054 #ifdef __cplusplus 03055 03061 inline int gx_appenderror(int code) { 03062 return gx_appenderrorcode(code); 03063 } 03064 #endif 03065 03066 #ifndef ANDROID 03067 /******************************************************************************/ 03076 inline int gx_appenderrora(int code, const char *wformat, ...) { 03077 va_list args; 03078 int st; 03079 va_start(args, wformat); 03080 st = gx_appenderrorav(code, wformat, args); 03081 va_end(args); 03082 return st; 03083 } 03084 03085 /******************************************************************************/ 03086 #ifdef __cplusplus 03087 03095 inline int gx_appenderror(int code, const char *wformat, ...) { 03096 va_list args; 03097 va_start(args, wformat); 03098 int st = gx_appenderrorav(code, wformat, args); 03099 va_end(args); 03100 return st; 03101 } 03102 #endif 03103 #endif 03104 03105 /******************************************************************************/ 03114 inline int gx_prependerror(int code, const wchar_t *wformat, ...) { 03115 va_list args; 03116 int st; 03117 va_start(args, wformat); 03118 st = gx_prependerrorv(code, wformat, args); 03119 va_end(args); 03120 return st; 03121 } 03122 03123 /******************************************************************************/ 03124 #ifdef __cplusplus 03125 03132 inline int gx_prependerror(int code) { 03133 return gx_prependerrorcode(code); 03134 } 03135 #endif 03136 03137 #ifndef ANDROID 03138 /******************************************************************************/ 03147 inline int gx_prependerrora(int code, const char *wformat, ...) { 03148 va_list args; 03149 int st; 03150 va_start(args, wformat); 03151 st = gx_prependerrorav(code, wformat, args); 03152 va_end(args); 03153 return st; 03154 } 03155 03156 /******************************************************************************/ 03157 #ifdef __cplusplus 03158 03166 inline int gx_prependerror(int code, const char *wformat, ...) { 03167 va_list args; 03168 va_start(args, wformat); 03169 int st = gx_prependerrorv(code, wformat, args); 03170 va_end(args); 03171 return st; 03172 } 03173 #endif 03174 #endif 03175 /******************************************************************************/ 03182 inline int gx_updateerrtable(int nitems, const gxERRITEM *items) { 03183 gxHANDLE nullhandle = { 0 }; 03184 struct GX_PARM_UPDATEERRTABLE ut; 03185 ut.nitems = nitems; 03186 ut.items = items; 03187 return gx_call(nullhandle, GX_CALL_UPDATEERRTABLE, &ut); 03188 } 03189 03190 /******************************************************************************/ 03195 inline int gx_pusherror(void) { 03196 gxHANDLE nullhandle = { 0 }; 03197 return gx_call(nullhandle, GX_CALL_PUSHERROR, (void *)0); 03198 } 03199 03200 /******************************************************************************/ 03205 inline int gx_poperror(void) { 03206 gxHANDLE nullhandle = { 0 }; 03207 return gx_call(nullhandle, GX_CALL_POPERROR, (void *)0); 03208 } 03209 03210 /******************************************************************************/ 03212 /******************************************************************************/ 03213 03214 /******************************************************************************* 03215 * DEVICE HANDLING 03216 ******************************************************************************/ 03217 03218 /******************************************************************************/ 03222 /******************************************************************************/ 03223 03224 /******************************************************************************/ 03235 inline int gx_listdevices(int *nitems, GX_DEVICE_INFO *items, 03236 unsigned int flags GX_DEFARG(0), GX_DEVICE_INFO *filter GX_DEFARG(0)) { 03237 gxHANDLE nullhandle = { 0 }; 03238 struct GX_PARM_LISTDEVICES pr; 03239 int st; 03240 03241 assert(nitems && items); 03242 memset(&pr, 0, sizeof(pr)); 03243 pr.flags = flags; 03244 if(filter) memcpy(&pr.filter, filter, sizeof(pr.filter)); 03245 pr.maxitems = *nitems; 03246 pr.items = items; 03247 st = gx_call(nullhandle, GX_CALL_LISTDEVICES, &pr); 03248 if(st) *nitems = pr.maxitems; 03249 return st; 03250 } 03251 03252 #ifndef ANDROID 03253 /******************************************************************************/ 03264 inline int gx_listdevicesa(int *nitems, GX_DEVICE_INFOA *items, 03265 unsigned int flags, GX_DEVICE_INFOA *filter) { 03266 03267 gxHANDLE nullhandle = { 0 }; 03268 struct GX_PARM_LISTDEVICESA pr; 03269 int st; 03270 03271 assert(nitems && items); 03272 memset(&pr, 0, sizeof(pr)); 03273 pr.flags = flags; 03274 if(filter) memcpy(&pr.filter, filter, sizeof(pr.filter)); 03275 pr.maxitems = *nitems; 03276 pr.items = items; 03277 st = gx_call(nullhandle, GX_CALL_LISTDEVICESA, &pr); 03278 if(st) *nitems = pr.maxitems; 03279 return st; 03280 } 03281 03282 #ifdef __cplusplus 03283 /******************************************************************************/ 03294 inline int gx_listdevices(int *nitems, GX_DEVICE_INFOA *items, 03295 unsigned int flags = 0, GX_DEVICE_INFOA *filter = 0) { 03296 return gx_listdevicesa(nitems, items, flags, filter); 03297 } 03298 #endif 03299 03300 /******************************************************************************/ 03312 inline int gx_opendevicea(gxHANDLE *handle, GX_DEVICE_INFOA *info, 03313 unsigned int flags, GX_DEVICE_INFOA *filter, 03314 int nproperties, const char **properties, 03315 int timeoutms) { 03316 03317 gxHANDLE nullhandle = { 0 }; 03318 struct GX_PARM_OPENDEVICEA pr; 03319 int st; 03320 03321 assert(handle); 03322 pr.flags = flags; 03323 if(filter) memcpy(&pr.filter, filter, sizeof(pr.filter)); 03324 pr.properties = properties; 03325 pr.nproperties = nproperties; 03326 pr.timeoutms = timeoutms; 03327 st = gx_call(nullhandle, GX_CALL_OPENDEVICEA, &pr); 03328 if(st) { 03329 *handle = pr.handle; 03330 if(info) memcpy(info, &pr.info, sizeof(GX_DEVICE_INFOA)); 03331 } 03332 return st; 03333 } 03334 03335 #ifdef __cplusplus 03336 /******************************************************************************/ 03348 inline int gx_opendevice(gxHANDLE *handle, GX_DEVICE_INFOA *info, 03349 unsigned int flags = 0, GX_DEVICE_INFOA *filter = 0, 03350 int nproperties = 0, const char **properties = 0, 03351 int timeoutms = 0) { 03352 03353 return gx_opendevicea(handle, info, flags, filter, 03354 nproperties, properties, timeoutms); 03355 } 03356 #endif 03357 #endif 03358 /******************************************************************************/ 03370 inline int gx_opendevice(gxHANDLE *handle, GX_DEVICE_INFO *info, 03371 unsigned int flags GX_DEFARG(0), GX_DEVICE_INFO *filter GX_DEFARG(0), 03372 int nproperties GX_DEFARG(0), const wchar_t **properties GX_DEFARG(0), 03373 int timeoutms GX_DEFARG(0)) { 03374 gxHANDLE nullhandle = { 0 }; 03375 struct GX_PARM_OPENDEVICE pr; 03376 int st; 03377 03378 assert(handle); 03379 pr.flags = flags; 03380 if(filter) memcpy(&pr.filter, filter, sizeof(pr.filter)); 03381 pr.properties = properties; 03382 pr.nproperties = nproperties; 03383 pr.timeoutms = timeoutms; 03384 st = gx_call(nullhandle, GX_CALL_OPENDEVICE, &pr); 03385 if(st) { 03386 *handle = pr.handle; 03387 if(info) memcpy(info, &pr.info, sizeof(GX_DEVICE_INFO)); 03388 } 03389 return st; 03390 } 03391 03392 /******************************************************************************/ 03401 inline int gx_getsysteminfo(GX_SYSTEM_INFO *info) { 03402 gxHANDLE nullhandle = { 0 }; 03403 assert(info); 03404 return gx_call(nullhandle, GX_CALL_GETSYSTEMINFO, info); 03405 } 03406 03407 /******************************************************************************/ 03409 /******************************************************************************/ 03410 03411 /******************************************************************************/ 03412 #endif /* GX_SWIGIF NO_GX_FUNCTIONS )*/ 03413 /******************************************************************************/ 03414 /******************************************************************************/ 03415 03416 #ifdef GX_DOTNET 03417 #pragma managed 03418 #endif 03419 03420 #if !defined(NO_GX_CLASSES) && !defined(ANDROID) /*(*/ 03421 03422 /******************************************************************************* 03423 * Classes 03424 ******************************************************************************/ 03425 03426 #if !defined(GX_EXT_MODULE) && !defined(__BORLANDC__) /*(*/ 03427 03428 #ifdef GX_UNICODE /*(*/ 03429 03430 /******************************************************************************/ 03432 #if !defined(GX_DOTNET) 03433 GX_CLASS gxDeviceInfo : private GX_DEVICE_INFO { 03434 #else 03435 GX_CLASS gxDeviceInfo 03436 #ifdef GX_DOTNET 03437 : public System::IDisposable 03438 #endif 03439 { /*}*/ 03440 private: 03441 gxString type; 03442 gxString devname; 03443 unsigned int serial; 03444 int priority; 03445 #endif 03446 public: 03448 inline gxDeviceInfo() { 03449 #if !defined(GX_DOTNET) 03450 memset(static_cast<GX_DEVICE_INFO *>(this), 0, sizeof(GX_DEVICE_INFO)); 03451 #else 03452 type = GX_NULLPTR; 03453 devname = GX_NULLPTR; 03454 serial = 0; 03455 priority = 0; 03456 #endif 03457 } 03458 03461 inline gxDeviceInfo(GX_CONST gxDeviceInfo GX_REF_CLASS(src)) { 03462 #if !defined(GX_DOTNET) 03463 memcpy(static_cast<GX_DEVICE_INFO *>(this), static_cast<const GX_DEVICE_INFO *>(&src), 03464 sizeof(GX_DEVICE_INFO)); 03465 #else 03466 SetType(src GX_M GetType()); 03467 SetName(src GX_M GetName()); 03468 SetSerial(src GX_M GetSerial()); 03469 SetPriority(src GX_M GetPriority()); 03470 #endif 03471 } 03472 03474 inline ~gxDeviceInfo() { 03475 _Dispose(); 03476 } 03477 03478 #ifdef GX_DOTNET_20 03479 inline !gxDeviceInfo() { 03480 _Dispose(); 03481 } 03482 #else 03483 03484 inline void Dispose(void) { 03485 #ifdef GX_DOTNET 03486 System::GC::SuppressFinalize(this);//do not call it from a destructor explicitly! 03487 #endif 03488 _Dispose(); 03490 } 03491 #endif 03492 03493 private: 03494 inline void _Dispose(void) { 03495 #if defined(GX_DOTNET) 03496 type = GX_NULLPTR; 03497 devname = GX_NULLPTR; 03498 #endif 03499 } 03500 public: 03501 03502 03503 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 03504 03505 inline operator GX_DEVICE_INFO *() { 03506 return static_cast<GX_DEVICE_INFO *>(this); 03507 } 03511 inline void SetType(const wchar_t *_type) { 03512 memset(type, 0, sizeof(type)); 03513 gx_wcsncpy(type, _type ? _type : L"", sizeof(type)/sizeof(wchar_t)); 03514 } 03518 inline void SetName(const wchar_t *_devname) { 03519 memset(devname, 0, sizeof(devname)); 03520 gx_wcsncpy(devname, _devname ? _devname : L"", sizeof(devname)/sizeof(wchar_t)); 03521 } 03522 #endif /*)*/ 03523 03526 inline void SetSerial(unsigned int _serial) { 03527 serial = _serial; 03528 } 03532 inline void SetPriority(int _priority) { 03533 priority = _priority; 03534 } 03535 03539 inline unsigned int GetSerial(void) GX_CONST { 03540 return serial; 03541 } 03545 inline int GetPriority(void) GX_CONST { 03546 return priority; 03547 } 03548 03552 inline void SetType(gxInStr _type) { 03553 #if !defined(GX_DOTNET) 03554 GX_GETSTRING(__type, _type); 03555 memset(type, 0, sizeof(type)); 03556 gx_wcsncpy(type, __type ? __type : L"", sizeof(type)/sizeof(wchar_t)); 03557 #else 03558 type = _type; 03559 #endif 03560 } 03561 03565 inline void SetName(gxInStr _devname) { 03566 #if !defined(GX_DOTNET) 03567 GX_GETSTRING(__devname, _devname); 03568 memset(devname, 0, sizeof(devname)); 03569 gx_wcsncpy(devname, __devname ? __devname : L"", sizeof(devname)/sizeof(wchar_t)); 03570 #else 03571 devname = _devname; 03572 #endif 03573 } 03574 03578 inline gxOutStr GetType(void) GX_CONST { 03579 #if !defined(GX_DOTNET) 03580 wchar_t buffer[1+(sizeof(type)/sizeof(wchar_t))]; 03581 memcpy(buffer, type, sizeof(type)); 03582 buffer[sizeof(type)/sizeof(wchar_t)] = 0; 03583 return GX_PUTSTRING(buffer); 03584 #else 03585 return type; 03586 #endif 03587 } 03588 03592 inline gxOutStr GetName(void) GX_CONST { 03593 #if !defined(GX_DOTNET) 03594 wchar_t buffer[1+(sizeof(devname)/sizeof(wchar_t))]; 03595 memcpy(buffer, devname, sizeof(devname)); 03596 buffer[sizeof(devname)/sizeof(wchar_t)] = 0; 03597 return GX_PUTSTRING(buffer); 03598 #else 03599 return devname; 03600 #endif 03601 } 03602 }; 03603 03604 #endif /* GX_UNICODE )*/ 03605 03606 /******************************************************************************/ 03607 03608 #ifdef GX_ASCII /*(*/ 03609 /******************************************************************************/ 03611 GX_CLASS gxDeviceInfoA : private GX_DEVICE_INFOA { 03612 public: 03614 inline gxDeviceInfoA() { 03615 memset(static_cast<GX_DEVICE_INFOA *>(this), 0, sizeof(GX_DEVICE_INFOA)); 03616 } 03617 03621 inline gxDeviceInfoA(GX_CONST gxDeviceInfoA GX_REF_CLASS(src)) { 03622 memcpy(static_cast<GX_DEVICE_INFOA *>(this), static_cast<const GX_DEVICE_INFOA *>(&src), 03623 sizeof(GX_DEVICE_INFOA)); 03624 } 03625 03626 #if !defined(GX_SWIGIF) 03627 03628 inline operator GX_DEVICE_INFOA *() { 03629 return static_cast<GX_DEVICE_INFOA *>(this); 03630 } 03634 inline void SetType(const char *_type) { 03635 memset(type, 0, sizeof(type)); 03636 gx_strncpy(type, _type ? _type : "", sizeof(type)); 03637 } 03641 inline void SetName(const char *_devname) { 03642 memset(devname, 0, sizeof(devname)); 03643 gx_strncpy(devname, _devname ? _devname : "", sizeof(devname)); 03644 } 03645 #endif /* GX_SWIGIF */ 03646 03650 inline void SetSerial(unsigned int _serial) { 03651 serial = _serial; 03652 } 03656 inline void SetPriority(int _priority) { 03657 priority = _priority; 03658 } 03659 03663 inline unsigned int GetSerial(void) GX_CONST { 03664 return serial; 03665 } 03668 inline int GetPriority(void) GX_CONST { 03669 return priority; 03670 } 03671 03675 inline void SetType(gxInAStr _type) { 03676 GX_GETASTRING(__type, _type); 03677 memset(type, 0, sizeof(type)); 03678 gx_strncpy(type, __type ? __type : "", sizeof(type)); 03679 } 03680 03684 inline void SetName(gxInAStr _devname) { 03685 GX_GETASTRING(__devname, _devname); 03686 memset(devname, 0, sizeof(devname)); 03687 gx_strncpy(devname, __devname ? __devname : "", sizeof(devname)); 03688 } 03689 03693 inline gxOutAStr GetType(void) GX_CONST { 03694 char buffer[1+sizeof(type)]; 03695 memcpy(buffer, type, sizeof(type)); 03696 buffer[sizeof(type)] = 0; 03697 return GX_PUTASTRING(buffer); 03698 } 03699 03703 inline gxOutAStr GetName(void) GX_CONST { 03704 char buffer[1+sizeof(devname)]; 03705 memcpy(buffer, devname, sizeof(devname)); 03706 buffer[sizeof(devname)] = 0; 03707 return GX_PUTASTRING(buffer); 03708 } 03709 }; 03710 #endif /* GX_ASCII )*/ 03711 03712 #endif /* GX_EXT_MODULE __BORLANDC__ )*/ 03713 /******************************************************************************/ 03714 03715 /******************************************************************************/ 03716 #ifdef GX_DOTNET /*(*/ 03717 03718 #ifndef GX_EXT_MODULE 03719 03720 GX_CLASS gxException : public System::ApplicationException { 03721 public: 03723 inline gxException(); 03724 }; 03725 #endif 03726 03728 typedef GX_INDIRECTION1(gx::gxException) gxError; 03729 03730 #else /*)(*/ 03731 03732 #ifndef GX_EXT_MODULE /*(*/ 03733 03738 class gxException { 03739 public: 03740 03744 inline int GetErrorCode(void) { 03745 return gx_geterrorcode(); 03746 } 03747 03748 #if !defined(GX_SWIGIF) /*(*/ 03749 03755 inline int GetError(int *code, wchar_t *string, int maxlen) { 03756 return gx_geterror(code, string, maxlen); 03757 } 03764 inline int GetError(int *code, char *string, int maxlen) { 03765 return gx_geterrora(code, string, maxlen); 03766 } 03767 #endif /*)*/ 03768 #ifdef GX_UNICODE 03769 03772 inline gxOutStr GetErrorString(void) { 03773 wchar_t errbuf[GX_MAXLEN_ERRVALUE+1]; 03774 gx_geterror(0, errbuf, GX_MAXLEN_ERRVALUE); 03775 errbuf[GX_MAXLEN_ERRVALUE] = 0; 03776 return GX_PUTSTRING(errbuf); 03777 } 03778 #endif 03779 #ifdef GX_ASCII 03780 03783 inline gxOutAStr GetErrorStringA(void) { 03784 char errbuf[GX_MAXLEN_ERRVALUE+1]; 03785 gx_geterrora(0, errbuf, GX_MAXLEN_ERRVALUE); 03786 errbuf[GX_MAXLEN_ERRVALUE] = 0; 03787 return GX_PUTASTRING(errbuf); 03788 } 03789 #endif 03790 }; 03791 #endif /*)*/ 03792 03794 typedef gxException gxError; 03795 #endif /*)*/ 03796 03797 #ifndef GX_EXT_MODULE /*(*/ 03798 /******************************************************************************/ 03800 GX_CLASS gxSystem { 03801 public: 03802 03803 /*************************************************************************** 03804 * Set error 03805 **************************************************************************/ 03806 03807 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 03808 03815 inline static bool SetErrorv(int flags, int code, const wchar_t *format, va_list args) { 03816 return gx_seterrorfv(flags, code, format, args) ? true : false; 03817 } 03824 inline static bool SetErrorv(int code, const wchar_t *format, va_list args) { 03825 return SetErrorv(GX_ERR_FLAG_CLEAR, code, format, args); 03826 } 03833 inline static bool AppendErrorv(int code, const wchar_t *format, va_list args) { 03834 return SetErrorv(GX_ERR_FLAG_APPEND, code, format, args); 03835 } 03842 inline static bool PrependErrorv(int code, const wchar_t *format, va_list args) { 03843 return SetErrorv(GX_ERR_FLAG_PREPEND, code, format, args); 03844 } 03845 03853 inline static bool SetError(int flags, int code, const wchar_t *format, ...) { 03854 va_list args; 03855 va_start(args, format); 03856 bool ret = SetErrorv(flags, code, format, args); 03857 va_end(args); 03858 return ret; 03859 } 03860 03868 inline static bool SetErrorv(int flags, int code, const char *format, va_list args) { 03869 return gx_seterrorafv(flags, code, format, args) ? true : false; 03870 } 03877 inline static bool SetErrorv(int code, const char *format, va_list args) { 03878 return SetErrorv(GX_ERR_FLAG_CLEAR, code, format, args); 03879 } 03886 inline static bool AppendErrorv(int code, const char *format, va_list args) { 03887 return SetErrorv(GX_ERR_FLAG_APPEND, code, format, args); 03888 } 03895 inline static bool PrependErrorv(int code, const char *format, va_list args) { 03896 return SetErrorv(GX_ERR_FLAG_PREPEND, code, format, args); 03897 } 03898 03906 inline static bool SetError(int flags, int code, const char *format, ...) { 03907 va_list args; 03908 va_start(args, format); 03909 bool ret = SetErrorv(flags, code, format, args); 03910 va_end(args); 03911 return ret; 03912 } 03913 #endif /*)*/ 03914 03915 #if !defined(GX_SWIG) && !defined(GX_DOTNET) /*(*/ 03916 03922 inline static bool SetError(int code, const wchar_t *format, ...) { 03923 va_list args; 03924 va_start(args, format); 03925 bool ret = SetErrorv(code, format, args); 03926 va_end(args); 03927 return ret; 03928 } 03935 inline static bool SetError(int code, const char *format, ...) { 03936 va_list args; 03937 va_start(args, format); 03938 bool ret = SetErrorv(code, format, args); 03939 va_end(args); 03940 return ret; 03941 } 03948 inline static bool AppendError(int code, const wchar_t *format, ...) { 03949 va_list args; 03950 va_start(args, format); 03951 bool ret = AppendErrorv(code, format, args); 03952 va_end(args); 03953 return ret; 03954 } 03961 inline static bool AppendError(int code, const char *format, ...) { 03962 va_list args; 03963 va_start(args, format); 03964 bool ret = AppendErrorv(code, format, args); 03965 va_end(args); 03966 return ret; 03967 } 03974 inline static bool PrependError(int code, const wchar_t *format, ...) { 03975 va_list args; 03976 va_start(args, format); 03977 bool ret = PrependErrorv(code, format, args); 03978 va_end(args); 03979 return ret; 03980 } 03987 inline static bool PrependError(int code, const char *format, ...) { 03988 va_list args; 03989 va_start(args, format); 03990 bool ret = PrependErrorv(code, format, args); 03991 va_end(args); 03992 return ret; 03993 } 03994 #endif /*)*/ 03995 03999 inline static bool ClearError(void) { 04000 return gx_clearerror() ? true : false; 04001 } 04002 04007 inline static bool SetError(int code) { 04008 return gx_seterrorf((int)GX_ENUM_PATH(GX_ERROR_FLAGS) GX_ERR_FLAG_CLEAR, code, L"")!=0; 04009 } 04014 inline static bool AppendError(int code) { 04015 return gx_seterrorf((int)GX_ENUM_PATH(GX_ERROR_FLAGS) GX_ERR_FLAG_APPEND, code, L"")!=0; 04016 } 04021 inline static bool PrependError(int code) { 04022 return gx_seterrorf((int)GX_ENUM_PATH(GX_ERROR_FLAGS) GX_ERR_FLAG_PREPEND, code, L"")!=0; 04023 } 04024 04025 #ifdef GX_UNICODE /*(*/ 04026 04033 inline static bool SetError(int flags, int code, gxInStr str) { 04034 GX_GETSTRING(_str, str); 04035 return gx_seterrorf(flags, code, L"%ls", _str) ? true : false; 04036 } 04043 inline static bool SetError(int code, gxInStr str) { 04044 GX_GETSTRING(_str, str); 04045 return gx_seterrorf((int)GX_ENUM_PATH(GX_ERROR_FLAGS) GX_ERR_FLAG_CLEAR, code, L"%ls", _str) ? true : false; 04046 } 04053 inline static bool AppendError(int code, gxInStr str) { 04054 GX_GETSTRING(_str, str); 04055 return gx_seterrorf((int)GX_ENUM_PATH(GX_ERROR_FLAGS) GX_ERR_FLAG_APPEND, code, L"%ls", _str) ? true : false; 04056 } 04063 inline static bool PrependError(int code, gxInStr str) { 04064 GX_GETSTRING(_str, str); 04065 return gx_seterrorf((int)GX_ENUM_PATH(GX_ERROR_FLAGS) GX_ERR_FLAG_PREPEND, code, L"%ls", _str) ? true : false; 04066 } 04067 #endif /*)*/ 04068 #ifdef GX_ASCII /*(*/ 04069 04076 inline static bool SetError(int flags, int code, gxInAStr str) { 04077 GX_GETASTRING(_str, str); 04078 return gx_seterrorf(flags, code, L"%hs", _str) ? true : false; 04079 } 04086 inline static bool SetError(int code, gxInAStr str) { 04087 GX_GETASTRING(_str, str); 04088 return gx_seterrorf(GX_ERR_FLAG_CLEAR, code, L"%hs", _str) ? true : false; 04089 } 04096 inline static bool AppendError(int code, gxInAStr str) { 04097 GX_GETASTRING(_str, str); 04098 return gx_seterrorf(GX_ERR_FLAG_APPEND, code, L"%hs", _str) ? true : false; 04099 } 04106 inline static bool PrependError(int code, gxInAStr str) { 04107 GX_GETASTRING(_str, str); 04108 return gx_seterrorf(GX_ERR_FLAG_PREPEND, code, L"%hs", _str) ? true : false; 04109 } 04110 #endif /*)*/ 04111 04112 /******************************************************************************* 04113 * Get error 04114 ******************************************************************************/ 04115 04119 inline static int GetErrorCode(void) { 04120 return gx_geterrorcode(); 04121 } 04122 04123 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 04124 04130 inline static int GetError(int *code, wchar_t *string, int maxlen) { 04131 return gx_geterror(code, string, maxlen); 04132 } 04139 inline static int GetError(int *code, char *string, int maxlen) { 04140 return gx_geterrora(code, string, maxlen); 04141 } 04142 #endif /*)*/ 04143 #ifdef GX_UNICODE 04144 04147 inline static gxOutStr GetErrorString(void) { 04148 wchar_t errbuf[GX_MAXLEN_ERRVALUE+1]; 04149 gx_geterror(0, errbuf, GX_MAXLEN_ERRVALUE); 04150 errbuf[GX_MAXLEN_ERRVALUE] = 0; 04151 #ifndef GX_DOTNET_20 04152 return GX_PUTSTRING(errbuf); 04153 #else 04154 return GX_PUTSTRING(GX_PUTPTR(errbuf)); 04155 #endif 04156 } 04157 #endif 04158 #ifdef GX_ASCII 04159 04162 inline static gxOutAStr GetErrorStringA(void) { 04163 char errbuf[GX_MAXLEN_ERRVALUE+1]; 04164 gx_geterrora(0, errbuf, GX_MAXLEN_ERRVALUE); 04165 errbuf[GX_MAXLEN_ERRVALUE] = 0; 04166 return GX_PUTASTRING(errbuf); 04167 } 04168 #endif 04169 04170 #if defined(GX_UNICODE) && !defined(GX_DOTNET) && !defined(GX_SWIG) && !defined(__BORLANDC__) /*(*/ 04171 04176 inline static std::vector<gxDeviceInfo> ListDevices(unsigned int flags, gxDeviceInfo GX_REF_CLASS(filter)) gxFuncThrowsError { 04177 const int maxarray = 100; 04178 std::vector<gxDeviceInfo> ret; 04179 GX_DEVICE_INFO *array = (GX_DEVICE_INFO *)malloc(sizeof(GX_DEVICE_INFO)*maxarray); 04180 if(!array) { 04181 SetError(GX_ENOMEM); 04182 gxthrow; 04183 } 04184 int ndevices = maxarray; 04185 int st = gx_listdevices(&ndevices, array, flags, filter); 04186 if(!st) { 04187 free(array); 04188 gxthrow; 04189 } 04190 if(ndevices) { 04191 gxtry { 04192 ret.resize(ndevices); 04193 for(int ix = 0; ix < ndevices; ix++) { 04194 ret[ix].SetType(array[ix].type); 04195 ret[ix].SetName(array[ix].devname); 04196 ret[ix].SetSerial(array[ix].serial); 04197 ret[ix].SetPriority(array[ix].priority); 04198 } 04199 } gxcatch(...) { 04200 free(array); 04201 __gxthrow; 04202 } 04203 } 04204 free(array); 04205 return ret; 04206 } 04207 #endif /* GX_UNICODE GX_DOTNET GX_SWIG __BORLANDC__ )*/ 04208 04209 #if defined(GX_ASCII) && !defined(GX_SWIG) && !defined(__BORLANDC__) /*(*/ 04210 04215 inline static std::vector<gxDeviceInfoA> ListDevicesA(unsigned int flags, gxDeviceInfoA GX_REF_CLASS(filter)) gxFuncThrowsError { 04216 const int maxarray = 100; 04217 std::vector<gxDeviceInfoA> ret; 04218 GX_DEVICE_INFOA *array = (GX_DEVICE_INFOA *)malloc(sizeof(GX_DEVICE_INFOA)*maxarray); 04219 if(!array) { 04220 SetError(GX_ENOMEM); 04221 gxthrow; 04222 } 04223 int ndevices = maxarray; 04224 int st = gx_listdevicesa(&ndevices, array, flags, filter); 04225 if(!st) { 04226 free(array); 04227 gxthrow; 04228 } 04229 if(ndevices) { 04230 gxtry { 04231 ret.resize(ndevices); 04232 for(int ix = 0; ix < ndevices; ix++) { 04233 ret[ix].SetType(array[ix].type); 04234 ret[ix].SetName(array[ix].devname); 04235 ret[ix].SetSerial(array[ix].serial); 04236 ret[ix].SetPriority(array[ix].priority); 04237 } 04238 } gxcatch(...) { 04239 free(array); 04240 __gxthrow; 04241 } 04242 } 04243 free(array); 04244 return ret; 04245 } 04246 #endif /* GX_ASCII GX_SWIG __BORLANDC__ ) */ 04247 04248 #if defined(GX_DOTNET) /*(*/ 04249 04254 inline static gxSysArray ListDevices(unsigned int flags, GX_INDIRECTION_GC(gxDeviceInfo, filter)) gxFuncThrowsError { 04255 const int maxarray = 100; 04256 gxSysArray ret = GX_NULLPTR; 04257 04258 GX_DEVICE_INFO *array = (GX_DEVICE_INFO *)malloc(sizeof(GX_DEVICE_INFO)*maxarray); 04259 if(!array) { 04260 SetError((int)GX_ENUM_PATH(GX_ERROR_CODES) GX_ENOMEM); 04261 gxthrow; 04262 } 04263 04264 int ndevices = maxarray; 04265 gx::GX_DEVICE_INFO _filter; 04266 if(filter) { 04267 System::IntPtr wname = System::Runtime::InteropServices::Marshal::StringToBSTR(filter->GetType()); 04268 if(wname.ToPointer()) { 04269 gx_wcsncpy(_filter.type, (const wchar_t *)wname.ToPointer(), sizeof(_filter.type)/sizeof(wchar_t)); 04270 } 04271 System::Runtime::InteropServices::Marshal::FreeBSTR(wname); 04272 wname = System::Runtime::InteropServices::Marshal::StringToBSTR(filter->GetName()); 04273 if(wname.ToPointer()) { 04274 gx_wcsncpy(_filter.devname, (const wchar_t *)wname.ToPointer(), sizeof(_filter.devname)/sizeof(wchar_t)); 04275 } 04276 System::Runtime::InteropServices::Marshal::FreeBSTR(wname); 04277 } 04278 04279 int st = gx_listdevices(&ndevices, array, flags, &_filter); 04280 if(!st) { 04281 free(array); 04282 gxthrow; 04283 } 04284 04285 ret = System::Array::CreateInstance(GX_TYPEID(gxDeviceInfo), ndevices); 04286 if(ndevices) { 04287 gxtry { 04288 for(int ix = 0; ix < ndevices; ix++) { 04289 GX_INDIRECTION_GC(gxDeviceInfo, d) = gxnew gxDeviceInfo; 04290 d->SetType(GX_MARSHALPTRTOSTRING2(array[ix].type, sizeof(array[ix].type)/sizeof(wchar_t))); 04291 d->SetName(GX_MARSHALPTRTOSTRING2(array[ix].devname, sizeof(array[ix].devname)/sizeof(wchar_t))); 04292 d->SetSerial(array[ix].serial); 04293 d->SetPriority(array[ix].priority); 04294 ret->SetValue(d, ix); 04295 } 04296 } gxcatch(...) { 04297 __gxthrow; 04298 } 04299 } 04300 free(array); 04301 return ret; 04302 } 04303 #endif /*)*/ 04304 04308 inline static bool PushError(void) gxFuncThrowsError { 04309 bool ret = gx_pusherror() ? true : false; 04310 gxcondthrow(!ret); 04311 return ret; 04312 } 04313 04317 inline static bool PopError(void) gxFuncThrowsError { 04318 bool ret = gx_poperror() ? true : false; 04319 gxcondthrow(!ret); 04320 return ret; 04321 } 04325 inline static int GetSystemInfo(GX_SYSINFO_FLAGS flag) gxFuncThrowsError { 04326 GX_SYSTEM_INFO info; 04327 int ret = 0; 04328 memset(&info,0,sizeof(info)); 04329 info.size = sizeof(info); 04330 if (gx_getsysteminfo(&info)) { 04331 switch (flag) { 04332 case GX_ENUM_PATH(GX_SYSINFO_FLAGS) GX_SYSINFO_FLAG_FREEFLOW: ret = info.cm_ff; break; 04333 case GX_ENUM_PATH(GX_SYSINFO_FLAGS) GX_SYSINFO_FLAG_PARKING: ret = info.cm_park; break; 04334 case GX_ENUM_PATH(GX_SYSINFO_FLAGS) GX_SYSINFO_FLAG_ACCR: ret = info.cm_accr ; break; 04335 case GX_ENUM_PATH(GX_SYSINFO_FLAGS) GX_SYSINFO_FLAG_PARKINGLANE: ret = info.cm_pl; break; 04336 case GX_ENUM_PATH(GX_SYSINFO_FLAGS) GX_SYSINFO_FLAG_FACE: ret = info.cm_face; break; 04337 case GX_ENUM_PATH(GX_SYSINFO_FLAGS) GX_SYSINFO_FLAG_PR: ret = info.pr; break; 04338 } 04339 } else { 04340 gxcondthrow(!ret); 04341 } 04342 return ret; 04343 } 04344 }; 04345 #endif /*)*/ 04346 /******************************************************************************/ 04347 04348 #if defined(GX_DOTNET) && !defined(GX_EXT_MODULE) 04349 04350 inline gxException::gxException() : System::ApplicationException(gx::gxSystem::GetErrorString()) { 04351 } 04352 #endif 04353 04354 /******************************************************************************/ 04355 04356 #ifndef GX_EXT_MODULE /*(*/ 04357 /******************************************************************************/ 04358 #if !defined(GX_SWIG) && !defined(GX_DOTNET) /*(*/ 04359 04360 class gxPtr { 04361 private: 04362 void *ptr; 04364 public: 04366 inline gxPtr() { 04367 ptr = (void *)0; 04368 } 04369 04373 inline gxPtr(int size) { 04374 ptr = (void *)0; 04375 bool st; 04376 st = Alloc(size); 04377 gxassert(st); 04378 } 04379 04381 inline ~gxPtr() { 04382 _Dispose(); 04383 } 04384 04385 private: 04386 inline void _Dispose(void) { 04387 if(ptr) Free(); 04388 } 04389 public: 04395 inline bool Realloc(int size) gxFuncThrowsError { 04396 gxassert(size >= 0); 04397 GX_PARM_GLOBALREALLOC gr; 04398 gr.buffer = ptr; 04399 gr.size = size; 04400 gxHANDLE nullhandle = { 0 }; 04401 int st = gx_call(nullhandle, GX_CALL_GLOBALREALLOC, &gr); 04402 if(!st) { 04403 gxthrow; 04404 return false; 04405 } 04406 ptr = gr.buffer; 04407 return true; 04408 } 04409 04414 inline bool Alloc(int size) gxFuncThrowsError { 04415 gxassert(size > 0); 04416 return Realloc(size); 04417 } 04418 04419 04423 inline bool Free(void) gxFuncThrowsError { 04424 return Realloc(0); 04425 } 04426 04430 inline int Size(void) const gxFuncThrowsError { 04431 GX_PARM_GLOBALSIZE gs; 04432 gs.buffer = ptr; 04433 gxHANDLE nullhandle = { 0 }; 04434 int st = gx_call(nullhandle, GX_CALL_GLOBALSIZE, &gs); 04435 if(!st) { 04436 gxthrow; 04437 return -1; 04438 } 04439 return gs.size; 04440 } 04441 04445 inline void *Ptr(void) const { 04446 return ptr; 04447 } 04448 04452 inline operator void *() const { 04453 return ptr; 04454 } 04455 04459 inline operator const void *() const { 04460 return ptr; 04461 } 04462 }; 04463 #endif /* GX_SWIG && GX_DOTNET )*/ 04464 #endif /* GX_EXT_MODULE )*/ 04465 /******************************************************************************/ 04466 04467 /******************************************************************************* 04468 * Module handling 04469 ******************************************************************************/ 04470 #if !defined(GX_MANUAL) 04471 #if !defined(GX_DOTNET) 04472 #define GX_GETHANDLE(name) gxHANDLE name = *this 04473 #else 04474 #define GX_GETHANDLE(name) gxHANDLE name = { _handle } 04475 #endif 04476 #endif 04477 04478 #ifndef GX_EXT_MODULE /*(*/ 04479 04485 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 04486 class gxHandle : public gxHANDLE { 04487 public: 04493 inline gxHandle(int call_group) { 04494 handle = ((unsigned int)call_group >> 16); 04495 } 04502 inline gxHandle(gxHANDLE GX_REF_CLASS(src)) gxFuncThrowsError { 04503 handle = src.handle; 04504 if(IsValid()) { 04505 if(!gx_refhandle(*this)) { 04506 handle = 0; 04507 gxthrow; 04508 } 04509 } 04510 } 04517 inline gxHandle(gxHandle GX_REF_CLASS(src)) gxFuncThrowsError { 04518 handle = src.handle; 04519 if(IsValid()) { 04520 if(!gx_refhandle(*this)) { 04521 handle = 0; 04522 gxthrow; 04523 } 04524 } 04525 } 04526 04527 #else /* GX_SWIGIF GX_DOTNET )(*/ 04528 04529 GX_CLASS gxHandle 04530 #ifdef GX_DOTNET 04531 : public System::IDisposable 04532 #endif 04533 { 04534 04535 #if !defined(GX_SWIGIF) /*(*/ 04536 04537 #if defined(GX_DOTNET) 04538 #if !defined(GX_MANUAL) 04539 protected: 04540 #ifndef GX_DOTNET_20 04541 __value gxu32 _handle; 04542 #else 04543 gxu32 _handle; 04544 #endif 04545 #endif 04546 04547 public: 04553 inline gxu32 _get_handle(void) GX_CONST { 04554 return _handle; 04555 } 04561 inline void _set_handle(gxu32 ptr) GX_CONST { 04562 _handle = ptr; 04563 } 04564 #endif 04565 04566 #endif /*)*/ 04567 04568 #endif /* GX_SWIGIF GX_DOTNET )*/ 04569 04570 public: 04574 inline gxHandle() { 04575 #ifndef GX_DOTNET 04576 handle = 0; 04577 #else 04578 _handle = 0; 04579 #endif 04580 } 04585 inline ~gxHandle() { 04586 _Dispose(); 04587 } 04588 04589 #ifdef GX_DOTNET_20 04590 inline !gxHandle() { 04591 _Dispose(); 04592 } 04593 #else 04594 04595 inline void Dispose(void) { 04596 #ifdef GX_DOTNET 04597 System::GC::SuppressFinalize(this); 04598 #endif 04599 _Dispose(); 04601 } 04602 #endif 04603 04604 private: 04605 inline void _Dispose(void) { 04606 Close(); 04607 } 04608 public: 04609 04610 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 04611 04616 inline bool Open(const wchar_t *modulename, const wchar_t *groupname = (const wchar_t *)0) gxFuncThrowsError { 04617 gxassert(modulename); 04618 gxassert(!handle); 04619 bool st = gx_openmodule(this, modulename, groupname) ? true : false; 04620 gxcondthrow(!st); 04621 return st; 04622 } 04628 inline bool Open(const char *modulename, const char *groupname = (const char *)0) gxFuncThrowsError { 04629 gxassert(modulename); 04630 gxassert(!handle); 04631 bool st = gx_openmodule(this, modulename, groupname) ? true : false; 04632 gxcondthrow(!st); 04633 return st; 04634 } 04635 #endif /* GX_SWIGIF GX_DOTNET )*/ 04636 04637 #ifdef GX_UNICODE /*(*/ 04638 04643 inline bool Open(gxInStr modulename, gxInStr groupname) gxFuncThrowsError { 04644 GX_GETSTRING(_modulename, modulename); 04645 GX_GETSTRING(_groupname, groupname); 04646 #ifndef GX_DOTNET 04647 bool st = gx_openmodule(this, _modulename, _groupname) ? true : false; 04648 #else 04649 GX_GETHANDLE(h); 04650 bool st = gx_openmodule(&h, _modulename, _groupname) ? true : false; 04651 if(st) _set_handle(h.handle); 04652 #endif 04653 gxcondthrow(!st); 04654 return st; 04655 } 04660 inline bool Open(gxInStr modulename) gxFuncThrowsError { 04661 GX_GETSTRING(_modulename, modulename); 04662 #ifndef GX_DOTNET 04663 bool st = gx_openmodule(this, _modulename, L"default")!=0; 04664 #else 04665 GX_GETHANDLE(h); 04666 bool st = gx_openmodule(&h, _modulename, L"default")!=0; 04667 if(st) _set_handle(h.handle); 04668 #endif 04669 gxcondthrow(!st); 04670 return st; 04671 } 04672 #endif /* GX_UNICODE )*/ 04673 04674 #ifdef GX_ASCII /*(*/ 04675 04680 inline bool Open(gxInAStr modulename, gxInAStr groupname) gxFuncThrowsError { 04681 GX_GETASTRING(_modulename, modulename); 04682 GX_GETASTRING(_groupname, groupname); 04683 bool st = gx_openmodulea(this, _modulename, _groupname)!=0; 04684 gxcondthrow(!st); 04685 return st; 04686 } 04691 inline bool Open(gxInAStr modulename) gxFuncThrowsError { 04692 GX_GETASTRING(_modulename, modulename); 04693 bool st = gx_openmodulea(this, _modulename, "default")!=0; 04694 gxcondthrow(!st); 04695 return st; 04696 } 04697 #endif /* GX_ASCII )*/ 04698 04705 inline bool Close(void) gxFuncThrowsError { 04706 bool st = IsValid(); 04707 if(st) { 04708 #ifndef GX_DOTNET 04709 st = gx_unrefhandle(this) ? true : false; 04710 if(st) handle = 0; 04711 #else 04712 gxHANDLE h = { _handle }; 04713 st = gx_unrefhandle(&h) ? true : false; 04714 if(st) _handle = 0; 04715 #endif 04716 gxcondthrow(!st); 04717 } 04718 return true; 04719 } 04720 04724 inline bool IsValid(void) GX_CONST { 04725 if(!this) return false; 04726 #ifndef GX_DOTNET 04727 return handle ? true : false; 04728 #else 04729 return _handle ? true : false; 04730 #endif 04731 } 04732 04733 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 04734 04739 inline bool GetInfo(const gxMODULEINFO **moduleinfo) gxFuncThrowsError { 04740 gxassert(moduleinfo); 04741 bool st = gx_getmoduleinfo(*this, moduleinfo) ? true : false; 04742 gxcondthrow(!st); 04743 return st; 04744 } 04745 04756 inline bool Call(int callcode, void *params) { 04757 return gx_call(*this, callcode, params) ? true : false; 04758 } 04759 04764 inline gxHandle &operator = (gxHANDLE GX_REF_STRUCT(src)) gxFuncThrowsError { 04765 int st = true; 04766 if(src.handle) { 04767 gxHANDLE nullhandle = { 0 }; 04768 int st = gx_call(nullhandle, GX_CALL_REFHANDLE, &src); 04769 if(!st) gxthrow; 04770 } 04771 if(st) { 04772 Close(); 04773 handle = src.handle; 04774 } 04775 return *this; 04776 } 04781 inline gxHandle &operator = (gxHandle GX_REF_CLASS(src)) { 04782 int st = true; 04783 if(src.handle) { 04784 gxHANDLE nullhandle = { 0 }; 04785 int st = gx_call(nullhandle, GX_CALL_REFHANDLE, &src); 04786 if(!st) gxthrow; 04787 } 04788 if(st) { 04789 Close(); 04790 handle = src.handle; 04791 } 04792 return *this; 04793 } 04794 04801 inline bool GetProperty(const wchar_t *name, wchar_t *string, int maxlen) gxFuncThrowsError { 04802 bool st = gx_getmoduleproperty(*this, name, string, maxlen) ? true : false; 04803 gxcondthrow(!st); 04804 return st; 04805 } 04806 04807 #if !defined(GX_SWIG) && !defined(NO_GX_STL) 04808 04812 inline std::wstring GetProperty(const wchar_t *name) gxFuncThrowsError { 04813 wchar_t buf[GX_MAXLEN_PROPVALUE+1]; 04814 if(!gx_getmoduleproperty(*this, name, buf, GX_MAXLEN_PROPVALUE)) { 04815 gxthrow; 04816 buf[0] = 0; 04817 } 04818 buf[GX_MAXLEN_PROPVALUE] = 0; 04819 return std::wstring(buf); 04820 } 04821 #endif 04822 04829 inline bool GetProperty(const char *name, char *string, int maxlen) gxFuncThrowsError { 04830 bool st = gx_getmoduleproperty(*this, name, string, maxlen) ? true : false; 04831 gxcondthrow(!st); 04832 return st; 04833 } 04834 04835 #if !defined(GX_SWIG) && !defined(NO_GX_STL) 04836 04840 inline std::string GetProperty(const char *name) gxFuncThrowsError { 04841 char buf[GX_MAXLEN_PROPVALUE+1]; 04842 if(!gx_getmoduleproperty(*this, name, buf, GX_MAXLEN_PROPVALUE)) { 04843 gxthrow; 04844 buf[0] = 0; 04845 } 04846 buf[GX_MAXLEN_PROPVALUE] = 0; 04847 return std::string(buf); 04848 } 04849 #endif 04850 #endif /* GX_SWIGIF GX_DOTNET )*/ 04851 04852 #ifdef GX_DOTNET 04853 04863 inline int Call(int callcode, System::IntPtr params) { 04864 gxHANDLE h = { _handle }; 04865 return gx_call(h, callcode, params.ToPointer()); 04866 } 04867 #endif /* GX_DOTNET )*/ 04868 04869 #ifdef GX_UNICODE /*(*/ 04870 04874 inline gxOutStr GetProperty(gxInStr name) gxFuncThrowsError { 04875 wchar_t buf[GX_MAXLEN_PROPVALUE+1]; 04876 GX_GETSTRING(_name, name); 04877 #ifndef GX_DOTNET 04878 int st = gx_getmoduleproperty(*this, _name, buf, GX_MAXLEN_PROPVALUE); 04879 #else 04880 gxHANDLE h = { _handle }; 04881 int st = gx_getmoduleproperty(h, _name, buf, GX_MAXLEN_PROPVALUE); 04882 #endif 04883 if(!st) return GX_PUTSTRING_NONE; 04884 buf[GX_MAXLEN_PROPVALUE] = 0; 04885 return GX_PUTSTRING(buf); 04886 } 04887 #endif /* GX_UNICODE )*/ 04888 04889 #ifdef GX_ASCII 04890 04894 inline gxOutAStr GetProperty(gxInAStr name) gxFuncThrowsError { 04895 char buf[GX_MAXLEN_PROPVALUE+1]; 04896 GX_GETASTRING(_name, name); 04897 int st = gx_getmodulepropertya(*this, _name, buf, GX_MAXLEN_PROPVALUE); 04898 if(!st) return GX_PUTASTRING_NONE; 04899 buf[GX_MAXLEN_PROPVALUE] = 0; 04900 return GX_PUTASTRING(buf); 04901 } 04902 #endif /* GX_ASCII */ 04903 04904 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 04905 04910 inline bool GetProperty(const wchar_t *name, int *ivalue) gxFuncThrowsError { 04911 bool st = gx_getmodulepropertyint(*this, name, ivalue) ? true : false; 04912 gxcondthrow(!st); 04913 return st; 04914 } 04915 04920 inline int GetPropertyInt(const wchar_t *name) gxFuncThrowsError { 04921 int ret = -1; 04922 if(!gx_getmodulepropertyint(*this, name, &ret)) gxthrow; 04923 return ret; 04924 } 04925 #endif /* GX_SWIGIF GX_DOTNET )*/ 04926 04927 #ifdef GX_UNICODE /*(*/ 04928 04932 inline int GetPropertyInt(gxInStr name) gxFuncThrowsError { 04933 int ret = -1; 04934 GX_GETSTRING(_name, name); 04935 #ifndef GX_DOTNET 04936 if(!gx_getmodulepropertyint(*this, _name, &ret)) gxthrow; 04937 #else 04938 gxHANDLE h = { _handle }; 04939 if(!gx_getmodulepropertyint(h, _name, &ret)) gxthrow; 04940 #endif 04941 return ret; 04942 } 04943 #endif /* GX_UNICODE )*/ 04944 04945 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 04946 04951 inline bool GetProperty(const char *name, int *ivalue) gxFuncThrowsError { 04952 bool st = gx_getmodulepropertyinta(*this, name, ivalue) ? true : false; 04953 gxcondthrow(!st); 04954 return st; 04955 } 04960 inline int GetPropertyInt(const char *name) gxFuncThrowsError { 04961 int ret = -1; 04962 if(!gx_getmodulepropertyinta(*this, name, &ret)) gxthrow; 04963 return ret; 04964 } 04965 #endif /* GX_SWIGIF GX_DOTNET )*/ 04966 04967 #ifdef GX_ASCII 04968 04972 inline int GetPropertyInt(gxInAStr name) gxFuncThrowsError { 04973 int ret = -1; 04974 GX_GETASTRING(_name, name); 04975 if(!gx_getmodulepropertyinta(*this, _name, &ret)) gxthrow; 04976 return ret; 04977 } 04978 #endif 04979 04980 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 04981 04986 inline bool GetProperty(const wchar_t *name, double *fvalue) gxFuncThrowsError { 04987 bool st = gx_getmodulepropertyfloat(*this, name, fvalue)!=0; 04988 gxcondthrow(!st); 04989 return st; 04990 } 04995 inline double GetPropertyFloat(const wchar_t *name) gxFuncThrowsError { 04996 double ret = -1; 04997 if(!gx_getmodulepropertyfloat(*this, name, &ret)) gxthrow; 04998 return ret; 04999 } 05000 #endif /* GX_SWIGIF GX_DOTNET )*/ 05001 05002 #ifdef GX_UNICODE /*(*/ 05003 05007 inline double GetPropertyFloat(gxInStr name) gxFuncThrowsError { 05008 double ret = -1; 05009 GX_GETSTRING(_name, name); 05010 #ifndef GX_DOTNET 05011 if(!gx_getmodulepropertyfloat(*this, _name, &ret)) gxthrow; 05012 #else 05013 gxHANDLE h = { _handle }; 05014 if(!gx_getmodulepropertyfloat(h, _name, &ret)) gxthrow; 05015 #endif 05016 return ret; 05017 } 05018 #endif /*)*/ 05019 05020 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 05021 05026 inline bool GetProperty(const char *name, double *fvalue) gxFuncThrowsError { 05027 bool st = gx_getmodulepropertyfloata(*this, name, fvalue) ? true : false; 05028 gxcondthrow(!st); 05029 return st; 05030 } 05035 inline double GetPropertyFloat(const char *name) gxFuncThrowsError { 05036 double ret = -1; 05037 if(!gx_getmodulepropertyfloata(*this, name, &ret)) gxthrow; 05038 return ret; 05039 } 05040 #endif /* GX_SWIGIF GX_DOTNET )*/ 05041 05042 #ifdef GX_ASCII 05043 05047 inline double GetPropertyFloat(gxInAStr name) gxFuncThrowsError { 05048 double ret = -1; 05049 GX_GETASTRING(_name, name); 05050 if(!gx_getmodulepropertyfloata(*this, _name, &ret)) gxthrow; 05051 return ret; 05052 } 05053 #endif 05054 05055 05056 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 05057 05062 inline bool GetPropertyVersion(const wchar_t *name, unsigned int *version) gxFuncThrowsError { 05063 bool st = gx_getmodulepropertyversion(*this, name, version)!=0; 05064 gxcondthrow(!st); 05065 return st; 05066 } 05067 05072 inline unsigned int GetPropertyVersion(const wchar_t *name) gxFuncThrowsError { 05073 unsigned int ret = 0; 05074 if(!gx_getmodulepropertyversion(*this, name, &ret)) gxthrow; 05075 return ret; 05076 } 05077 #endif /* GX_SWIGIF GX_DOTNET )*/ 05078 05079 #ifdef GX_UNICODE /*(*/ 05080 05084 inline unsigned int GetPropertyVersion(gxInStr name) gxFuncThrowsError { 05085 unsigned int ret = 0; 05086 GX_GETSTRING(_name, name); 05087 #ifndef GX_DOTNET 05088 if(!gx_getmodulepropertyversion(*this, _name, &ret)) gxthrow; 05089 #else 05090 gxHANDLE h = { _handle }; 05091 if(!gx_getmodulepropertyversion(h, _name, &ret)) gxthrow; 05092 #endif 05093 return ret; 05094 } 05095 #endif /*)*/ 05096 05097 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 05098 05103 inline bool GetPropertyVersion(const char *name, unsigned int *version) gxFuncThrowsError { 05104 bool st = gx_getmodulepropertyversiona(*this, name, version) ? true : false; 05105 gxcondthrow(!st); 05106 return st; 05107 } 05108 05113 inline unsigned int GetPropertyVersion(const char *name) gxFuncThrowsError { 05114 unsigned int ret = 0; 05115 if(!gx_getmodulepropertyversiona(*this, name, &ret)) gxthrow; 05116 return ret; 05117 } 05118 #endif /* GX_SWIGIF GX_DOTNET )*/ 05119 05120 #ifdef GX_ASCII 05121 05125 inline unsigned int GetPropertyVersion(gxInAStr name) gxFuncThrowsError { 05126 unsigned int ret = 0; 05127 GX_GETASTRING(_name, name); 05128 if(!gx_getmodulepropertyversiona(*this, _name, &ret)) gxthrow; 05129 return ret; 05130 } 05131 #endif 05132 05133 05134 /**************************************************************************/ 05135 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 05136 05141 inline bool SetProperty(const wchar_t *name, const wchar_t *string) gxFuncThrowsError { 05142 bool st = gx_setmoduleproperty(*this, name, string) ? true : false; 05143 gxcondthrow(!st); 05144 return st; 05145 } 05146 05152 inline bool SetProperty(const char *name, const char *string) gxFuncThrowsError { 05153 bool st = gx_setmodulepropertya(*this, name, string) ? true : false; 05154 gxcondthrow(!st); 05155 return st; 05156 } 05157 #endif /* GX_SWIGIF GX_DOTNET )*/ 05158 05159 #ifdef GX_UNICODE /*(*/ 05160 05165 inline bool SetProperty(gxInStr name, gxInStr str) gxFuncThrowsError { 05166 GX_GETSTRING(_name, name); 05167 GX_GETSTRING(_str, str); 05168 #ifndef GX_DOTNET 05169 bool st = gx_setmoduleproperty(*this, _name, _str) ? true : false; 05170 #else 05171 gxHANDLE h = { _handle }; 05172 bool st = gx_setmoduleproperty(h, _name, _str) ? true : false; 05173 #endif 05174 gxcondthrow(!st); 05175 return st; 05176 } 05177 #endif /* GX_UNICODE )*/ 05178 05179 #ifdef GX_ASCII 05180 05185 inline bool SetProperty(gxInAStr name, gxInAStr str) gxFuncThrowsError { 05186 GX_GETASTRING(_name, name); 05187 GX_GETASTRING(_str, str); 05188 bool st = gx_setmodulepropertya(*this, _name, _str) ? true : false; 05189 gxcondthrow(!st); 05190 return st; 05191 } 05192 #endif /* GX_ASCII */ 05193 05194 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 05195 05200 inline bool SetProperty(const wchar_t *name, int ivalue) gxFuncThrowsError { 05201 bool st = gx_setmodulepropertyint(*this, name, ivalue) ? true : false; 05202 gxcondthrow(!st); 05203 return st; 05204 } 05205 05211 inline bool SetProperty(const char *name, int ivalue) gxFuncThrowsError { 05212 bool st = gx_setmodulepropertyinta(*this, name, ivalue) ? true : false; 05213 gxcondthrow(!st); 05214 return st; 05215 } 05216 #endif /* GX_SWIGIF GX_DOTNET )*/ 05217 05218 #ifdef GX_UNICODE /*(*/ 05219 05224 inline bool SetProperty(gxInStr name, int ivalue) gxFuncThrowsError { 05225 GX_GETSTRING(_name, name); 05226 #ifndef GX_DOTNET 05227 bool st = gx_setmodulepropertyint(*this, _name, ivalue) ? true : false; 05228 #else 05229 gxHANDLE h = { _handle }; 05230 bool st = gx_setmodulepropertyint(h, _name, ivalue) ? true : false; 05231 #endif 05232 gxcondthrow(!st); 05233 return st; 05234 } 05235 #endif /*)*/ 05236 #ifdef GX_ASCII 05237 05242 inline bool SetProperty(gxInAStr name, int ivalue) gxFuncThrowsError { 05243 GX_GETASTRING(_name, name); 05244 bool st = gx_setmodulepropertyinta(*this, _name, ivalue) ? true : false; 05245 gxcondthrow(!st); 05246 return st; 05247 } 05248 #endif 05249 05250 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 05251 05256 inline bool SetProperty(const wchar_t *name, double fvalue) gxFuncThrowsError { 05257 bool st = gx_setmodulepropertyfloat(*this, name, fvalue) ? true : false; 05258 gxcondthrow(!st); 05259 return st; 05260 } 05261 05267 inline bool SetProperty(const char *name, double fvalue) gxFuncThrowsError { 05268 bool st = gx_setmodulepropertyfloata(*this, name, fvalue) ? true : false; 05269 gxcondthrow(!st); 05270 return st; 05271 } 05272 #endif /* GX_SWIGIF GX_DOTNET )*/ 05273 05274 #ifdef GX_UNICODE /*(*/ 05275 05280 inline bool SetProperty(gxInStr name, double fvalue) gxFuncThrowsError { 05281 GX_GETSTRING(_name, name); 05282 #ifndef GX_DOTNET 05283 bool st = gx_setmodulepropertyfloat(*this, _name, fvalue) ? true : false; 05284 #else 05285 gxHANDLE h = { _handle }; 05286 bool st = gx_setmodulepropertyfloat(h, _name, fvalue) ? true : false; 05287 #endif 05288 gxcondthrow(!st); 05289 return st; 05290 } 05291 #endif /* GX_UNICODE )*/ 05292 05293 #ifdef GX_ASCII 05294 05299 inline bool SetProperty(gxInAStr name, double fvalue) gxFuncThrowsError { 05300 GX_GETASTRING(_name, name); 05301 bool st = gx_setmodulepropertyfloata(*this, _name, fvalue) ? true : false; 05302 gxcondthrow(!st); 05303 return st; 05304 } 05305 #endif /* GX_ASCII */ 05306 05307 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 05308 05314 inline bool SaveProperties(const wchar_t *name, int level = 0) gxFuncThrowsError { 05315 bool st = gx_savemoduleproperties(*this, name, level) ? true : false; 05316 gxcondthrow(!st); 05317 return st; 05318 } 05319 05326 inline bool SaveProperties(const char *name, int level = 0) gxFuncThrowsError { 05327 bool st = gx_savemoduleproperties(*this, name, level) ? true : false; 05328 gxcondthrow(!st); 05329 return st; 05330 } 05331 #endif /* GX_SWIGIF GX_DOTNET )*/ 05332 05333 #ifdef GX_UNICODE /*(*/ 05334 05340 inline bool SaveProperties(gxInStr name, int level) gxFuncThrowsError { 05341 GX_GETSTRING(_name, name); 05342 #ifndef GX_DOTNET 05343 bool st = gx_savemoduleproperties(*this, _name, level) ? true : false; 05344 #else 05345 gxHANDLE h = { _handle }; 05346 bool st = gx_savemoduleproperties(h, _name, level) ? true : false; 05347 #endif 05348 gxcondthrow(!st); 05349 return st; 05350 } 05351 05357 inline bool SaveProperties(gxInStr name) gxFuncThrowsError { 05358 GX_GETSTRING(_name, name); 05359 #ifndef GX_DOTNET 05360 bool st = gx_savemoduleproperties(*this, _name, 0) ? true : false; 05361 #else 05362 gxHANDLE h = { _handle }; 05363 bool st = gx_savemoduleproperties(h, _name, 0) ? true : false; 05364 #endif 05365 gxcondthrow(!st); 05366 return st; 05367 } 05368 #endif /* GX_UNICODE )*/ 05369 05370 #ifdef GX_ASCII 05371 05377 inline bool SaveProperties(gxInAStr name, int level = 0) gxFuncThrowsError { 05378 GX_GETASTRING(_name, name); 05379 bool st = gx_savemodulepropertiesa(*this, _name, level) ? true : false; 05380 gxcondthrow(!st); 05381 return st; 05382 } 05383 #endif /* GX_ASCII */ 05384 05385 /******************************************************************************/ 05391 inline bool MPStartTransaction(void) { 05392 GX_GETHANDLE(h); 05393 bool st = gx_mpstarttransaction(h) ? true : false; 05394 gxcondthrow(!st); 05395 return st; 05396 } 05397 05398 /******************************************************************************/ 05402 inline bool MPCommit(void) { 05403 GX_GETHANDLE(h); 05404 bool st = gx_mpcommit(h) ? true : false; 05405 gxcondthrow(!st); 05406 return st; 05407 } 05408 05409 }; 05410 05411 #endif /* GX_EXT_MODULE )*/ 05412 /******************************************************************************/ 05413 #endif /* NO_GX_CLASSES !ANDROID)*/ 05414 /******************************************************************************/ 05415 #ifdef GX_NAMESPACES 05416 } /* namespace gx */ 05417 #endif 05418 #ifdef __BORLANDC__ 05419 #pragma warn .rch 05420 #endif 05421 #ifdef _MSC_VER 05422 #pragma warning(default: 4127) /* truncated debug info */ 05423 #endif 05424 /******************************************************************************/ 05425 #endif /*GXSD_INCL*/ 05426 /******************************************************************************/