00001 #ifndef PRAPI_INCL
00002 #define PRAPI_INCL
00003
00004
00005
00006
00007 #ifdef GX_DOTNET
00008 #using "gxdotnet7.dll"
00009 #endif
00010 #ifndef __cplusplus
00011 #define USE_COMPAT_VARIANT_1
00012 #endif
00013 #include "gxsd.h"
00014 #include "prtypes.h"
00015 #include "prerror.h"
00016 #include "prdoctypes.h"
00017 #include "gximage.h"
00018 #include "gxtrafo.h"
00019
00020 #if defined(WIN32) && !defined(GX_DOTNET)
00021 #include <windows.h>
00022 #endif
00023
00024 #ifdef _MSC_VER
00025 #pragma warning(push)
00026 #pragma warning(disable : 4786)
00027 #endif
00028 #ifdef __BORLANDC__
00029 #pragma warn -rch
00030 #endif
00031
00032 #ifdef GX_NAMESPACES
00033 namespace pr {
00034 #endif
00035
00120 #ifndef GX_MANUAL
00121
00122 #ifdef GX_DOTNET
00123 #pragma unmanaged
00124 #define _GX_ENOENT 2
00125 #define _PR_UMODE_DISCONNECT 0
00126 #define _PR_PROP_TYPE_CONFIDENCE 3
00127 #define _PR_PROP_TYPE_RFID_FILES 2
00128 #define _PR_PROP_TYPE_BARCODE_TYPE 1
00129 #define _PR_DF_RFID_FACE 0x420000
00130 #define _PRV_RFIDDIR 0xd0500001
00131 #define _PRV_BARCODE 0xd0300000
00132 #define _PRV_CONFIDENCE 0xd0000005
00133 #define _GX_VARIANT_INT 1
00134 #define gxPG4 _gxPG4
00135 #ifdef WIN32
00136 #define HWND void*
00137 #define UINT unsigned int
00138 #endif
00139 #define GXVT GX_VARIANT_TYPES::
00140 #define GXVF GX_VARIANT_FLAGS::
00141 #define GXEC GX_ERROR_CODES::
00142 #else
00143 #define _GX_ENOENT GX_ENOENT
00144 #define _PR_UMODE_DISCONNECT PR_UMODE_DISCONNECT
00145 #define _PR_PROP_TYPE_CONFIDENCE PR_PROP_TYPE_CONFIDENCE
00146 #define _PR_PROP_TYPE_RFID_FILES PR_PROP_TYPE_RFID_FILES
00147 #define _PR_PROP_TYPE_BARCODE_TYPE PR_PROP_TYPE_BARCODE_TYPE
00148 #define _PR_DF_RFID_FACE PR_DF_RFID_FACE
00149 #define _PRV_RFIDDIR PRV_RFIDDIR
00150 #define _PRV_BARCODE PRV_BARCODE
00151 #define _PRV_CONFIDENCE PRV_CONFIDENCE
00152 #define _GX_VARIANT_INT GX_VARIANT_INT
00153 #define GXVT
00154 #define GXVF
00155 #define GXEC
00156 #endif
00157 #endif
00158
00159 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL)
00160
00161 enum PR_MAXLEN_VALUES {
00162 MAX_LIGHTS = 8,
00163 };
00164
00165
00166
00167
00168
00169
00170 enum {
00171 PR_CALL_GROUP_PRAPI = 0x20080000,
00172 PR_CALL_PRAPI_GETDEVICELIST = PR_CALL_GROUP_PRAPI,
00173 PR_CALL_PRAPI_GETDEVICELISTA = PR_CALL_GROUP_PRAPI+1,
00174 PR_CALL_PRAPI_USEDEVICE = PR_CALL_GROUP_PRAPI+2,
00175 PR_CALL_PRAPI_USEDEVICEA = PR_CALL_GROUP_PRAPI+3,
00176 PR_CALL_PRAPI_GETCONTROLLERHANDLE = PR_CALL_GROUP_PRAPI+4,
00177 PR_CALL_PRAPI_CALIBRATE = PR_CALL_GROUP_PRAPI+60,
00178
00179
00180
00181 PR_CALL_PRAPI_ISCALIBRATED = PR_CALL_GROUP_PRAPI+61,
00182 PR_CALL_PRAPI_SETPAGELIGHT = PR_CALL_GROUP_PRAPI+62,
00183 PR_CALL_PRAPI_SETEVENTFUNCTION = PR_CALL_GROUP_PRAPI+11,
00184 PR_CALL_PRAPI_TEST_DOCUMENT = PR_CALL_GROUP_PRAPI+63,
00185 PR_CALL_PRAPI_CAPTURE = PR_CALL_GROUP_PRAPI+13,
00186 PR_CALL_PRAPI_CAPTURE_START = PR_CALL_GROUP_PRAPI+14,
00187 PR_CALL_PRAPI_CAPTURE_GETSTATUS = PR_CALL_GROUP_PRAPI+15,
00188 PR_CALL_PRAPI_CAPTURE_WAIT = PR_CALL_GROUP_PRAPI+16,
00189 PR_CALL_PRAPI_CAPTURE_PREVIEW = PR_CALL_GROUP_PRAPI+64,
00190 PR_CALL_PRAPI_SAVEIMAGE = PR_CALL_GROUP_PRAPI+19,
00191 PR_CALL_PRAPI_SAVEIMAGEA = PR_CALL_GROUP_PRAPI+20,
00192 PR_CALL_PRAPI_DRAWIMAGE = PR_CALL_GROUP_PRAPI+21,
00193 PR_CALL_PRAPI_RESETDOCUMENT = PR_CALL_GROUP_PRAPI+176,
00194 PR_CALL_PRAPI_GETLIGHTNUMBER = PR_CALL_GROUP_PRAPI+51,
00195 PR_CALL_PRAPI_GETRFIDCARDLIST = PR_CALL_GROUP_PRAPI+126,
00196 PR_CALL_PRAPI_GETRFIDCARDLISTA = PR_CALL_GROUP_PRAPI+127,
00197 PR_CALL_PRAPI_GETRFIDFILE = PR_CALL_GROUP_PRAPI+73,
00198 PR_CALL_PRAPI_GETRFIDFILEA = PR_CALL_GROUP_PRAPI+74,
00199 PR_CALL_PRAPI_GETLIGHTMASK = PR_CALL_GROUP_PRAPI+65,
00200 PR_CALL_PRAPI_GETWINDOWNUMBER = PR_CALL_GROUP_PRAPI+66,
00201 PR_CALL_PRAPI_GETLIGHTLIST = PR_CALL_GROUP_PRAPI+67,
00202 PR_CALL_PRAPI_SET_STATUS_LED = PR_CALL_GROUP_PRAPI+68,
00203 PR_CALL_PRAPI_TEST_POWER = PR_CALL_GROUP_PRAPI+69,
00204 PR_CALL_PRAPI_TEST_BUTTON = PR_CALL_GROUP_PRAPI+70,
00205 PR_CALL_PRAPI_MAKEBAC = PR_CALL_GROUP_PRAPI+75,
00206 PR_CALL_PRAPI_MAKEBACA = PR_CALL_GROUP_PRAPI+76,
00207 PR_CALL_PRAPI_MAKEPASSIVEAUTH = PR_CALL_GROUP_PRAPI+77,
00208 PR_CALL_PRAPI_MAKEPASSIVEAUTHA = PR_CALL_GROUP_PRAPI+78,
00209 PR_CALL_PRAPI_MAKEACTIVEAUTH = PR_CALL_GROUP_PRAPI+79,
00210 PR_CALL_PRAPI_MAKEACTIVEAUTHA = PR_CALL_GROUP_PRAPI+80,
00211 PR_CALL_PRAPI_BEGIN_WINDOW_MESSAGING = PR_CALL_GROUP_PRAPI+82,
00212 PR_CALL_PRAPI_END_WINDOW_MESSAGING = PR_CALL_GROUP_PRAPI+83,
00213 PR_CALL_PRAPI_GET_BUTTON_EVENT = PR_CALL_GROUP_PRAPI+84,
00214 PR_CALL_PRAPI_SUSPEND = PR_CALL_GROUP_PRAPI+85,
00215 PR_CALL_PRAPI_WAKEUP = PR_CALL_GROUP_PRAPI+86,
00216 PR_CALL_PRAPI_LOADCERTFILE = PR_CALL_GROUP_PRAPI+132,
00217 PR_CALL_PRAPI_LOADCERTFILEA = PR_CALL_GROUP_PRAPI+133,
00218 PR_CALL_PRAPI_GET_UDINFO = PR_CALL_GROUP_PRAPI+94,
00219 PR_CALL_PRAPI_READ_UD = PR_CALL_GROUP_PRAPI+95,
00220 PR_CALL_PRAPI_WRITE_UD = PR_CALL_GROUP_PRAPI+96,
00221 PR_CALL_PRAPI_GETOCR_V = PR_CALL_GROUP_PRAPI+97,
00222 PR_CALL_PRAPI_GETMRZ_V = PR_CALL_GROUP_PRAPI+98,
00223 PR_CALL_PRAPI_GETBARCODE_V = PR_CALL_GROUP_PRAPI+99,
00224 PR_CALL_PRAPI_GETDOCUMENTRECT_V = PR_CALL_GROUP_PRAPI+100,
00225 PR_CALL_PRAPI_RECOGNIZE_V = PR_CALL_GROUP_PRAPI+101,
00226 PR_CALL_PRAPI_RESOLVEMRZTEXT_V = PR_CALL_GROUP_PRAPI+102,
00227 PR_CALL_PRAPI_RESOLVEMRZTEXTA_V = PR_CALL_GROUP_PRAPI+103,
00228 PR_CALL_PRAPI_RESOLVERFIDDATA_V = PR_CALL_GROUP_PRAPI+104,
00229 PR_CALL_PRAPI_GETDOCUMENTSTATUS_V = PR_CALL_GROUP_PRAPI+105,
00230 PR_CALL_PRAPI_GETFIELDFROMDOC_V = PR_CALL_GROUP_PRAPI+106,
00231 PR_CALL_PRAPI_GETFIELDIMAGE_V = PR_CALL_GROUP_PRAPI+107,
00232 PR_CALL_PRAPI_COMPARE_FACE_V = PR_CALL_GROUP_PRAPI+108,
00233 PR_CALL_PRAPI_SAVEDOCUMENT_V = PR_CALL_GROUP_PRAPI+109,
00234 PR_CALL_PRAPI_SAVEDOCUMENTA_V = PR_CALL_GROUP_PRAPI+110,
00235 PR_CALL_PRAPI_LOADDOCUMENT_V = PR_CALL_GROUP_PRAPI+111,
00236 PR_CALL_PRAPI_LOADDOCUMENTA_V = PR_CALL_GROUP_PRAPI+112,
00237 PR_CALL_PRAPI_GETDOCUMENTROOT_V = PR_CALL_GROUP_PRAPI+113,
00238 PR_CALL_PRAPI_CONNECTRFIDCARD = PR_CALL_GROUP_PRAPI+118,
00239 PR_CALL_PRAPI_CONNECTRFIDCARDA = PR_CALL_GROUP_PRAPI+119,
00240 PR_CALL_PRAPI_DISCONNECTRFIDCARD = PR_CALL_GROUP_PRAPI+120,
00241 PR_CALL_PRAPI_DISCONNECTRFIDCARDA = PR_CALL_GROUP_PRAPI+121,
00242 PR_CALL_PRAPI_MAKECHIPAUTH = PR_CALL_GROUP_PRAPI+122,
00243 PR_CALL_PRAPI_MAKECHIPAUTHA = PR_CALL_GROUP_PRAPI+123,
00244 PR_CALL_PRAPI_MAKETERMINALAUTH = PR_CALL_GROUP_PRAPI+124,
00245 PR_CALL_PRAPI_MAKETERMINALAUTHA = PR_CALL_GROUP_PRAPI+125,
00246 PR_CALL_PRAPI_CHECKRFIDFILEHASH = PR_CALL_GROUP_PRAPI+128,
00247 PR_CALL_PRAPI_CHECKRFIDFILEHASHA = PR_CALL_GROUP_PRAPI+129,
00248 PR_CALL_PRAPI_GETIMAGE_V = PR_CALL_GROUP_PRAPI+130,
00249 PR_CALL_PRAPI_GETDEVICEINFO = PR_CALL_GROUP_PRAPI+131,
00250 PR_CALL_PRAPI_GETRFIDCARDINFO = PR_CALL_GROUP_PRAPI+134,
00251 PR_CALL_PRAPI_GETRFIDCARDINFOA = PR_CALL_GROUP_PRAPI+135,
00252 PR_CALL_PRAPI_FINGERSTONIST = PR_CALL_GROUP_PRAPI+139,
00253 PR_CALL_PRAPI_FINGERSTONISTA = PR_CALL_GROUP_PRAPI+140,
00254 PR_CALL_PRAPI_FINGERSTONISTMEM = PR_CALL_GROUP_PRAPI+141,
00255 PR_CALL_PRAPI_INITTERMINALAUTH = PR_CALL_GROUP_PRAPI+142,
00256 PR_CALL_PRAPI_INITTERMINALAUTHA = PR_CALL_GROUP_PRAPI+143,
00257 PR_CALL_PRAPI_COMPLETETERMINALAUTH = PR_CALL_GROUP_PRAPI+144,
00258 PR_CALL_PRAPI_COMPLETETERMINALAUTHA = PR_CALL_GROUP_PRAPI+145,
00259 PR_CALL_PRAPI_CLEARCERTLIST = PR_CALL_GROUP_PRAPI+146,
00260 PR_CALL_PRAPI_BLINK_STATUS = PR_CALL_GROUP_PRAPI+151,
00261 PR_CALL_PRAPI_LOADCERTFROMMEM = PR_CALL_GROUP_PRAPI+152,
00262 PR_CALL_PRAPI_SELFTEST = PR_CALL_GROUP_PRAPI+153,
00263 PR_CALL_PRAPI_DECODELATENTIMAGE = PR_CALL_GROUP_PRAPI+154,
00264 PR_CALL_PRAPI_MAKEPACE = PR_CALL_GROUP_PRAPI+155,
00265 PR_CALL_PRAPI_MAKEPACEA = PR_CALL_GROUP_PRAPI+156,
00266 PR_CALL_PRAPI_GETCERTIFICATEID = PR_CALL_GROUP_PRAPI+157,
00267 PR_CALL_PRAPI_GETCERTIFICATEIDA = PR_CALL_GROUP_PRAPI+158,
00268 PR_CALL_PRAPI_GETNEXTAUTHENTICATION = PR_CALL_GROUP_PRAPI+159,
00269 PR_CALL_PRAPI_GETNEXTAUTHENTICATIONA = PR_CALL_GROUP_PRAPI+160,
00270 PR_CALL_PRAPI_READMAGSTRIPE = PR_CALL_GROUP_PRAPI+163,
00271 PR_CALL_PRAPI_READMAGSTRIPEA = PR_CALL_GROUP_PRAPI+164,
00272 PR_CALL_PRAPI_LOADCERTFROMSTORE = PR_CALL_GROUP_PRAPI+165,
00273 PR_CALL_PRAPI_LOADCERTFROMSTOREA = PR_CALL_GROUP_PRAPI+166,
00274 PR_CALL_PRAPI_RESOLVEMAGSTRIPE = PR_CALL_GROUP_PRAPI+167,
00275 PR_CALL_PRAPI_RESOLVEMAGSTRIPEA = PR_CALL_GROUP_PRAPI+168,
00276 PR_CALL_PRAPI_GETENHANCEDUV = PR_CALL_GROUP_PRAPI+169,
00277 PR_CALL_PRAPI_DOAUTHENTICATION = PR_CALL_GROUP_PRAPI+170,
00278 PR_CALL_PRAPI_DOAUTHENTICATIONA = PR_CALL_GROUP_PRAPI+171,
00279 PR_CALL_PRAPI_SELECT_APPLICATION = PR_CALL_GROUP_PRAPI+172,
00280 PR_CALL_PRAPI_SELECT_APPLICATIONA = PR_CALL_GROUP_PRAPI+173,
00281 PR_CALL_PRAPI_GETAPPLICATIONS = PR_CALL_GROUP_PRAPI+174,
00282 PR_CALL_PRAPI_GETAPPLICATIONSA = PR_CALL_GROUP_PRAPI+175,
00283 PR_CALL_PRAPI_GETRFIDFILE_START = PR_CALL_GROUP_PRAPI+177,
00284 PR_CALL_PRAPI_GETRFIDFILE_STARTA = PR_CALL_GROUP_PRAPI+178,
00285 PR_CALL_PRAPI_GETRFIDFILE_GETSTATUS = PR_CALL_GROUP_PRAPI+179,
00286 PR_CALL_PRAPI_GETRFIDFILE_WAIT = PR_CALL_GROUP_PRAPI+180,
00287 PR_CALL_PRAPI_GETRFIDFILE_STOP = PR_CALL_GROUP_PRAPI+181,
00288 PR_CALL_PRAPI_SAVEDOCUMENTTOMEM = PR_CALL_GROUP_PRAPI+182,
00289 PR_CALL_PRAPI_LOADDOCUMENTFROMMEM = PR_CALL_GROUP_PRAPI+183,
00290 PR_CALL_PRAPI_ANALYZE = PR_CALL_GROUP_PRAPI+184,
00291 PR_CALL_PRAPI_ANALYZED = PR_CALL_GROUP_PRAPI+185,
00292 PR_CALL_PRAPI_GETREADERCARDLIST = PR_CALL_GROUP_PRAPI+186,
00293 PR_CALL_PRAPI_GETFILELIST = PR_CALL_GROUP_PRAPI+187,
00294
00295
00296
00297 };
00298
00299
00300
00301
00302
00303
00304
00305
00306 struct PR_PARM_PRAPI_GETSTATUS {
00307 int reqid;
00308 int status;
00309
00310 };
00311
00312
00313
00314
00315 struct PR_PARM_PRAPI_GETDEVICELIST {
00316 wchar_t **devices;
00317 bool *calibrated;
00318 int ndevices;
00319 };
00320
00321
00322
00323
00324 struct PR_PARM_PRAPI_GETDEVICELISTA {
00325 char **devices;
00326 bool *calibrated;
00327 int ndevices;
00328 };
00329
00330
00331
00332
00333 struct PR_PARM_PRAPI_USEDEVICE {
00334 const wchar_t *device;
00335 int mode;
00336
00337 };
00338
00339
00340
00341
00342 struct PR_PARM_PRAPI_USEDEVICEA {
00343 const char *device;
00344 int mode;
00345
00346 };
00347
00348
00349
00350
00351 struct PR_PARM_PRAPI_GETCONTROLLERHANDLE {
00352 gxHANDLE *handle;
00353 };
00354
00355
00356
00357
00358 struct PR_PARM_PRAPI_CALIBRATE {
00359 int windowid;
00360
00361 };
00362
00363
00364
00365
00366 struct PR_PARM_PRAPI_ISCALIBRATED {
00367 int windowid;
00368
00369 };
00370
00371
00372
00373
00374 struct PR_PARM_PRAPI_SETPAGELIGHT {
00375 int pages;
00376
00377
00378
00379
00380
00381 unsigned int *lights;
00382 };
00383
00384
00385
00386
00387 struct PR_PARM_PRAPI_RESETDOCUMENT {
00388 int lastpage;
00389 };
00390
00391 #endif
00392 #if !defined(GX_SWIGIF) && !(defined(GX_MANUAL) && defined(GX_DOTNET))
00393
00407 typedef void GXAPI PR_EVFUNC(int event,int param1,int param2,void* uparam);
00408
00411 #endif
00412 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL)
00413
00414
00415
00416
00417 struct PR_PARM_PRAPI_SETEVENTFUNCTION {
00418 PR_EVFUNC *func;
00419 void *param;
00420 };
00421
00422
00423
00424
00425 struct PR_PARM_PRAPI_TEST_DOCUMENT {
00426 int state;
00427 int windowid;
00428
00429 };
00430
00431
00432
00433
00434 struct PR_PARM_PRAPI_CAPTURE_START {
00435 int reqid;
00436
00437 };
00438
00439
00440
00441
00442 struct PR_PARM_PRAPI_CAPTURE_WAIT {
00443 int reqid;
00444 };
00445
00446
00447
00448
00449 struct PR_PARM_PRAPI_CAPTURE_PREVIEW {
00450 int windowid;
00451 };
00452
00453
00454
00455
00456 struct PR_PARM_PRAPI_GETIMAGE_V {
00457 int page;
00458 int light;
00459 int type;
00460
00461 gxVARIANT img;
00462 };
00463
00464
00465
00466
00467 struct PR_PARM_PRAPI_GETENHANCEDUV {
00468 int page;
00469 int imgtype;
00470 gxVARIANT result;
00471 };
00472
00473
00474
00475
00476 struct PR_PARM_PRAPI_SAVEIMAGE {
00477 int page;
00478 int light;
00479 int type;
00480
00481 const wchar_t *filename;
00482 int filetype;
00483 };
00484
00485
00486
00487
00488 struct PR_PARM_PRAPI_SAVEIMAGEA {
00489 int page;
00490 int light;
00491 int type;
00492
00493 const char *filename;
00494 int filetype;
00495 };
00496
00497 #if defined(WIN32) && !defined(GX_DOTNET)
00498
00499
00500
00501
00502 struct PR_PARM_PRAPI_DRAWIMAGE {
00503 int page;
00504 int light;
00505 int type;
00506
00507 HDC hdc;
00508 int x;
00509 int y;
00510 int xsize;
00511 int ysize;
00512 gxRCT *frame;
00513 };
00514
00515 #endif
00516
00517
00518
00519
00520 struct PR_PARM_PRAPI_GETLIGHTNUMBER {
00521 int lights;
00522 };
00523
00524
00525
00526
00527 struct PR_PARM_PRAPI_GETRFIDCARDLIST {
00528 wchar_t **cards;
00529 int ncards;
00530 };
00531
00532
00533
00534
00535 struct PR_PARM_PRAPI_GETRFIDCARDLISTA {
00536 char **cards;
00537 int ncards;
00538 };
00539
00540 struct PR_PARM_PRAPI_GETREADERCARDLIST {
00541 wchar_t *reader;
00542 wchar_t **cards;
00543 int ncards;
00544 };
00545
00546 struct PR_PARM_PRAPI_GETFILELIST {
00547 const wchar_t *card;
00548 int *files;
00549 int nfiles;
00550 };
00551
00552
00553
00554
00555 struct PR_PARM_PRAPI_GETRFIDFILE {
00556 const wchar_t *card;
00557 int fileid;
00558 void *data;
00559 int sdata;
00560 };
00561
00562
00563
00564
00565 struct PR_PARM_PRAPI_GETRFIDFILEA {
00566 const char *card;
00567 int fileid;
00568 void *data;
00569 int sdata;
00570 };
00571
00572
00573
00574
00575 struct PR_PARM_PRAPI_GETRFIDFILE_START {
00576 const wchar_t *card;
00577 int fileid;
00578 int reqid;
00579
00580 };
00581
00582
00583
00584
00585 struct PR_PARM_PRAPI_GETRFIDFILE_STARTA {
00586 const char *card;
00587 int fileid;
00588 int reqid;
00589
00590 };
00591
00592
00593
00594
00595 struct PR_PARM_PRAPI_GETRFIDFILE_WAIT {
00596 int reqid;
00597 void *data;
00598 int sdata;
00599 };
00600
00601
00602
00603
00604 struct PR_PARM_PRAPI_GETLIGHTMASK {
00605 int lightid;
00606
00607
00608 int windowid;
00609
00610
00611 int lightmask;
00612 };
00613
00614
00615
00616
00617 struct PR_PARM_PRAPI_GETWINDOWNUMBER {
00618 int windows;
00619 };
00620
00621
00622
00623
00624 struct PR_PARM_PRAPI_GETLIGHTLIST {
00625 int *lightbuf;
00626 int nlights;
00627 };
00628
00629
00630
00631
00632 struct PR_PARM_PRAPI_SET_STATUS_LED {
00633 int ledmask;
00634 int color;
00635
00636
00637 };
00638
00639
00640
00641
00642 struct PR_PARM_PRAPI_BLINK_STATUS {
00643 int coding;
00644
00645
00646
00647 int iteration;
00648 int mask;
00649 int type;
00650
00651 unsigned int datalength;
00652 unsigned int *data;
00653 };
00654
00655
00656
00657
00658 struct PR_PARM_PRAPI_TEST_POWER {
00659 int state;
00660 int level;
00661 };
00662
00663
00664
00665
00666 struct PR_PARM_PRAPI_TEST_BUTTON {
00667 int code;
00668 int state;
00669 };
00670
00671
00672
00673
00674 struct PR_PARM_PRAPI_GET_BUTTON_EVENT {
00675 int code;
00676 int state;
00677 };
00678
00679
00680
00681
00682 struct PR_PARM_PRAPI_GET_APPLICATIONS {
00683 const wchar_t *card;
00684 int *apps;
00685
00686 int napps;
00687 };
00688
00689
00690
00691
00692 struct PR_PARM_PRAPI_GET_APPLICATIONSA {
00693 const char *card;
00694 int *apps;
00695
00696 int napps;
00697 };
00698
00699
00700
00701
00702 struct PR_PARM_PRAPI_SELECT_APPLICATION {
00703 const wchar_t *card;
00704 int application;
00705 };
00706
00707
00708
00709
00710 struct PR_PARM_PRAPI_SELECT_APPLICATIONA {
00711 const char *card;
00712 int application;
00713 };
00714
00715
00716
00717
00718 struct PR_PARM_PRAPI_MAKEBAC {
00719 const wchar_t *card;
00720 const wchar_t **lines;
00721 int nlines;
00722 };
00723
00724
00725
00726
00727 struct PR_PARM_PRAPI_MAKEBACA {
00728 const char *card;
00729 const char **lines;
00730 int nlines;
00731 };
00732
00733
00734
00735
00736 struct PR_PARM_PRAPI_MAKEPACE {
00737 const wchar_t *card;
00738 const wchar_t **lines;
00739 int nlines;
00740 int PasswordType;
00742 };
00743
00744
00745
00746
00747 struct PR_PARM_PRAPI_MAKEPACEA {
00748 const char *card;
00749 const char **lines;
00750 int nlines;
00751 int PasswordType;
00753 };
00754
00755
00756
00757
00758
00759 struct PR_PARM_PRAPI_LOADCERTFILE {
00760 const wchar_t *certificate;
00761 const wchar_t *privateKey;
00762 };
00763
00764
00765
00766
00767 struct PR_PARM_PRAPI_LOADCERTFILEA {
00768 const char *certificate;
00769 const char *privateKey;
00770 };
00771
00772
00773
00774
00775 struct PR_PARM_PRAPI_LOADCERTFROMSTORE {
00776 const wchar_t *storename;
00777 };
00778
00779
00780
00781
00782 struct PR_PARM_PRAPI_LOADCERTFROMSTOREA {
00783 const char *storename;
00784 };
00785
00786
00787
00788
00789 struct PR_PARM_PRAPI_LOADCERTFROMMEM{
00790 void* certificate_data;
00791 unsigned int certificate_length;
00792 void* privateKey_data;
00793 unsigned int privateKey_length;
00794 };
00795
00796
00797
00798
00799 struct PR_PARM_PRAPI_BEGIN_WINDOW_MESSAGING {
00800 #if defined(WIN32)
00801 HWND hwnd;
00802 UINT base_msg;
00803 #else
00804 int rfu1;
00805 #endif
00806 };
00807
00808
00809
00810
00811
00812 struct PR_PARM_PRAPI_GET_UDINFO {
00813 int nblocks;
00814 int sblock;
00815 };
00816
00817
00818
00819
00820 struct PR_PARM_PRAPI_READ_UD {
00821 int fblock;
00822 int nblocks;
00823 void *data;
00824 };
00825
00826
00827
00828
00829 struct PR_PARM_PRAPI_WRITE_UD {
00830 int fblock;
00831 int nblocks;
00832 const void *data;
00833 };
00834
00835
00836
00837
00838 struct PR_PARM_PRAPI_GETOCR_V {
00839 int page;
00840 int light;
00841 int type;
00842 gxVARIANT doc;
00843 gxVARIANT params;
00844 };
00845
00846
00847
00848
00849 struct PR_PARM_PRAPI_GETMRZ_V {
00850 int page;
00851 int light;
00852 int type;
00853 gxVARIANT doc;
00854 };
00855
00856
00857
00858
00859 struct PR_PARM_PRAPI_GETBARCODE_V {
00860 int page;
00861 int light;
00862 int type;
00863 int bctype;
00864
00865 int index;
00866 gxVARIANT doc;
00867 };
00868
00869
00870
00871
00872 struct PR_PARM_PRAPI_GETDOCUMENTRECT_V {
00873 int page;
00874 int light;
00875 int type;
00876 gxVARIANT doc;
00877 };
00878
00879
00880
00881
00882 struct PR_PARM_PRAPI_RECOGNIZE_V {
00883 int page;
00884 gxVARIANT doc;
00885 };
00886
00887
00888
00889
00890 struct PR_PARM_PRAPI_RESOLVEMRZTEXT_V {
00891 const wchar_t **lines;
00892 int nlines;
00893 gxVARIANT doc;
00894 };
00895
00896
00897
00898
00899 struct PR_PARM_PRAPI_RESOLVEMRZTEXTA_V {
00900 const char **lines;
00901 int nlines;
00902 gxVARIANT doc;
00903 };
00904
00905
00906
00907
00908 struct PR_PARM_PRAPI_RESOLVERFIDDATA_V {
00909 const void *data;
00910 int sdata;
00911 gxVARIANT doc;
00912 };
00913
00914
00915
00916
00917 struct PR_PARM_PRAPI_GETDOCUMENTSTATUS_V {
00918 gxVARIANT doc;
00919 int code;
00920 int status;
00921
00922 };
00923
00924
00925
00926
00927 struct PR_PARM_PRAPI_GETFIELDFROMDOC_V {
00928 gxVARIANT doc;
00929 int field_code;
00930 int index;
00931 gxVARIANT field;
00932 };
00933
00934
00935
00936
00937 struct PR_PARM_PRAPI_GETFIELDIMAGE_V {
00938 gxVARIANT doc;
00939 int field_code;
00940 int index;
00941 gxVARIANT img;
00942 };
00943
00944
00945
00946
00947 struct PR_PARM_PRAPI_COMPARE_FACE_V {
00948 int page;
00949 int face_no;
00950 gxVARIANT doc;
00951 };
00952
00953
00954
00955
00956 struct PR_PARM_PRAPI_SAVEDOCUMENT_V {
00957 gxVARIANT doc;
00958 const wchar_t *filename;
00959 int filetype;
00960 };
00961
00962
00963
00964
00965 struct PR_PARM_PRAPI_SAVEDOCUMENTA_V {
00966 gxVARIANT doc;
00967 const char *filename;
00968 int filetype;
00969 };
00970
00971
00972
00973
00974 struct PR_PARM_PRAPI_LOADDOCUMENT_V {
00975 const wchar_t *filename;
00976 gxVARIANT doc;
00977 };
00978
00979
00980
00981
00982 struct PR_PARM_PRAPI_LOADDOCUMENTA_V {
00983 const char *filename;
00984 gxVARIANT doc;
00985 };
00986
00987
00988
00989
00990 struct PR_PARM_PRAPI_GETDOCUMENTROOT_V {
00991 gxVARIANT doc;
00992 };
00993
00994
00995
00996
00997
00998
00999
01000
01001 struct PR_PARM_PRAPI_RFIDCARD {
01002 const wchar_t *card;
01003 };
01004
01005
01006
01007
01008
01009
01010
01011
01012 struct PR_PARM_PRAPI_RFIDCARDA {
01013 const char *card;
01014 };
01015
01016
01017
01018
01019 struct PR_PARM_PRAPI_TA {
01020 const wchar_t *card;
01021 void *data;
01022 int sdata;
01023 };
01024
01025
01026
01027
01028 struct PR_PARM_PRAPI_TAA {
01029 const char *card;
01030 void *data;
01031 int sdata;
01032 };
01033
01034
01035
01036
01037 struct PR_PARM_PRAPI_CHECKRFIDFILEHASH {
01038 const wchar_t *card;
01039 int fileid;
01040 };
01041
01042
01043
01044
01045 struct PR_PARM_PRAPI_CHECKRFIDFILEHASHA {
01046 const char *card;
01047 int fileid;
01048 };
01049
01050
01051
01052
01053 struct PR_PARM_PRAPI_GETDEVICEINFO {
01054 gxVARIANT devinfo;
01055 };
01056
01057
01058
01059
01060 struct PR_PARM_PRAPI_GETRFIDCARDINFO {
01061 const wchar_t *card;
01062 gxVARIANT cardinfo;
01063 };
01064
01065
01066
01067
01068 struct PR_PARM_PRAPI_GETRFIDCARDINFOA {
01069 const char *card;
01070 gxVARIANT cardinfo;
01071 };
01072
01073
01074
01075
01076 struct PR_PARM_PRAPI_FINGERSTONIST {
01077 const wchar_t *filename;
01078 gxVARIANT fields;
01079 };
01080
01081
01082
01083
01084 struct PR_PARM_PRAPI_FINGERSTONISTA {
01085 const char *filename;
01086 gxVARIANT fields;
01087 };
01088
01089
01090
01091
01092 struct PR_PARM_PRAPI_FINGERSTONISTMEM {
01093 void **buffer;
01094 gxi32 *buflen;
01095 gxVARIANT fields;
01096 };
01097
01098
01099
01100
01101 struct PR_PARM_PRAPI_CLEARCERTLIST {
01102 int sel;
01103 };
01104
01105
01106
01107
01108 struct PR_PARM_PRAPI_SELFTEST {
01109 int condition;
01110 gxVARIANT result;
01111 };
01112
01113
01114
01115
01116 struct PR_PARM_PRAPI_DECODELATENTIMAGE {
01117 int page;
01118 int light;
01119 int type;
01120 const wchar_t *decpar;
01121 gxVARIANT image;
01122 };
01123
01124
01125
01126
01127 struct PR_PARM_PRAPI_GETCERTIFICATEIDA {
01128 const char *card;
01129 int Authentication;
01130 gxVARIANT CertId;
01131 };
01132
01133
01134
01135
01136 struct PR_PARM_PRAPI_GETCERTIFICATEID {
01137 const wchar_t *card;
01138 int Authentication;
01139 gxVARIANT CertId;
01140 };
01141
01142
01143
01144
01145 struct PR_PARM_PRAPI_GETNEXTAUTHENTICATIONA {
01146 const char *card;
01147 int ProcessName;
01148 int ForceNext;
01149 };
01150
01151
01152
01153
01154 struct PR_PARM_PRAPI_GETNEXTAUTHENTICATION {
01155 const wchar_t *card;
01156 int ProcessName;
01157 int ForceNext;
01158 };
01159
01160
01161
01162
01163 struct PR_PARM_PRAPI_DOAUTHENTICATIONA {
01164 const char *card;
01165 int ProcessName;
01166 const char **AuthData;
01167 int Lines;
01168 int PasswordType;
01169 };
01170
01171
01172
01173
01174 struct PR_PARM_PRAPI_DOAUTHENTICATION {
01175 const wchar_t *card;
01176 int ProcessName;
01177 const wchar_t **AuthData;
01178 int Lines;
01179 int PasswordType;
01180 };
01181
01182
01183
01184
01185 struct PR_PARM_PRAPI_READMAGSTRIPE {
01186 wchar_t **tracks;
01187 int ntracks;
01188 };
01189
01190
01191
01192
01193 struct PR_PARM_PRAPI_READMAGSTRIPEA {
01194 char **tracks;
01195 int ntracks;
01196 };
01197
01198
01199
01200
01201 struct PR_PARM_PRAPI_RESOLVEMAGSTRIPE {
01202 const wchar_t **tracks;
01203 int ntracks;
01204 gxVARIANT doc;
01205 };
01206
01207
01208
01209
01210 struct PR_PARM_PRAPI_RESOLVEMAGSTRIPEA {
01211 const char **tracks;
01212 int ntracks;
01213 gxVARIANT doc;
01214 };
01215
01216
01217
01218
01219 struct PR_PARM_PRAPI_SAVEDOCUMENTTOMEM {
01220 gxVARIANT doc;
01221 int filetype;
01222 gxu8 **buffer;
01223 int *buflen;
01224 };
01225
01226
01227
01228
01229 struct PR_PARM_PRAPI_LOADDOCUMENTFROMMEM {
01230 gxVARIANT doc;
01231 const gxu8 *buffer;
01232 int buflen;
01233 };
01234
01235
01236
01237
01238 struct PR_PARM_PRAPI_ANALYZE {
01239 gxVARIANT page;
01240 int takslen;
01241 int *task;
01242 gxVARIANT doc;
01243 };
01244
01245
01246
01247
01248 struct PR_PARM_PRAPI_ANALYZED {
01249 gxu8 *buffer;
01250 int buflen;
01251 gxVARIANT doc;
01252 };
01253
01254 #endif
01255
01256
01257
01258
01259
01260 #if !defined(NO_GX_FUNCTIONS) && !defined(GX_SWIGIF)
01261
01277 inline int pr_getdevicelist(gxHANDLE handle,wchar_t ***devices,int *ndevices) {
01278 struct PR_PARM_PRAPI_GETDEVICELIST gdl;
01279 int ret;
01280 assert(devices && ndevices);
01281 ret = gx_call(handle, PR_CALL_PRAPI_GETDEVICELIST, &gdl);
01282 *devices = gdl.devices;
01283 *ndevices = gdl.ndevices;
01284 return ret;
01285 }
01286
01298 inline int pr_getdevicelista(gxHANDLE handle,char ***devices,int *ndevices) {
01299 struct PR_PARM_PRAPI_GETDEVICELISTA gdl;
01300 int ret;
01301 assert(devices && ndevices);
01302 ret = gx_call(handle, PR_CALL_PRAPI_GETDEVICELISTA, &gdl);
01303 *devices = gdl.devices;
01304 *ndevices = gdl.ndevices;
01305 return ret;
01306 }
01307
01308 #ifdef __cplusplus
01309
01320 inline int pr_getdevicelist(gxHANDLE handle,char ***devices,int *ndevices) {
01321 return pr_getdevicelista(handle,devices,ndevices);
01322 }
01323 #endif
01324
01334 inline int pr_usedevice(gxHANDLE handle,const wchar_t *device,int mode) {
01335 struct PR_PARM_PRAPI_USEDEVICE ud;
01336 assert(device);
01337 ud.device = device;
01338 ud.mode = mode;
01339 return gx_call(handle, PR_CALL_PRAPI_USEDEVICE, &ud);
01340 }
01341
01351 inline int pr_usedevicea(gxHANDLE handle,const char *device,int mode) {
01352 struct PR_PARM_PRAPI_USEDEVICEA ud;
01353 assert(device);
01354 ud.device = device;
01355 ud.mode = mode;
01356 return gx_call(handle, PR_CALL_PRAPI_USEDEVICEA, &ud);
01357 }
01358
01367 inline int pr_usedevicen(gxHANDLE handle,int devno,int mode) {
01368 char **devlist;
01369 int ndev,ret;
01370 assert(devno>=0);
01371
01372 if(!pr_getdevicelista(handle,&devlist,&ndev))return 0;
01373 if(ndev<=devno){
01374 if(ndev)gx_globalfree(devlist);
01375 gx_seterror(_GX_ENOENT,L"No device found");
01376 return false;
01377 }
01378
01379 ret=pr_usedevicea(handle,devlist[devno],mode);
01380 gx_globalfree(devlist);
01381 return ret;
01382 }
01383
01384 #ifdef __cplusplus
01385
01395 inline int pr_usedevice(gxHANDLE handle,const char *device,int mode) {
01396 return pr_usedevicea(handle,device,mode);
01397 }
01398
01407 inline int pr_usedevice(gxHANDLE handle,int devno,int mode) {
01408 return pr_usedevicen(handle,devno,mode);
01409 }
01410 #endif
01411
01417 inline int pr_closedevice(gxHANDLE handle) {
01418 struct PR_PARM_PRAPI_USEDEVICEA ud;
01419 ud.device = 0;
01420 ud.mode=_PR_UMODE_DISCONNECT;
01421 return gx_call(handle, PR_CALL_PRAPI_USEDEVICEA, &ud);
01422 }
01423
01433 inline int pr_getctrlhandle(gxHANDLE handle,gxHANDLE **hctrl) {
01434 struct PR_PARM_PRAPI_GETCONTROLLERHANDLE gch;
01435 int ret;
01436 assert(hctrl);
01437 ret = gx_call(handle, PR_CALL_PRAPI_GETCONTROLLERHANDLE, &gch);
01438 *hctrl=gch.handle;
01439 return ret;
01440 }
01441
01453 inline int pr_calibrate(gxHANDLE handle,int windowid GX_DEFARG(0)) {
01454 struct PR_PARM_PRAPI_CALIBRATE cal;
01455 cal.windowid = windowid;
01456 return gx_call(handle, PR_CALL_PRAPI_CALIBRATE, &cal);
01457 }
01458
01467 inline int pr_iscalibrated(gxHANDLE handle,int windowid GX_DEFARG(0)) {
01468 struct PR_PARM_PRAPI_ISCALIBRATED cal;
01469 cal.windowid = windowid;
01470 return gx_call(handle, PR_CALL_PRAPI_ISCALIBRATED, &cal);
01471 }
01472
01487 inline int pr_testdocument(gxHANDLE handle,int *state,int windowid GX_DEFARG(0)) {
01488 struct PR_PARM_PRAPI_TEST_DOCUMENT td;
01489 int ret;
01490 assert(state);
01491 td.windowid = windowid;
01492 ret = gx_call(handle, PR_CALL_PRAPI_TEST_DOCUMENT, &td);
01493 if(state)*state = td.state;
01494 return ret;
01495 }
01496
01503 inline int pr_getlightnumber(gxHANDLE handle,int *lights) {
01504 struct PR_PARM_PRAPI_GETLIGHTNUMBER li;
01505 int ret;
01506 assert(lights);
01507 ret = gx_call(handle, PR_CALL_PRAPI_GETLIGHTNUMBER, &li);
01508 if(lights) *lights = li.lights;
01509 return ret;
01510 }
01511
01528 inline int pr_getlightmask(gxHANDLE handle,int *lightmask,int lightid,int windowid) {
01529 struct PR_PARM_PRAPI_GETLIGHTMASK ll;
01530 int ret;
01531 assert(lightmask);
01532 ll.lightid = lightid;
01533 ll.windowid = windowid;
01534 ret = gx_call(handle, PR_CALL_PRAPI_GETLIGHTMASK, &ll);
01535 if(lightmask) *lightmask = ll.lightmask;
01536 return ret;
01537 }
01538
01546 inline int pr_getlightlist(gxHANDLE handle,int *lightbuf,int nlights) {
01547 struct PR_PARM_PRAPI_GETLIGHTLIST ll;
01548 assert(lightbuf);
01549 ll.lightbuf = lightbuf;
01550 ll.nlights = nlights;
01551 return gx_call(handle, PR_CALL_PRAPI_GETLIGHTLIST, &ll);
01552 }
01553
01560 inline int pr_getwindownumber(gxHANDLE handle,int *windows) {
01561 struct PR_PARM_PRAPI_GETWINDOWNUMBER wi;
01562 int ret;
01563 assert(windows);
01564 ret = gx_call(handle, PR_CALL_PRAPI_GETWINDOWNUMBER, &wi);
01565 if(windows) *windows = wi.windows;
01566 return ret;
01567 }
01568
01578 inline int pr_setstatusled(gxHANDLE handle, int ledmask, int color) {
01579 struct PR_PARM_PRAPI_SET_STATUS_LED led;
01580 led.ledmask = ledmask;
01581 led.color = color;
01582 return gx_call(handle, PR_CALL_PRAPI_SET_STATUS_LED, &led);
01583 }
01584
01599 inline int pr_blinkstatus(gxHANDLE handle, int coding, int mask, int type, int iteration, unsigned int *data, unsigned int datalength) {
01600
01601 struct PR_PARM_PRAPI_BLINK_STATUS out_data;
01602
01603 out_data.coding = coding;
01604 out_data.mask = mask;
01605 out_data.type = type;
01606 out_data.iteration = iteration;
01607 out_data.data = data;
01608 out_data.datalength = datalength;
01609
01610 return gx_call(handle, PR_CALL_PRAPI_BLINK_STATUS, &out_data);
01611 }
01612
01621 inline int pr_testpower(gxHANDLE handle, int *state, int *level) {
01622 struct PR_PARM_PRAPI_TEST_POWER tp;
01623 int ret;
01624 assert(state);
01625 ret = gx_call(handle, PR_CALL_PRAPI_TEST_POWER, &tp);
01626 if(state)*state = tp.state;
01627 if(level)*level = tp.level;
01628 return ret;
01629 }
01630
01638 inline int pr_testbutton(gxHANDLE handle, int keycode, int *state) {
01639 struct PR_PARM_PRAPI_TEST_BUTTON bt;
01640 int ret;
01641 assert(state);
01642 bt.code = keycode;
01643 ret = gx_call(handle, PR_CALL_PRAPI_TEST_BUTTON, &bt);
01644 if(state)*state = bt.state;
01645 return ret;
01646 }
01647
01655 inline int pr_getbuttonevent(gxHANDLE handle, int *keycode, int *state) {
01656 struct PR_PARM_PRAPI_GET_BUTTON_EVENT bt;
01657 int ret;
01658 assert(state);
01659 assert(keycode);
01660 ret = gx_call(handle, PR_CALL_PRAPI_GET_BUTTON_EVENT, &bt);
01661 if(state)*state = bt.state;
01662 if(keycode)*keycode = bt.code;
01663 return ret;
01664 }
01665
01676 inline int pr_suspend(gxHANDLE handle) {
01677 return gx_call(handle,PR_CALL_PRAPI_SUSPEND,0);
01678 }
01679
01686 inline int pr_wakeup(gxHANDLE handle) {
01687 return gx_call(handle,PR_CALL_PRAPI_WAKEUP,0);
01688 }
01689
01698 inline int pr_getudinfo(gxHANDLE handle, int *nblocks, int *sblock) {
01699 struct PR_PARM_PRAPI_GET_UDINFO gi;
01700 int ret;
01701 assert(nblocks);
01702 assert(sblock);
01703 ret = gx_call(handle, PR_CALL_PRAPI_GET_UDINFO, &gi);
01704 if(nblocks)*nblocks = gi.nblocks;
01705 if(sblock)*sblock = gi.sblock;
01706 return ret;
01707 }
01708
01721 inline int pr_readudata(gxHANDLE handle, int fblock, int nblocks, void **data) {
01722 struct PR_PARM_PRAPI_READ_UD ru;
01723 int ret;
01724 assert(data);
01725 ru.fblock = fblock;
01726 ru.nblocks = nblocks;
01727 ret = gx_call(handle, PR_CALL_PRAPI_READ_UD, &ru);
01728 if(data)*data = ru.data;
01729 return ret;
01730 }
01731
01741 inline int pr_writeudata(gxHANDLE handle, int fblock, int nblocks, const void *data) {
01742 struct PR_PARM_PRAPI_WRITE_UD wu;
01743 wu.fblock = fblock;
01744 wu.nblocks = nblocks;
01745 wu.data = data;
01746 return gx_call(handle, PR_CALL_PRAPI_WRITE_UD, &wu);
01747 }
01748
01756 inline int pr_getdeviceinfo(gxHANDLE handle, gxVARIANT *devinfo) {
01757 struct PR_PARM_PRAPI_GETDEVICEINFO gdi;
01758 int ret;
01759 assert(devinfo);
01760 ret = gx_call(handle, PR_CALL_PRAPI_GETDEVICEINFO, &gdi);
01761 if(ret && devinfo)*devinfo = gdi.devinfo;
01762 return ret;
01763 }
01764
01774 inline int pr_selftest(gxHANDLE handle, int condition, gxVARIANT *result)
01775 {
01776 struct PR_PARM_PRAPI_SELFTEST self_test;
01777 int ret;
01778 assert(result);
01779 self_test.condition = condition;
01780 ret = gx_call(handle, PR_CALL_PRAPI_SELFTEST, &self_test);
01781 *result = self_test.result;
01782 return ret;
01783 }
01784
01795 inline int pr_readmagstripe(gxHANDLE handle, wchar_t ***tracks, int *ntracks)
01796 {
01797 struct PR_PARM_PRAPI_READMAGSTRIPE gms;
01798 int ret;
01799 assert(tracks && ntracks);
01800 ret = gx_call(handle, PR_CALL_PRAPI_READMAGSTRIPE, &gms);
01801 if(ret) {
01802 *tracks = gms.tracks;
01803 *ntracks = gms.ntracks;
01804 }
01805 return ret;
01806 }
01807
01818 inline int pr_readmagstripea(gxHANDLE handle, char ***tracks, int *ntracks)
01819 {
01820 struct PR_PARM_PRAPI_READMAGSTRIPEA gms;
01821 int ret;
01822 assert(tracks && ntracks);
01823 ret = gx_call(handle, PR_CALL_PRAPI_READMAGSTRIPEA, &gms);
01824 if(ret) {
01825 *tracks = gms.tracks;
01826 *ntracks = gms.ntracks;
01827 }
01828 return ret;
01829 }
01830
01831 #ifdef __cplusplus
01832
01842 inline int pr_readmagstripe(gxHANDLE handle, char ***tracks, int *ntracks) {
01843 return pr_readmagstripea(handle, tracks, ntracks);
01844 }
01845 #endif
01846
01847
01860 inline int pr_seteventfunction(gxHANDLE handle, PR_EVFUNC *eventhandler, void *param) {
01861 struct PR_PARM_PRAPI_SETEVENTFUNCTION sef;
01862 sef.func = eventhandler;
01863 sef.param = param;
01864 return gx_call(handle, PR_CALL_PRAPI_SETEVENTFUNCTION, &sef);
01865 }
01866
01867 #if (defined(WIN32) || defined(GX_MANUAL)) && !defined(GX_SWIG)
01868
01886 inline int pr_beginwindowmessaging(gxHANDLE handle, HWND hwnd, UINT base_msg GX_DEFARG(WM_USER)) {
01887 struct PR_PARM_PRAPI_BEGIN_WINDOW_MESSAGING bwm;
01888 bwm.hwnd = hwnd;
01889 bwm.base_msg = base_msg;
01890 return gx_call(handle,PR_CALL_PRAPI_BEGIN_WINDOW_MESSAGING,&bwm);
01891 }
01892
01902 inline int pr_endwindowmessaging(gxHANDLE handle) {
01903 return gx_call(handle,PR_CALL_PRAPI_END_WINDOW_MESSAGING,0);
01904 }
01905
01906 #endif
01907
01908 #if (defined(LINUX) || defined(GX_MANUAL)) && !defined(GX_SWIG)
01909
01920 inline int pr_startbgprocesses(gxHANDLE handle) {
01921 struct PR_PARM_PRAPI_BEGIN_WINDOW_MESSAGING bwm;
01922 return gx_call(handle,PR_CALL_PRAPI_BEGIN_WINDOW_MESSAGING,&bwm);
01923 }
01924
01933 inline int pr_stopbgprocesses(gxHANDLE handle) {
01934 return gx_call(handle,PR_CALL_PRAPI_END_WINDOW_MESSAGING,0);
01935 }
01936
01937 #endif
01938
01955 inline int pr_setpagelight(gxHANDLE handle,int pages,unsigned int *lights) {
01956 struct PR_PARM_PRAPI_SETPAGELIGHT spl;
01957 spl.pages = pages;
01958 spl.lights = lights;
01959 return gx_call(handle, PR_CALL_PRAPI_SETPAGELIGHT, &spl);
01960 }
01961
01972 inline int pr_capture(gxHANDLE handle) {
01973 return gx_call(handle, PR_CALL_PRAPI_CAPTURE, 0);
01974 }
01975
01985 inline int pr_capture_start(gxHANDLE handle,int *reqid) {
01986 struct PR_PARM_PRAPI_CAPTURE_START cap;
01987 int ret;
01988 assert(reqid);
01989 ret = gx_call(handle, PR_CALL_PRAPI_CAPTURE_START, &cap);
01990 if(reqid) *reqid = cap.reqid;
01991 return ret;
01992 }
01993
02003 inline int pr_capture_getstatus(gxHANDLE handle,int reqid,int *status) {
02004 struct PR_PARM_PRAPI_GETSTATUS stat;
02005 int ret;
02006 assert(status);
02007 stat.reqid = reqid;
02008 ret = gx_call(handle, PR_CALL_PRAPI_CAPTURE_GETSTATUS, &stat);
02009 if(status) *status = stat.status;
02010 return ret;
02011 }
02012
02021 inline int pr_capture_wait(gxHANDLE handle,int reqid) {
02022 struct PR_PARM_PRAPI_CAPTURE_WAIT cap;
02023 cap.reqid = reqid;
02024 return gx_call(handle, PR_CALL_PRAPI_CAPTURE_WAIT, &cap);
02025 }
02026
02037 inline int pr_capture_preview(gxHANDLE handle,int windowid GX_DEFARG(0)) {
02038 struct PR_PARM_PRAPI_CAPTURE_PREVIEW cap;
02039 cap.windowid = windowid;
02040 return gx_call(handle, PR_CALL_PRAPI_CAPTURE_PREVIEW, &cap);
02041 }
02042
02061 inline int pr_getimage(gxHANDLE handle,int page,int light,int type,gxVARIANT *img) {
02062 struct PR_PARM_PRAPI_GETIMAGE_V gi;
02063 int ret;
02064 assert(img);
02065 gi.page = page;
02066 gi.light = light;
02067 gi.type = type;
02068 ret = gx_call(handle, PR_CALL_PRAPI_GETIMAGE_V, &gi);
02069 *img = gi.img;
02070 return ret;
02071 }
02072
02081 inline int pr_getenhanceduv(gxHANDLE handle, int page, int imagetype, gxVARIANT *img)
02082 {
02083 struct PR_PARM_PRAPI_GETENHANCEDUV euv;
02084 int ret;
02085 assert(img);
02086 euv.page = page;
02087 euv.imgtype = imagetype;
02088 ret = gx_call(handle, PR_CALL_PRAPI_GETENHANCEDUV, &euv);
02089 *img = euv.result;
02090 return ret;
02091 }
02092
02106 inline int pr_saveimage(gxHANDLE handle,int page,int light,int type,const wchar_t *filename,int filetype) {
02107 struct PR_PARM_PRAPI_SAVEIMAGE si;
02108 si.page = page;
02109 si.light = light;
02110 si.type = type;
02111 si.filename = filename;
02112 si.filetype = filetype;
02113 return gx_call(handle, PR_CALL_PRAPI_SAVEIMAGE, &si);
02114 }
02115
02130 inline int pr_saveimagea(gxHANDLE handle,int page,int light,int type,const char *filename,int filetype) {
02131 struct PR_PARM_PRAPI_SAVEIMAGEA si;
02132 si.page = page;
02133 si.light = light;
02134 si.type = type;
02135 si.filename = filename;
02136 si.filetype = filetype;
02137 return gx_call(handle, PR_CALL_PRAPI_SAVEIMAGEA, &si);
02138 }
02139
02140 #ifdef __cplusplus
02141
02155 inline int pr_saveimage(gxHANDLE handle,int page,int light,int type,const char *filename,int filetype) {
02156 return pr_saveimagea(handle,page,light,type,filename,filetype);
02157 }
02158 #endif
02159
02160 #if (defined(WIN32) || defined(GX_MANUAL)) && !defined(GX_DOTNET)
02161
02178 inline int pr_drawimage(gxHANDLE handle,int page,int light,int type,HDC hdc,int x,int y,int xsize,int ysize,gxRCT *frame) {
02179 struct PR_PARM_PRAPI_DRAWIMAGE di;
02180 di.page = page;
02181 di.light = light;
02182 di.type = type;
02183 di.hdc = hdc;
02184 di.x = x;
02185 di.y = y;
02186 di.xsize = xsize;
02187 di.ysize = ysize;
02188 di.frame = frame;
02189 return gx_call(handle, PR_CALL_PRAPI_DRAWIMAGE, &di);
02190 }
02191 #endif
02192
02202 inline int pr_fingertonist(gxHANDLE handle,const wchar_t *filename,gxVARIANT fields) {
02203 struct PR_PARM_PRAPI_FINGERSTONIST fn;
02204 fn.filename = filename;
02205 fn.fields = fields;
02206 return gx_call(handle, PR_CALL_PRAPI_FINGERSTONIST, &fn);
02207 }
02208
02216 inline int pr_fingertonista(gxHANDLE handle,const char *filename,gxVARIANT fields) {
02217 struct PR_PARM_PRAPI_FINGERSTONISTA fn;
02218 fn.filename = filename;
02219 fn.fields = fields;
02220 return gx_call(handle, PR_CALL_PRAPI_FINGERSTONISTA, &fn);
02221 }
02222
02223 #ifdef __cplusplus
02224
02231 inline int pr_fingertonist(gxHANDLE handle,const char *filename,gxVARIANT fields) {
02232 return pr_fingertonista(handle,filename,fields);
02233 }
02234 #endif
02235
02244 inline int pr_fingertonistmem(gxHANDLE handle,void **buffer, int *buflen,gxVARIANT fields) {
02245 struct PR_PARM_PRAPI_FINGERSTONISTMEM fn;
02246 fn.buffer = buffer;
02247 fn.buflen = buflen;
02248 fn.fields = fields;
02249 return gx_call(handle, PR_CALL_PRAPI_FINGERSTONISTMEM, &fn);
02250 }
02251
02264 inline int pr_resetdocument(gxHANDLE handle, int lastpage GX_DEFARG(0)) {
02265 struct PR_PARM_PRAPI_RESETDOCUMENT rd;
02266 rd.lastpage = lastpage;
02267 return gx_call(handle, PR_CALL_PRAPI_RESETDOCUMENT, &rd);
02268 }
02269
02279 inline int pr_loaddocument(gxHANDLE handle, const wchar_t *filename, gxVARIANT *pdoc) {
02280 struct PR_PARM_PRAPI_LOADDOCUMENT_V ld;
02281 int st;
02282 assert(filename);
02283 ld.filename = filename;
02284 st = gx_call(handle,PR_CALL_PRAPI_LOADDOCUMENT_V,&ld);
02285 if(pdoc) *pdoc = ld.doc;
02286 return st;
02287 }
02288
02298 inline int pr_loaddocumenta(gxHANDLE handle, const char *filename, gxVARIANT *pdoc) {
02299 struct PR_PARM_PRAPI_LOADDOCUMENTA_V ld;
02300 int st;
02301 assert(filename);
02302 ld.filename = filename;
02303 st = gx_call(handle,PR_CALL_PRAPI_LOADDOCUMENTA_V,&ld);
02304 if(pdoc) *pdoc = ld.doc;
02305 return st;
02306 }
02307
02308 #ifdef __cplusplus
02309
02318 inline int pr_loaddocument(gxHANDLE handle, const char *filename, gxVARIANT *pdoc) {
02319 return pr_loaddocumenta(handle, filename, pdoc);
02320 }
02321 #endif
02322
02333 inline int pr_loaddocumentfrommem(gxHANDLE handle, const gxu8 *buffer, int buflen, gxVARIANT *pdoc) {
02334 struct PR_PARM_PRAPI_LOADDOCUMENTFROMMEM ld;
02335 int st;
02336 ld.buffer = buffer;
02337 ld.buflen = buflen;
02338 st = gx_call(handle, PR_CALL_PRAPI_LOADDOCUMENTFROMMEM, &ld);
02339 if(pdoc) *pdoc = ld.doc;
02340 return st;
02341 }
02342
02362 inline int pr_getocr(gxHANDLE handle, int page, int light, int type, gxVARIANT *doc,
02363 gxVARIANT ocrparams GX_DEFARG(0)) {
02364 struct PR_PARM_PRAPI_GETOCR_V gd;
02365 int ret;
02366 assert(doc);
02367 gd.page = page;
02368 gd.light = light;
02369 gd.type = type;
02370 gd.params = ocrparams;
02371 ret = gx_call(handle, PR_CALL_PRAPI_GETOCR_V, &gd);
02372 *doc = gd.doc;
02373 return ret;
02374 }
02375
02390 inline int pr_getmrz(gxHANDLE handle,int page,int light,int type,gxVARIANT *doc) {
02391 struct PR_PARM_PRAPI_GETMRZ_V gd;
02392 int ret;
02393 assert(doc);
02394 gd.page = page;
02395 gd.light = light;
02396 gd.type = type;
02397 ret = gx_call(handle, PR_CALL_PRAPI_GETMRZ_V, &gd);
02398 *doc = gd.doc;
02399 return ret;
02400 }
02401
02419 inline int pr_getbarcode(gxHANDLE handle,int page,int light,int type,int bctype,int index,gxVARIANT *doc) {
02420 struct PR_PARM_PRAPI_GETBARCODE_V gbc;
02421 int ret;
02422 assert(doc);
02423 gbc.page=page;
02424 gbc.light=light;
02425 gbc.type=type;
02426 gbc.bctype=bctype;
02427 gbc.index=index;
02428 ret = gx_call(handle, PR_CALL_PRAPI_GETBARCODE_V, &gbc);
02429 *doc = gbc.doc;
02430 return ret;
02431 }
02432
02446 inline int pr_getdocumentrect(gxHANDLE handle,int page,int light,int type,gxVARIANT *doc) {
02447 struct PR_PARM_PRAPI_GETDOCUMENTRECT_V gd;
02448 int ret;
02449 assert(doc);
02450 gd.page = page;
02451 gd.light = light;
02452 gd.type = type;
02453 ret = gx_call(handle, PR_CALL_PRAPI_GETDOCUMENTRECT_V, &gd);
02454 *doc = gd.doc;
02455 return ret;
02456 }
02457
02468 inline int pr_recognize(gxHANDLE handle,int page,gxVARIANT *doc) {
02469 struct PR_PARM_PRAPI_RECOGNIZE_V gd;
02470 int ret;
02471 assert(doc);
02472 gd.page = page;
02473 ret = gx_call(handle, PR_CALL_PRAPI_RECOGNIZE_V, &gd);
02474 *doc = gd.doc;
02475 return ret;
02476 }
02477
02487 inline int pr_analyze(gxHANDLE handle, gxVARIANT page, int tasklen, int *task, gxVARIANT *doc) {
02488 struct PR_PARM_PRAPI_ANALYZE an;
02489 int ret;
02490 assert(doc);
02491 an.page = page;
02492 an.takslen = tasklen;
02493 an.task = task;
02494 ret = gx_call(handle, PR_CALL_PRAPI_ANALYZE, &an);
02495 if(ret) {
02496 *doc = an.doc;
02497 }
02498 return ret;
02499 }
02500
02509 inline int pr_analyzed(gxHANDLE handle, gxu8 *buffer, int buflen, gxVARIANT *doc) {
02510 struct PR_PARM_PRAPI_ANALYZED an;
02511 int ret;
02512 assert(doc);
02513 an.buffer = buffer;
02514 an.buflen = buflen;
02515 ret = gx_call(handle, PR_CALL_PRAPI_ANALYZED, &an);
02516 if(ret) {
02517 *doc = an.doc;
02518 }
02519 return ret;
02520 }
02521
02522 #ifdef __cplusplus
02523
02531 inline int pr_analyze(gxHANDLE handle, gxu8 *buffer, int buflen, gxVARIANT *doc) {
02532 return pr_analyzed(handle, buffer, buflen, doc);
02533 }
02534 #endif
02535
02546 inline int pr_resolvemrztext(gxHANDLE handle,const wchar_t **lines,int nlines,gxVARIANT *doc) {
02547 struct PR_PARM_PRAPI_RESOLVEMRZTEXT_V rt;
02548 int ret;
02549 assert(doc);
02550 rt.lines = lines;
02551 rt.nlines = nlines;
02552 ret = gx_call(handle, PR_CALL_PRAPI_RESOLVEMRZTEXT_V, &rt);
02553 *doc = rt.doc;
02554 return ret;
02555 }
02556
02567 inline int pr_resolvemrztexta(gxHANDLE handle,const char **lines,int nlines,gxVARIANT *doc) {
02568 struct PR_PARM_PRAPI_RESOLVEMRZTEXTA_V rt;
02569 int ret;
02570 assert(doc);
02571 rt.lines = lines;
02572 rt.nlines = nlines;
02573 ret = gx_call(handle, PR_CALL_PRAPI_RESOLVEMRZTEXTA_V, &rt);
02574 *doc = rt.doc;
02575 return ret;
02576 }
02577
02578 #ifdef __cplusplus
02579
02589 inline int pr_resolvemrztext(gxHANDLE handle,const char **lines,int nlines,gxVARIANT *doc) {
02590 return pr_resolvemrztexta(handle,lines,nlines,doc);
02591 }
02592 #endif
02593
02604 inline int pr_getdocumentstatus(gxHANDLE handle,gxVARIANT doc,int *code,int *status) {
02605 struct PR_PARM_PRAPI_GETDOCUMENTSTATUS_V gds;
02606 int ret;
02607 gds.doc = doc;
02608 ret = gx_call(handle, PR_CALL_PRAPI_GETDOCUMENTSTATUS_V, &gds);
02609 if (code) *code = gds.code;
02610 if (status) *status = gds.status;
02611 return ret;
02612 }
02613
02625 inline int pr_getfieldfromdoc(gxHANDLE handle, gxVARIANT doc, int field_code, int index, gxVARIANT *field) {
02626 struct PR_PARM_PRAPI_GETFIELDFROMDOC_V gfd;
02627 int ret;
02628 assert(field);
02629 gfd.doc = doc;
02630 gfd.field_code = field_code;
02631 gfd.index = index;
02632 ret = gx_call(handle, PR_CALL_PRAPI_GETFIELDFROMDOC_V, &gfd);
02633 if(field) *field = gfd.field;
02634 return ret;
02635 }
02636
02637 #ifndef GX_DOTNET
02638
02653 inline int pr_getfieldfromdocw(gxHANDLE handle, gxVARIANT doc, int field_code, wchar_t *text, int *stext,
02654 int *status, gxPG4 *frame) {
02655 int ret = true;
02656 int s, t = 0;
02657 gxVARIANT field;
02658 if(!stext) stext = &t;
02659
02660 assert((!text && !*stext) || (text && *stext>0));
02661
02662 if(text && *stext>0) text[0] = 0;
02663 if(status) *status = -1;
02664 if(frame) memset(frame, 0, sizeof(gxPG4));
02665 if(!pr_getfieldfromdoc(handle, doc, field_code, 0, &field)) {
02666 if(gx_geterrorcode()==GX_ENOENT) {
02667 *stext = 0;
02668 return true;
02669 }
02670 return false;
02671 }
02672
02673 if(text && !gx_convertvariantchild(field, (int)PRV_FIELDVALUE, 0, GX_VARIANT_UNICODE, stext,0, text, *stext)) {
02674 if(gx_geterrorcode()==GX_ENOENT) {
02675 *stext = 0;
02676 }
02677 else ret = false;
02678 }
02679 s = sizeof(int);
02680 if(status && !gx_convertvariantchild(field, (int)PRV_CHECKSUM, 0, GX_VARIANT_INT, &s, 0, status, s)) {
02681 if(gx_geterrorcode()!=GX_ENOENT) ret = false;
02682 }
02683 s = sizeof(int); t = 8;
02684 if(frame && !gx_convertvariantchild(field, (int)PRV_WINDOWFRAME, 0, GX_VARIANT_INTARRAY, &s, &t, frame, 8*s)) {
02685 if(gx_geterrorcode()!=GX_ENOENT) ret = false;
02686 }
02687 if(!ret) gx_pusherror();
02688 gx_disposevariant(&field);
02689 if(!ret) gx_poperror();
02690 return ret;
02691 }
02692
02693 #ifdef __cplusplus
02694
02710 inline int pr_getfieldfromdoc(gxHANDLE handle, gxVARIANT doc, int field_code, wchar_t *text, int *stext,
02711 int *status, gxPG4 *frame) {
02712 return pr_getfieldfromdocw(handle, doc, field_code, text, stext, status, frame);
02713 }
02714
02729 inline int pr_getfieldfromdoc(gxHANDLE handle, const gxVARIANT doc, int field_code, wchar_t *text, int stext,
02730 int *status, gxPG4 *frame) {
02731 return pr_getfieldfromdocw(handle, doc, field_code, text, &stext, status, frame);
02732 }
02733
02734 #endif
02735
02751 inline int pr_getfieldfromdoca(gxHANDLE handle, gxVARIANT doc, int field_code, char *text, int *stext,
02752 int *status, gxPG4 *frame) {
02753 int ret = true;
02754 int s, t = 0;
02755 gxVARIANT field;
02756 if(!stext) stext = &t;
02757
02758 assert((!text && !*stext) || (text && *stext>0));
02759
02760 if(text && *stext>0) text[0] = 0;
02761 if(status) *status = -1;
02762 if(frame) memset(frame, 0, sizeof(gxPG4));
02763 if(!pr_getfieldfromdoc(handle, doc, field_code, 0, &field)) {
02764 if(gx_geterrorcode()==GX_ENOENT) {
02765 *stext = 0;
02766 return true;
02767 }
02768 return false;
02769 }
02770
02771 if(text && !gx_convertvariantchild(field, (int)PRV_FIELDVALUE, 0, GX_VARIANT_ASCII, stext, 0, text, *stext)) {
02772 if(gx_geterrorcode()==GX_ENOENT) {
02773 *stext = 0;
02774 }
02775 else ret = false;
02776 }
02777 s = sizeof(int);
02778 if(status && !gx_convertvariantchild(field, (int)PRV_CHECKSUM, 0, GX_VARIANT_INT, &s, 0, status, s)) {
02779 if(gx_geterrorcode()!=GX_ENOENT) ret = false;
02780 }
02781 s = sizeof(int); t = 8;
02782 if(frame && !gx_convertvariantchild(field, (int)PRV_WINDOWFRAME, 0, GX_VARIANT_INTARRAY, &s, &t, frame, 8*s)) {
02783 if(gx_geterrorcode()!=GX_ENOENT) ret = false;
02784 }
02785 if(!ret) gx_pusherror();
02786 gx_disposevariant(&field);
02787 if(!ret) gx_poperror();
02788 return ret;
02789 }
02790
02791 #ifdef __cplusplus
02792
02808 inline int pr_getfieldfromdoc(gxHANDLE handle, gxVARIANT doc, int field_code, char *text, int *stext,
02809 int *status, gxPG4 *frame) {
02810 return pr_getfieldfromdoca(handle, doc, field_code, text, stext, status, frame);
02811 }
02812
02827 inline int pr_getfieldfromdoc(gxHANDLE handle, gxVARIANT doc, int field_code, char *text, int stext,
02828 int *status, gxPG4 *frame) {
02829 return pr_getfieldfromdoc(handle, doc, field_code, text, &stext, status, frame);
02830 }
02831
02832 #endif
02833
02849 inline int pr_getfieldfromdocb(gxHANDLE handle, gxVARIANT doc, int field_code, void *data, int *sdata,
02850 int *status, gxPG4 *frame) {
02851 int ret = true;
02852 int s, t = 0;
02853 gxVARIANT field;
02854 if(!sdata) sdata = &t;
02855
02856 assert((!data && !*sdata) || (data && *sdata>0));
02857
02858 if(status) *status = -1;
02859 if(frame) memset(frame, 0, sizeof(gxPG4));
02860 if(!pr_getfieldfromdoc(handle, doc,field_code, 0, &field)) {
02861 if(gx_geterrorcode()==GX_ENOENT) {
02862 *sdata = 0;
02863 return true;
02864 }
02865 return false;
02866 }
02867
02868 if(data && !gx_convertvariantchild(field, (int)PRV_FIELDVALUE, 0, GX_VARIANT_BINARY, sdata, 0, data, *sdata)) {
02869 if(gx_geterrorcode()==GX_ENOENT) {
02870 *sdata = 0;
02871 }
02872 else ret = false;
02873 }
02874 s = sizeof(int);
02875 if(status && !gx_convertvariantchild(field, (int)PRV_CHECKSUM, 0, GX_VARIANT_INT, &s, 0, status, s)) {
02876 if(gx_geterrorcode()!=GX_ENOENT) ret = false;
02877 }
02878 s = sizeof(int); t = 8;
02879 if(frame && !gx_convertvariantchild(field, (int)PRV_WINDOWFRAME, 0, GX_VARIANT_INTARRAY, &s, &t, frame, 8*s)) {
02880 if(gx_geterrorcode()!=GX_ENOENT) ret = false;
02881 }
02882 if(!ret) gx_pusherror();
02883 gx_disposevariant(&field);
02884 if(!ret) gx_poperror();
02885 return ret;
02886 }
02887
02888 #ifdef __cplusplus
02889
02905 inline int pr_getfieldfromdoc(gxHANDLE handle, gxVARIANT doc, int field_code, void *data, int *sdata,
02906 int *status, gxPG4 *frame) {
02907 return pr_getfieldfromdocb(handle, doc, field_code, data, sdata, status, frame);
02908 }
02909
02924 inline int pr_getfieldfromdoc(gxHANDLE handle, gxVARIANT doc, int field_code, void *data, int sdata,
02925 int *status, gxPG4 *frame) {
02926 return pr_getfieldfromdoc(handle, doc, field_code, data, &sdata, status, frame);
02927 }
02928
02929 #endif
02930 #endif
02931
02942 inline int pr_getfieldimage(gxHANDLE handle,gxVARIANT doc,int field_code,int index,gxVARIANT *img) {
02943 struct PR_PARM_PRAPI_GETFIELDIMAGE_V parm;
02944 int ret;
02945 assert(img);
02946 parm.doc = doc;
02947 parm.field_code = field_code;
02948 parm.index = index;
02949 ret = gx_call(handle, PR_CALL_PRAPI_GETFIELDIMAGE_V, &parm);
02950 if (ret && img) *img = parm.img;
02951 return ret;
02952 }
02953
02963 inline int pr_getgximagefromdoc(gxHANDLE handle,gxVARIANT doc,int field_code, gxIMAGE **img) {
02964 int ret = true;
02965 gxVARIANT field;
02966 int ind=0;
02967 if(field_code>_PR_DF_RFID_FACE){
02968 ind=(field_code&0xffff)-1;
02969 field_code&=~0xffff;
02970 }
02971 if(!pr_getfieldimage(handle,doc,field_code,ind,&field)) return false;
02972 ret = gx_imagefromvariant(gx_direct(GX_CALL_GROUP_GX_IMAGE),img,field);
02973 if(!ret)gx_pusherror();
02974 gx_disposevariant(&field);
02975 if(!ret)gx_poperror();
02976 return ret;
02977 }
02978
02991 inline int pr_getpropfromdoc(gxHANDLE handle, gxVARIANT doc, int field_code, int prop_code,
02992 void *data, int *sdata, int *data_type) {
02993
02994 gxVARIANT d = doc, field = 0;
02995 int dc = 0, s = sizeof(int);
02996 int ret;
02997 assert(sdata);
02998 if(!pr_getfieldfromdoc(handle,d,field_code,0,&field)) return false;
02999
03000 if(prop_code==_PR_PROP_TYPE_RFID_FILES) dc=(int)_PRV_RFIDDIR;
03001 if(prop_code==_PR_PROP_TYPE_BARCODE_TYPE) dc=(int)_PRV_BARCODE;
03002 if(prop_code==_PR_PROP_TYPE_CONFIDENCE) dc=(int)_PRV_CONFIDENCE;
03003 ret = gx_convertvariantchild(field,dc,0,_GX_VARIANT_INT,&s,0,data,*sdata);
03004 if(!ret)gx_pusherror();
03005 gx_unrefvariant(field);
03006 if(data_type)*data_type=0x14;
03007 if(!ret)gx_poperror();
03008 return ret;
03009 }
03010
03011
03022 inline int pr_compareface(gxHANDLE handle, int page, int face_no, gxVARIANT *doc) {
03023 int ret;
03024 struct PR_PARM_PRAPI_COMPARE_FACE_V param;
03025 assert(doc);
03026 param.page = page;
03027 param.face_no = face_no;
03028 ret = gx_call(handle, PR_CALL_PRAPI_COMPARE_FACE_V, ¶m);
03029 *doc = param.doc;
03030 return ret;
03031 }
03032
03042 inline int pr_savedocument(gxHANDLE handle, gxVARIANT pdoc, const wchar_t *filename, int filetype) {
03043 struct PR_PARM_PRAPI_SAVEDOCUMENT_V sd;
03044 assert(filename);
03045 sd.doc = pdoc;
03046 sd.filename = filename;
03047 sd.filetype = filetype;
03048 return gx_call(handle,PR_CALL_PRAPI_SAVEDOCUMENT_V,&sd);
03049 }
03050
03060 inline int pr_savedocumenta(gxHANDLE handle, gxVARIANT pdoc, const char *filename, int filetype) {
03061 struct PR_PARM_PRAPI_SAVEDOCUMENTA_V sd;
03062 assert(filename);
03063 sd.doc = pdoc;
03064 sd.filename = filename;
03065 sd.filetype = filetype;
03066 return gx_call(handle,PR_CALL_PRAPI_SAVEDOCUMENTA_V,&sd);
03067 }
03068
03069 #ifdef __cplusplus
03070
03079 inline int pr_savedocument(gxHANDLE handle, gxVARIANT pdoc, const char *filename, int filetype) {
03080 return pr_savedocumenta(handle, pdoc, filename, filetype);
03081 }
03082 #endif
03083
03092 inline int pr_savedocumenttomem(gxHANDLE handle, gxVARIANT pdoc, gxu8 **buffer, int *buflen, int filetype) {
03093 struct PR_PARM_PRAPI_SAVEDOCUMENTTOMEM stm;
03094 stm.doc = pdoc;
03095 stm.filetype = filetype;
03096 stm.buffer = buffer;
03097 stm.buflen = buflen;
03098 return gx_call(handle, PR_CALL_PRAPI_SAVEDOCUMENTTOMEM, &stm);
03099 }
03100
03108 inline int pr_getdocumentroot(gxHANDLE handle, gxVARIANT *pdoc) {
03109 struct PR_PARM_PRAPI_GETDOCUMENTROOT_V gd;
03110 int st;
03111 st = gx_call(handle, PR_CALL_PRAPI_GETDOCUMENTROOT_V, &gd);
03112 if(pdoc) *pdoc = gd.doc;
03113 return st;
03114 }
03115
03128 inline int pr_decodelatentimage(gxHANDLE handle, int page, int light, int type, const wchar_t *decpar,
03129 gxVARIANT *image) {
03130 struct PR_PARM_PRAPI_DECODELATENTIMAGE dli;
03131 int st;
03132 assert(image);
03133 dli.page = page;
03134 dli.light = light;
03135 dli.type = type;
03136 dli.decpar = decpar;
03137 st = gx_call(handle, PR_CALL_PRAPI_DECODELATENTIMAGE, &dli);
03138 if(st && image) *image = dli.image;
03139 return st;
03140 }
03141
03150 inline int pr_resolvemagstripe(gxHANDLE handle, const wchar_t **tracks, int ntracks, gxVARIANT *doc) {
03151 struct PR_PARM_PRAPI_RESOLVEMAGSTRIPE rms;
03152 int ret;
03153 assert(doc);
03154 rms.tracks = tracks;
03155 rms.ntracks = ntracks;
03156 ret = gx_call(handle, PR_CALL_PRAPI_RESOLVEMAGSTRIPE, &rms);
03157 *doc = rms.doc;
03158 return ret;
03159 }
03160
03169 inline int pr_resolvemagstripea(gxHANDLE handle, const char **tracks, int ntracks, gxVARIANT *doc) {
03170 struct PR_PARM_PRAPI_RESOLVEMAGSTRIPEA rms;
03171 int ret;
03172 assert(doc);
03173 rms.tracks = tracks;
03174 rms.ntracks = ntracks;
03175 ret = gx_call(handle, PR_CALL_PRAPI_RESOLVEMAGSTRIPEA, &rms);
03176 *doc = rms.doc;
03177 return ret;
03178 }
03179
03180 #ifdef __cplusplus
03181
03189 inline int pr_resolvemagstripe(gxHANDLE handle, const char **tracks, int ntracks, gxVARIANT *doc) {
03190 return pr_resolvemagstripea(handle, tracks, ntracks, doc);
03191 }
03192 #endif
03193
03210 inline int pr_getrfidcardlist(gxHANDLE handle,wchar_t ***cards,int *ncards) {
03211 struct PR_PARM_PRAPI_GETRFIDCARDLIST gcl;
03212 int ret;
03213 assert(cards && ncards);
03214 ret = gx_call(handle, PR_CALL_PRAPI_GETRFIDCARDLIST, &gcl);
03215 *cards = gcl.cards;
03216 *ncards = gcl.ncards;
03217 return ret;
03218 }
03219
03230 inline int pr_getrfidcardlista(gxHANDLE handle,char ***cards,int *ncards) {
03231 struct PR_PARM_PRAPI_GETRFIDCARDLISTA gcl;
03232 int ret;
03233 assert(cards && ncards);
03234 ret = gx_call(handle, PR_CALL_PRAPI_GETRFIDCARDLISTA, &gcl);
03235 *cards = gcl.cards;
03236 *ncards = gcl.ncards;
03237 return ret;
03238 }
03239
03240 #ifdef __cplusplus
03241
03251 inline int pr_getrfidcardlist(gxHANDLE handle,char ***cards,int *ncards) {
03252 return pr_getrfidcardlista(handle,cards,ncards);
03253 }
03254 #endif
03255
03269 inline int pr_getrfidfile(gxHANDLE handle,const wchar_t *card,int fileid,void **data,int *sdata) {
03270 struct PR_PARM_PRAPI_GETRFIDFILE gf;
03271 int ret;
03272 assert(data && sdata);
03273 gf.card = card;
03274 gf.fileid = fileid;
03275 ret = gx_call(handle, PR_CALL_PRAPI_GETRFIDFILE, &gf);
03276 *data = gf.data;
03277 *sdata = gf.sdata;
03278 return ret;
03279 }
03280
03294 inline int pr_getrfidfilea(gxHANDLE handle,const char *card,int fileid,void **data,int *sdata) {
03295 struct PR_PARM_PRAPI_GETRFIDFILEA gf;
03296 int ret;
03297 assert(data && sdata);
03298 gf.card = card;
03299 gf.fileid = fileid;
03300 ret = gx_call(handle, PR_CALL_PRAPI_GETRFIDFILEA, &gf);
03301 *data = gf.data;
03302 *sdata = gf.sdata;
03303 return ret;
03304 }
03305
03306 #ifdef __cplusplus
03307
03320 inline int pr_getrfidfile(gxHANDLE handle,const char *card,int fileid,void **data,int *sdata) {
03321 return pr_getrfidfilea(handle,card,fileid,data,sdata);
03322 }
03323 #endif
03324
03333 inline int pr_getrfidfile_start(gxHANDLE handle, const wchar_t *card, int fileid, int *reqid) {
03334 struct PR_PARM_PRAPI_GETRFIDFILE_START param;
03335 int ret;
03336 param.card = card;
03337 param.fileid = fileid;
03338 ret = gx_call(handle, PR_CALL_PRAPI_GETRFIDFILE_START, ¶m);
03339 if(reqid) *reqid = param.reqid;
03340 return ret;
03341 }
03342
03351 inline int pr_getrfidfile_starta(gxHANDLE handle, const char *card, int fileid, int *reqid) {
03352 struct PR_PARM_PRAPI_GETRFIDFILE_STARTA param;
03353 int ret;
03354 param.card = card;
03355 param.fileid = fileid;
03356 ret = gx_call(handle, PR_CALL_PRAPI_GETRFIDFILE_STARTA, ¶m);
03357 if(reqid) *reqid = param.reqid;
03358 return ret;
03359 }
03360
03361
03362 #ifdef __cplusplus
03363
03371 inline int pr_getrfidfile_start(gxHANDLE handle,const char *card,int fileid,int *reqid) {
03372 return pr_getrfidfile_starta(handle,card,fileid,reqid);
03373 }
03374 #endif
03375
03385 inline int pr_getrfidfile_getstatus(gxHANDLE handle,int reqid,int *status) {
03386 struct PR_PARM_PRAPI_GETSTATUS stat;
03387 int ret;
03388 assert(status);
03389 stat.reqid = reqid;
03390 ret = gx_call(handle, PR_CALL_PRAPI_GETRFIDFILE_GETSTATUS, &stat);
03391 if(status) *status = stat.status;
03392 return ret;
03393 }
03394
03405 inline int pr_getrfidfile_wait(gxHANDLE handle, int reqid, void **data, int *sdata) {
03406 struct PR_PARM_PRAPI_GETRFIDFILE_WAIT param;
03407 int ret;
03408 assert(data && sdata);
03409 param.reqid = reqid;
03410 ret = gx_call(handle, PR_CALL_PRAPI_GETRFIDFILE_WAIT, ¶m);
03411 *data = param.data;
03412 *sdata = param.sdata;
03413 return ret;
03414 }
03415
03423 inline int pr_getrfidfile_stop(gxHANDLE handle) {
03424 int ret;
03425 ret = gx_call(handle, PR_CALL_PRAPI_GETRFIDFILE_STOP, 0);
03426 return ret;
03427 }
03428
03437 inline int pr_resolverfiddata(gxHANDLE handle, const void *data, int sdata, gxVARIANT *doc) {
03438 struct PR_PARM_PRAPI_RESOLVERFIDDATA_V rd;
03439 int ret;
03440 assert(doc);
03441 rd.data = data;
03442 rd.sdata = sdata;
03443 ret = gx_call(handle, PR_CALL_PRAPI_RESOLVERFIDDATA_V, &rd);
03444 *doc = rd.doc;
03445 return ret;
03446 }
03447
03457 inline int pr_getapplications(gxHANDLE handle, const wchar_t *card, int **apps, int *napps) {
03458 struct PR_PARM_PRAPI_GET_APPLICATIONS param;
03459 int ret;
03460 assert(apps && napps);
03461 param.card = card;
03462 ret = gx_call(handle, PR_CALL_PRAPI_GETAPPLICATIONS, ¶m);
03463 *apps = param.apps;
03464 *napps = param.napps;
03465 return ret;
03466 }
03467
03477 inline int pr_getapplicationsa(gxHANDLE handle, const char *card, int **apps, int *napps) {
03478 struct PR_PARM_PRAPI_GET_APPLICATIONSA param;
03479 int ret;
03480 param.card = card;
03481 ret = gx_call(handle, PR_CALL_PRAPI_GETAPPLICATIONSA, ¶m);
03482 *apps = param.apps;
03483 *napps = param.napps;
03484 return ret;
03485 }
03486
03487 #ifdef __cplusplus
03488
03497 inline int pr_getapplications(gxHANDLE handle, const char *card, int **apps, int *napps) {
03498 return pr_getapplicationsa(handle, card, apps, napps);
03499 }
03500
03501 #endif
03502
03511 inline int pr_selectapplication(gxHANDLE handle, const wchar_t *card, int application) {
03512 struct PR_PARM_PRAPI_SELECT_APPLICATION param;
03513 param.card = card;
03514 param.application = application;
03515 return gx_call(handle, PR_CALL_PRAPI_SELECT_APPLICATION, ¶m);
03516 }
03517
03526 inline int pr_selectapplicationa(gxHANDLE handle, const char *card, int application) {
03527 struct PR_PARM_PRAPI_SELECT_APPLICATIONA param;
03528 param.card = card;
03529 param.application = application;
03530 return gx_call(handle, PR_CALL_PRAPI_SELECT_APPLICATIONA, ¶m);
03531 }
03532
03533 #ifdef __cplusplus
03534
03542 inline int pr_selectapplication(gxHANDLE handle, const char *card, int application) {
03543 return pr_selectapplicationa(handle,card,application);
03544 }
03545
03546 #endif
03547
03556 inline int pr_makebac(gxHANDLE handle, const wchar_t *card, const wchar_t **lines, int nlines) {
03557 struct PR_PARM_PRAPI_MAKEBAC param;
03558 param.card = card;
03559 param.lines = lines;
03560 param.nlines = nlines;
03561 return gx_call(handle, PR_CALL_PRAPI_MAKEBAC, ¶m);
03562 }
03563
03572 inline int pr_makebaca(gxHANDLE handle, const char *card, const char **lines, int nlines) {
03573 struct PR_PARM_PRAPI_MAKEBACA param;
03574 param.card = card;
03575 param.lines = lines;
03576 param.nlines = nlines;
03577 return gx_call(handle, PR_CALL_PRAPI_MAKEBACA, ¶m);
03578 }
03579
03580 #ifdef __cplusplus
03581
03589 inline int pr_makebac(gxHANDLE handle, const char *card, const char **lines, int nlines) {
03590 return pr_makebaca(handle,card,lines,nlines);
03591 }
03592
03593 #endif
03594
03605 inline int pr_makepace(gxHANDLE handle, const wchar_t *card, const wchar_t **lines, int nlines, int PasswordType) {
03606 struct PR_PARM_PRAPI_MAKEPACE param;
03607 param.card = card;
03608 param.lines = lines;
03609 param.nlines = nlines;
03610 param.PasswordType = PasswordType;
03611 return gx_call(handle, PR_CALL_PRAPI_MAKEPACE, ¶m);
03612 }
03613
03624 inline int pr_makepacea(gxHANDLE handle, const char *card, const char **lines, int nlines, int PasswordType) {
03625 struct PR_PARM_PRAPI_MAKEPACEA param;
03626 param.card = card;
03627 param.lines = lines;
03628 param.nlines = nlines;
03629 param.PasswordType = PasswordType;
03630 return gx_call(handle, PR_CALL_PRAPI_MAKEPACEA, ¶m);
03631 }
03632
03633 #ifdef __cplusplus
03634
03644 inline int pr_makepace(gxHANDLE handle, const char *card, const char **lines, int nlines, int PasswordType) {
03645 return pr_makepacea(handle,card,lines,nlines,PasswordType);
03646 }
03647 #endif
03648
03649
03657 inline int pr_makepassiveauth(gxHANDLE handle, const wchar_t *card) {
03658 struct PR_PARM_PRAPI_RFIDCARD param;
03659 param.card = card;
03660 return gx_call(handle, PR_CALL_PRAPI_MAKEPASSIVEAUTH, ¶m);
03661 }
03662
03670 inline int pr_makepassiveautha(gxHANDLE handle, const char *card) {
03671 struct PR_PARM_PRAPI_RFIDCARDA param;
03672 param.card = card;
03673 return gx_call(handle, PR_CALL_PRAPI_MAKEPASSIVEAUTHA, ¶m);
03674 }
03675
03676 #ifdef __cplusplus
03677
03684 inline int pr_makepassiveauth(gxHANDLE handle, const char *card) {
03685 return pr_makepassiveautha(handle,card);
03686 }
03687 #endif
03688
03699 inline int pr_makeactiveauth(gxHANDLE handle, const wchar_t *card) {
03700 struct PR_PARM_PRAPI_RFIDCARD param;
03701 param.card = card;
03702 return gx_call(handle, PR_CALL_PRAPI_MAKEACTIVEAUTH, ¶m);
03703 }
03704
03715 inline int pr_makeactiveautha(gxHANDLE handle, const char *card) {
03716 struct PR_PARM_PRAPI_RFIDCARDA param;
03717 param.card = card;
03718 return gx_call(handle, PR_CALL_PRAPI_MAKEACTIVEAUTHA, ¶m);
03719 }
03720
03721 #ifdef __cplusplus
03722
03732 inline int pr_makeactiveauth(gxHANDLE handle, const char *card) {
03733 return pr_makeactiveautha(handle,card);
03734 }
03735 #endif
03736
03744 inline int pr_makechipauth(gxHANDLE handle, const wchar_t *card) {
03745 struct PR_PARM_PRAPI_RFIDCARD param;
03746 param.card = card;
03747 return gx_call(handle, PR_CALL_PRAPI_MAKECHIPAUTH, ¶m);
03748 }
03749
03757 inline int pr_makechipautha(gxHANDLE handle, const char *card) {
03758 struct PR_PARM_PRAPI_RFIDCARDA param;
03759 param.card = card;
03760 return gx_call(handle, PR_CALL_PRAPI_MAKECHIPAUTHA, ¶m);
03761 }
03762
03763 #ifdef __cplusplus
03764
03771 inline int pr_makechipauth(gxHANDLE handle, const char *card) {
03772 return pr_makechipautha(handle,card);
03773 }
03774 #endif
03775
03783 inline int pr_maketerminalauth(gxHANDLE handle, const wchar_t *card) {
03784 struct PR_PARM_PRAPI_RFIDCARD param;
03785 param.card = card;
03786 return gx_call(handle, PR_CALL_PRAPI_MAKETERMINALAUTH, ¶m);
03787 }
03788
03796 inline int pr_maketerminalautha(gxHANDLE handle, const char *card) {
03797 struct PR_PARM_PRAPI_RFIDCARDA param;
03798 param.card = card;
03799 return gx_call(handle, PR_CALL_PRAPI_MAKETERMINALAUTHA, ¶m);
03800 }
03801
03802 #ifdef __cplusplus
03803
03810 inline int pr_maketerminalauth(gxHANDLE handle, const char *card) {
03811 return pr_maketerminalautha(handle,card);
03812 }
03813 #endif
03814
03823 inline int pr_initta(gxHANDLE handle, const wchar_t *card, void **data, int *sdata) {
03824 struct PR_PARM_PRAPI_TA param;
03825 int ret;
03826 assert(data && sdata);
03827 param.card = card;
03828 ret = gx_call(handle, PR_CALL_PRAPI_INITTERMINALAUTH, ¶m);
03829 if (ret != 0) {
03830 *data = param.data;
03831 *sdata = param.sdata;
03832 }
03833 return ret;
03834 }
03835
03844 inline int pr_inittaa(gxHANDLE handle, const char *card, void **data, int *sdata) {
03845 struct PR_PARM_PRAPI_TAA param;
03846 int ret;
03847 assert(data && sdata);
03848 param.card = card;
03849 ret = gx_call(handle, PR_CALL_PRAPI_INITTERMINALAUTHA, ¶m);
03850 if (ret != 0) {
03851 *data = param.data;
03852 *sdata = param.sdata;
03853 }
03854 return ret;
03855 }
03856
03857 #ifdef __cplusplus
03858
03866 inline int pr_initta(gxHANDLE handle, const char *card, void **data, int *sdata) {
03867 return pr_inittaa(handle, card, data, sdata);
03868 }
03869 #endif
03870
03879 inline int pr_completeta(gxHANDLE handle, const wchar_t *card, const void *data, int sdata) {
03880 struct PR_PARM_PRAPI_TA param;
03881 param.card = card;
03882 param.data = (void*)data;
03883 param.sdata = sdata;
03884 return gx_call(handle, PR_CALL_PRAPI_COMPLETETERMINALAUTH, ¶m);
03885 }
03886
03895 inline int pr_completetaa(gxHANDLE handle, const char *card, const void *data, int sdata) {
03896 struct PR_PARM_PRAPI_TAA param;
03897 param.card = card;
03898 param.data = (void*)data;
03899 param.sdata = sdata;
03900 return gx_call(handle, PR_CALL_PRAPI_COMPLETETERMINALAUTHA, ¶m);
03901 }
03902
03903 #ifdef __cplusplus
03904
03912 inline int pr_completeta(gxHANDLE handle, const char *card, const void *data, int sdata) {
03913 return pr_completetaa(handle, card, data, sdata);
03914 }
03915 #endif
03916
03925 inline int pr_loadcertfile(gxHANDLE handle, const wchar_t *certificate, const wchar_t *privateKey GX_DEFARG(NULL)) {
03926 struct PR_PARM_PRAPI_LOADCERTFILE param;
03927 param.certificate = certificate;
03928 param.privateKey = privateKey;
03929 return gx_call(handle, PR_CALL_PRAPI_LOADCERTFILE, ¶m);
03930 }
03931
03940 inline int pr_loadcertfilea(gxHANDLE handle, const char *certificate, const char *privateKey GX_DEFARG(NULL)) {
03941 struct PR_PARM_PRAPI_LOADCERTFILEA param;
03942 param.certificate = certificate;
03943 param.privateKey = privateKey;
03944 return gx_call(handle, PR_CALL_PRAPI_LOADCERTFILEA, ¶m);
03945 }
03946
03947 #ifdef __cplusplus
03948
03956 inline int pr_loadcertfile(gxHANDLE handle, const char *certificate, const char *privateKey GX_DEFARG(NULL)) {
03957 return pr_loadcertfilea(handle, certificate, privateKey);
03958 }
03959
03960 #endif
03961
03969 inline int pr_loadcertfromstore(gxHANDLE handle, const wchar_t *storename) {
03970 struct PR_PARM_PRAPI_LOADCERTFROMSTORE param;
03971 param.storename = storename;
03972 return gx_call(handle, PR_CALL_PRAPI_LOADCERTFROMSTORE, ¶m);
03973 }
03974
03982 inline int pr_loadcertfromstorea(gxHANDLE handle, const char *storename) {
03983 struct PR_PARM_PRAPI_LOADCERTFROMSTOREA param;
03984 param.storename = storename;
03985 return gx_call(handle, PR_CALL_PRAPI_LOADCERTFROMSTOREA, ¶m);
03986 }
03987
03988 #ifdef __cplusplus
03989
03996 inline int pr_loadcertfromstore(gxHANDLE handle, const char *storename) {
03997 return pr_loadcertfromstorea(handle, storename);
03998 }
03999
04000 #endif
04001
04002
04013 inline int pr_loadcertfrommem(gxHANDLE handle, void *certificate_data, unsigned int certificate_length, void *privateKey_data GX_DEFARG(NULL), unsigned int privateKey_length GX_DEFARG(0)) {
04014 struct PR_PARM_PRAPI_LOADCERTFROMMEM param;
04015 param.certificate_data = certificate_data;
04016 param.certificate_length = certificate_length;
04017 param.privateKey_data = privateKey_data;
04018 param.privateKey_length = privateKey_length;
04019
04020 return gx_call(handle, PR_CALL_PRAPI_LOADCERTFROMMEM, ¶m);
04021 }
04022
04031 inline int pr_clearcertlist(gxHANDLE handle, int sel) {
04032 struct PR_PARM_PRAPI_CLEARCERTLIST ccl;
04033 ccl.sel = sel;
04034 return gx_call(handle, PR_CALL_PRAPI_CLEARCERTLIST, &ccl);
04035 }
04036
04044 inline int pr_connectrfidcard(gxHANDLE handle, const wchar_t *card) {
04045 struct PR_PARM_PRAPI_RFIDCARD param;
04046 param.card = card;
04047 return gx_call(handle, PR_CALL_PRAPI_CONNECTRFIDCARD, ¶m);
04048 }
04049
04057 inline int pr_connectrfidcarda(gxHANDLE handle, const char *card) {
04058 struct PR_PARM_PRAPI_RFIDCARDA param;
04059 param.card = card;
04060 return gx_call(handle, PR_CALL_PRAPI_CONNECTRFIDCARDA, ¶m);
04061 }
04062
04063 #ifdef __cplusplus
04064
04071 inline int pr_connectrfidcard(gxHANDLE handle, const char *card) {
04072 return pr_connectrfidcarda(handle, card);
04073 }
04074 #endif
04075
04083 inline int pr_disconnectrfidcard(gxHANDLE handle, const wchar_t *card) {
04084 struct PR_PARM_PRAPI_RFIDCARD param;
04085 param.card = card;
04086 return gx_call(handle, PR_CALL_PRAPI_DISCONNECTRFIDCARD, ¶m);
04087 }
04088
04096 inline int pr_disconnectrfidcarda(gxHANDLE handle, const char *card) {
04097 struct PR_PARM_PRAPI_RFIDCARDA param;
04098 param.card = card;
04099 return gx_call(handle, PR_CALL_PRAPI_DISCONNECTRFIDCARDA, ¶m);
04100 }
04101
04102 #ifdef __cplusplus
04103
04110 inline int pr_disconnectrfidcard(gxHANDLE handle, const char *card) {
04111 return pr_disconnectrfidcarda(handle, card);
04112 }
04113 #endif
04114
04123 inline int pr_checkrfidfilehash(gxHANDLE handle, const wchar_t *card, int fileid) {
04124 struct PR_PARM_PRAPI_CHECKRFIDFILEHASH param;
04125 param.card = card;
04126 param.fileid = fileid;
04127 return gx_call(handle, PR_CALL_PRAPI_CHECKRFIDFILEHASH, ¶m);
04128 }
04129
04138 inline int pr_checkrfidfilehasha(gxHANDLE handle, const char *card, int fileid) {
04139 struct PR_PARM_PRAPI_CHECKRFIDFILEHASHA param;
04140 param.card = card;
04141 param.fileid = fileid;
04142 return gx_call(handle, PR_CALL_PRAPI_CHECKRFIDFILEHASHA, ¶m);
04143 }
04144
04145 #ifdef __cplusplus
04146
04154 inline int pr_checkrfidfilehash(gxHANDLE handle, const char *card, int fileid) {
04155 return pr_checkrfidfilehasha(handle, card, fileid);
04156 }
04157 #endif
04158
04167 inline int pr_getrfidcardinfo(gxHANDLE handle, const wchar_t *card, gxVARIANT *cardinfo) {
04168 struct PR_PARM_PRAPI_GETRFIDCARDINFO grci;
04169 int ret;
04170 assert(cardinfo);
04171 grci.card = card;
04172 ret = gx_call(handle, PR_CALL_PRAPI_GETRFIDCARDINFO, &grci);
04173 if(ret && cardinfo) *cardinfo = grci.cardinfo;
04174 return ret;
04175 }
04176
04185 inline int pr_getrfidcardinfoa(gxHANDLE handle, const char *card, gxVARIANT *cardinfo) {
04186 struct PR_PARM_PRAPI_GETRFIDCARDINFOA grci;
04187 int ret;
04188 assert(cardinfo);
04189 grci.card = card;
04190 ret = gx_call(handle, PR_CALL_PRAPI_GETRFIDCARDINFOA, &grci);
04191 if(ret && cardinfo) *cardinfo = grci.cardinfo;
04192 return ret;
04193 }
04194
04195 #ifdef __cplusplus
04196
04204 inline int pr_getrfidcardinfo(gxHANDLE handle, const char *card, gxVARIANT *cardinfo) {
04205 return pr_getrfidcardinfoa(handle, card, cardinfo);
04206 }
04207 #endif
04208
04218 inline int pr_getcertificateid(gxHANDLE handle, const wchar_t *card,int Authentication, gxVARIANT *CertificateId) {
04219 struct PR_PARM_PRAPI_GETCERTIFICATEID cid;
04220 int ret;
04221 assert(CertificateId);
04222 cid.card = card;
04223 cid.Authentication = Authentication;
04224 ret = gx_call(handle, PR_CALL_PRAPI_GETCERTIFICATEID, &cid);
04225 if(ret && CertificateId) *CertificateId = cid.CertId;
04226 return ret;
04227 }
04228
04238 inline int pr_getcertificateida(gxHANDLE handle, const char *card, int Authentication, gxVARIANT *CertificateId) {
04239 struct PR_PARM_PRAPI_GETCERTIFICATEIDA cid;
04240 int ret;
04241 cid.card = card;
04242 cid.Authentication = Authentication;
04243 assert(CertificateId);
04244 ret = gx_call(handle, PR_CALL_PRAPI_GETCERTIFICATEIDA, &cid);
04245 if(ret && CertificateId) *CertificateId = cid.CertId;
04246 return ret;
04247 }
04248
04249 #ifdef __cplusplus
04250
04259 inline int pr_getcertificateid(gxHANDLE handle, const char *card, int Authentication, gxVARIANT *CertificateId) {
04260 return pr_getcertificateida(handle, card, Authentication, CertificateId);
04261 }
04262 #endif
04263
04264
04275 inline int pr_getnextauthentication(gxHANDLE handle, const wchar_t *card, int *Authentication, int ForceNext GX_DEFARG(false)) {
04276 struct PR_PARM_PRAPI_GETNEXTAUTHENTICATION authproc;
04277 int ret;
04278 authproc.card = card;
04279 authproc.ForceNext = ForceNext;
04280 ret = gx_call(handle, PR_CALL_PRAPI_GETNEXTAUTHENTICATION, &authproc);
04281 *Authentication = authproc.ProcessName;
04282 return ret;
04283 }
04284
04295 inline int pr_getnextauthenticationa(gxHANDLE handle, const char *card, int *Authentication, int ForceNext GX_DEFARG(false)) {
04296 struct PR_PARM_PRAPI_GETNEXTAUTHENTICATIONA authproc;
04297 int ret;
04298 authproc.card = card;
04299 authproc.ForceNext = ForceNext;
04300 ret = gx_call(handle, PR_CALL_PRAPI_GETNEXTAUTHENTICATIONA, &authproc);
04301 *Authentication = authproc.ProcessName;
04302 return ret;
04303 }
04304
04305 #ifdef __cplusplus
04306
04316 inline int pr_getnextauthentication(gxHANDLE handle, const char *card, int *Authentication, int ForceNext = false) {
04317 return pr_getnextauthenticationa(handle, card,Authentication, ForceNext);
04318 }
04319 #endif
04320
04334 inline int pr_doauthentication(gxHANDLE handle, const wchar_t *card, int Authentication, const wchar_t **AuthData GX_DEFARG(0), int Lines GX_DEFARG(0), int PasswordType GX_DEFARG(PR_PACE_PW_MRZ)) {
04335 struct PR_PARM_PRAPI_DOAUTHENTICATION params;
04336 int ret;
04337 params.card = card;
04338 params.ProcessName = Authentication;
04339 params.AuthData = AuthData;
04340 params.Lines = Lines;
04341 params.PasswordType = PasswordType;
04342 ret = gx_call(handle, PR_CALL_PRAPI_DOAUTHENTICATION, ¶ms);
04343 return ret;
04344 }
04345
04359 inline int pr_doauthenticationa(gxHANDLE handle, const char *card, int Authentication, const char **AuthData GX_DEFARG(0), int Lines GX_DEFARG(0), int PasswordType GX_DEFARG(PR_PACE_PW_MRZ)) {
04360 struct PR_PARM_PRAPI_DOAUTHENTICATIONA params;
04361 int ret;
04362 params.card = card;
04363 params.ProcessName = Authentication;
04364 params.AuthData = AuthData;
04365 params.Lines = Lines;
04366 params.PasswordType = PasswordType;
04367 ret = gx_call(handle, PR_CALL_PRAPI_DOAUTHENTICATIONA, ¶ms);
04368 return ret;
04369 }
04370
04371 #ifdef __cplusplus
04372
04385 inline int pr_doauthentication(gxHANDLE handle, const char *card, int Authentication, const char **AuthData GX_DEFARG(0), int Lines GX_DEFARG(0), int PasswordType GX_DEFARG(PR_PACE_PW_MRZ)) {
04386 return pr_doauthenticationa(handle, card,Authentication, AuthData, Lines, PasswordType);
04387 }
04388 #endif
04389
04390
04393 #endif
04394
04395 #ifdef GX_DOTNET
04396 #pragma managed
04397 #undef gxPG4
04398 #endif
04399
04400
04401 #if !defined(NO_GX_CLASSES)
04402
04410 GX_CLASS prDoc : public gxHandle
04411 #ifdef GX_DOTNET
04412 ,public System::IDisposable
04413 #endif
04414 {
04415
04416 inline prDoc() {}
04417 inline prDoc(prDoc &src) {}
04418 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
04419 inline prDoc& operator= (prDoc ) { return *this; }
04420 #endif
04421
04422 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL)
04423 protected:
04424
04425 gxVARIANT doc;
04426
04427 #endif
04428
04429 public:
04430
04432 inline ~prDoc() throw(gxError) {
04433 Free();
04434 }
04435
04437 inline void Dispose(void) {
04438 #ifdef GX_DOTNET
04439 System::GC::SuppressFinalize(this);
04440 #endif
04441 Free();
04442 gxHandle::Dispose();
04443 }
04444
04445 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL)
04446 #ifndef GX_DOTNET
04447
04451 inline operator gxVARIANT () GX_CONST {
04452 return doc;
04453 }
04454 #else
04455 private public:
04456 #endif
04457
04462 inline prDoc(gxVARIANT src, gxHANDLE h) throw(gxError) {
04463 doc = 0;
04464 if(!gx_refhandle(h)) { gxthrow; return; }
04465 #ifdef GX_DOTNET
04466 _set_handle(h.handle);
04467 #else
04468 handle = h.handle;
04469 #endif
04470 if(src && !gx_refvariant(src)) {
04471 gx_pusherror();
04472 gx_unrefhandle(&h);
04473 #ifdef GX_DOTNET
04474 _handle = 0;
04475 #else
04476 handle = 0;
04477 #endif
04478 gx_poperror();
04479 gxthrow;
04480 return;
04481 }
04482 doc = src;
04483 }
04484 public:
04485
04486 #endif
04487
04493 inline bool Copy(prDoc &src) throw(gxError) {
04494 gxVARIANT d = doc;
04495 if(d) {
04496 if(!gx_unrefvariant(d)) {
04497 gxthrow;
04498 return false;
04499 }
04500 }
04501 #ifndef GX_DOTNET
04502 bool st = gx_duplicatevariant(&d,src)!=0;
04503 #else
04504 bool st = gx_duplicatevariant(&d,src.doc)!=0;
04505 #endif
04506 if(!st){
04507 gxthrow;
04508 return false;
04509 }
04510 doc = d;
04511 return true;
04512 }
04513
04518 inline bool Free(void) throw(gxError) {
04519 gxVARIANT d = doc;
04520 if(d) {
04521 if(!gx_unrefvariant(d)) {
04522 gxthrow;
04523 return false;
04524 }
04525 doc = 0;
04526 }
04527 return true;
04528 }
04529
04533 inline gxVariant * ToVariant() throw(gxError) {
04534 gxVARIANT d = doc;
04535 if(!d) {
04536 gxSystem::ClearError();
04537 return 0;
04538 }
04539 #ifndef GX_DOTNET
04540 gxVariant * vr = new gxVariant(d);
04541 #else
04542 gxVariant * vr = new gxVariant();
04543 vr->_set_variant(d);
04544 gx_refvariant(d);
04545 #endif
04546 if(!vr){gxSystem::SetError(GXEC GX_ENOMEM);gxthrow;}
04547 return vr;
04548 }
04549
04557 inline prDoc * GetDocPart(int ix) throw(gxError) {
04558 gxVARIANT task;
04559 prDoc *cdoc = 0;
04560 char path[50];
04561 gx_snprintf(path, 50, "C,D=%i/L,X=%i", PRV_TASKLIST, ix);
04562 if(!gx_getvariantbypath(doc, path, &task)) {
04563 gxthrow;
04564 return cdoc;
04565 }
04566
04567 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
04568 if(task) {
04569 cdoc = new prDoc(task, *this);
04570 gx_unrefvariant(task);
04571 if(!cdoc) { gxSystem::SetError(GX_ENOMEM); gxthrow; }
04572 }
04573 #else
04574 GX_GETHANDLE(h);
04575 cdoc = new prDoc(task, h);
04576 if(task) gx_unrefvariant(task);
04577 if(!cdoc) { gxSystem::SetError(GX_ENOMEM); gxthrow; }
04578 #endif
04579 if(!task) gxSystem::ClearError();
04580 return cdoc;
04581 }
04582
04590 inline int Code(void) GX_CONST throw(gxError) {
04591 int code = -1;
04592 GX_GETHANDLE(h);
04593 gxVARIANT d = doc;
04594 if(!pr_getdocumentstatus(h,d,&code,0)) gxthrow;
04595 return code;
04596 }
04597
04606 inline int Status(void) GX_CONST throw(gxError) {
04607 int status = -1;
04608 GX_GETHANDLE(h);
04609 gxVARIANT d = doc;
04610 if(!pr_getdocumentstatus(h,d,0,&status)) gxthrow;
04611 return status;
04612 }
04613
04614 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
04615
04625 inline bool Field(int field_code, char *text, int stext, int index GX_DEFARG(0)) GX_CONST throw(gxError) {
04626 gxassert(text && stext>0);
04627 return Field(field_code, text, &stext, index);
04628 }
04629
04641 inline bool Field(int field_code, char *text, int *stext, int index GX_DEFARG(0)) GX_CONST throw(gxError) {
04642 gxassert(text && stext && *stext>0);
04643 gxVARIANT field=0;
04644 if(field_code>_PR_DF_RFID_FACE) {
04645 if(field_code&0xffff) index += (field_code&0xffff)-1;
04646 field_code &= ~0xffff;
04647 }
04648 if(!pr_getfieldfromdoc(*this, doc, field_code, index, &field)) {
04649 if(gx_geterror()==GX_ENOENT){
04650 if(text && *stext>0)text[0]=0;
04651 return true;
04652 }
04653 gxthrow;
04654 return false;
04655 }
04656 if(!gx_convertvariantchild(field,(int)PRV_FIELDVALUE,0,GXVT GX_VARIANT_ASCII,
04657 stext,0,text,*stext)) {
04658 if(gx_geterror()==GX_ENOENT){
04659 if(text && *stext>0)text[0]=0;
04660 gx_unrefvariant(field);
04661 return true;
04662 }
04663 gx_pusherror();
04664 gx_unrefvariant(field);
04665 gx_poperror();
04666 gxthrow;
04667 return false;
04668 }
04669 gx_unrefvariant(field);
04670 return true;
04671 }
04672
04683 inline bool Field(int field_code, wchar_t *text, int stext, int index GX_DEFARG(0)) GX_CONST throw(gxError) {
04684 gxassert(text && stext>0);
04685 return Field(field_code, text, &stext, index);
04686 }
04687
04699 inline bool Field(int field_code, wchar_t *text, int *stext, int index GX_DEFARG(0)) GX_CONST throw(gxError) {
04700 gxassert(text && stext && *stext>0);
04701 gxVARIANT field=0;
04702 if(field_code>_PR_DF_RFID_FACE) {
04703 if(field_code&0xffff) index += (field_code&0xffff)-1;
04704 field_code &= ~0xffff;
04705 }
04706 if(!pr_getfieldfromdoc(*this, doc, field_code, index, &field)) {
04707 if(gx_geterror()==GX_ENOENT){
04708 if(text && *stext>0)text[0]=0;
04709 return true;
04710 }
04711 gxthrow;
04712 return false;
04713 }
04714 if(!gx_convertvariantchild(field,(int)PRV_FIELDVALUE,0,GXVT GX_VARIANT_UNICODE,
04715 stext,0,text,*stext*sizeof(wchar_t))) {
04716 if(gx_geterror()==GX_ENOENT){
04717 if(text && *stext>0)text[0]=0;
04718 gx_unrefvariant(field);
04719 return true;
04720 }
04721 gx_pusherror();
04722 gx_unrefvariant(field);
04723 gx_poperror();
04724 gxthrow;
04725 return false;
04726 }
04727 gx_unrefvariant(field);
04728 return true;
04729 }
04730
04741 inline bool Field(int field_code, void *data, int sdata, int index GX_DEFARG(0)) GX_CONST throw(gxError) {
04742 gxassert(data && sdata>0);
04743 return Field(field_code, data, &sdata, index);
04744 }
04745
04757 inline bool Field(int field_code, void *data, int *sdata, int index GX_DEFARG(0)) GX_CONST throw(gxError) {
04758 gxassert(data && sdata && *sdata>0);
04759 gxVARIANT field=0;
04760 if(field_code>_PR_DF_RFID_FACE) {
04761 if(field_code&0xffff) index += (field_code&0xffff)-1;
04762 field_code &= ~0xffff;
04763 }
04764 if(!pr_getfieldfromdoc(*this, doc, field_code, index, &field)) {
04765 if(gx_geterror()==GX_ENOENT){
04766 return true;
04767 }
04768 gxthrow;
04769 return false;
04770 }
04771 if(!gx_convertvariantchild(field,(int)PRV_FIELDVALUE,0,GXVT GX_VARIANT_BINARY,
04772 sdata,0,data,*sdata)) {
04773 if(gx_geterror()==GX_ENOENT){
04774 gx_unrefvariant(field);
04775 return true;
04776 }
04777 gx_pusherror();
04778 gx_unrefvariant(field);
04779 gx_poperror();
04780 gxthrow;
04781 return false;
04782 }
04783 gx_unrefvariant(field);
04784 return true;
04785 }
04786
04787 #endif
04788
04795 inline gxImage * FieldImage(int field_code) GX_CONST throw(gxError) {
04796 int index = 0;
04797 if(field_code>_PR_DF_RFID_FACE) {
04798 if(field_code&0xffff) index = (field_code&0xffff)-1;
04799 field_code &= ~0xffff;
04800 }
04801 return FieldImage(field_code, index);
04802 }
04803
04812 inline gxImage * FieldImage(int field_code, int index) GX_CONST throw(gxError) {
04813 gxVARIANT vimg = 0;
04814 gxIMAGE *img = 0;
04815 gxImage *cimg = 0;
04816 GX_GETHANDLE(h);
04817 gxVARIANT d = doc;
04818
04819 if(!pr_getfieldimage(h, d, field_code, index ,&vimg)) {
04820 if(gx_geterror()!=GX_ENOENT){
04821 gxthrow;
04822 return cimg;
04823 }
04824 }
04825 bool ret = true;
04826 if(vimg) {
04827 ret = gx_imagefromvariant(&img,vimg)!=0;
04828 if(!ret)gx_pusherror();
04829 gx_unrefvariant(vimg);
04830 if(!ret){
04831 gx_poperror();
04832 gxthrow;
04833 return cimg;
04834 }
04835 }
04836
04837 if(img){
04838 #ifndef GX_DOTNET
04839 cimg = new gxImage(*img);
04840 gx_unrefimage(img);
04841 if(!cimg){gxSystem::SetError(GX_ENOMEM);gxthrow;}
04842 #else
04843 cimg = new gxImage();
04844 if(!cimg){gxSystem::SetError(GX_ENOMEM);gxthrow;}
04845 else cimg->_set_image(img);
04846 #endif
04847 }
04848 else gxSystem::ClearError();
04849 return cimg;
04850 }
04851
04852 #ifdef GX_UNICODE
04853
04859 inline gxOutStr Field(int field_code) GX_CONST throw(gxError) {
04860 return Field(field_code, 0);
04861 }
04862
04871 inline gxOutStr Field(int field_code, int index) GX_CONST throw(gxError) {
04872 wchar_t fieldbuf[GX_MAXLEN_STRING+1];
04873 GX_GETHANDLE(h);
04874 gxVARIANT d = doc;
04875 gxVARIANT field=0;
04876 if(!pr_getfieldfromdoc(h, d, field_code, index, &field)) {
04877 if(gx_geterror()==GX_ENOENT){
04878 fieldbuf[0]=0;
04879 return GX_PUTSTRING(fieldbuf);
04880 }
04881 gxthrow;
04882 return GX_PUTSTRING_NONE;
04883 }
04884 int s=GX_MAXLEN_STRING;
04885 if(!gx_convertvariantchild(field,(int)PRV_FIELDVALUE,0,GXVT GX_VARIANT_UNICODE,
04886 &s,0,fieldbuf,s*sizeof(wchar_t))) {
04887 if(gx_geterror()==GX_ENOENT){
04888 fieldbuf[0]=0;
04889 gx_unrefvariant(field);
04890 return GX_PUTSTRING(fieldbuf);
04891 }
04892 gx_pusherror();
04893 gx_unrefvariant(field);
04894 gx_poperror();
04895 gxthrow;
04896 return GX_PUTSTRING_NONE;
04897 }
04898 gx_unrefvariant(field);
04899 fieldbuf[GX_MAXLEN_STRING] = 0;
04900 return GX_PUTSTRING(fieldbuf);
04901 }
04902 #endif
04903
04904 #ifdef GX_ASCII
04905
04911 inline gxOutAStr FieldA(int field_code) GX_CONST throw(gxError) {
04912 return FieldA(field_code, 0);
04913 }
04914
04923 inline gxOutAStr FieldA(int field_code, int index) GX_CONST throw(gxError) {
04924 char fieldbuf[GX_MAXLEN_STRING+1];
04925 GX_GETHANDLE(h);
04926 gxVARIANT d = doc;
04927 gxVARIANT field=0;
04928 if(!pr_getfieldfromdoc(h, d, field_code, index, &field)) {
04929 if(gx_geterror()==GX_ENOENT){
04930 fieldbuf[0]=0;
04931 return GX_PUTASTRING(fieldbuf);
04932 }
04933 gxthrow;
04934 return GX_PUTASTRING_NONE;
04935 }
04936 int s=GX_MAXLEN_STRING;
04937 if(!gx_convertvariantchild(field,(int)PRV_FIELDVALUE,0,GXVT GX_VARIANT_ASCII,
04938 &s,0,fieldbuf,s)) {
04939 if(gx_geterror()==GX_ENOENT){
04940 fieldbuf[0]=0;
04941 gx_unrefvariant(field);
04942 return GX_PUTASTRING(fieldbuf);
04943 }
04944 gx_pusherror();
04945 gx_unrefvariant(field);
04946 gx_poperror();
04947 gxthrow;
04948 return GX_PUTASTRING_NONE;
04949 }
04950 gx_unrefvariant(field);
04951 fieldbuf[GX_MAXLEN_STRING] = 0;
04952 return GX_PUTASTRING(fieldbuf);
04953 }
04954 #endif
04955
04956 #if defined(GX_SWIG) || defined(GX_DOTNET)
04957
04965 inline gxOutData FieldB(int field_code, int index) GX_CONST throw(gxError) {
04966 GX_GETHANDLE(h);
04967 gxVARIANT d = doc;
04968 gxVARIANT field, data = 0;
04969 if(!pr_getfieldfromdoc(h, d, field_code, index, &field)) {
04970 if(gx_geterror()!=GX_ENOENT) {
04971 gxthrow;
04972 }
04973 return GX_PUTDATA_NONE;
04974 }
04975 int id = PRV_FIELDVALUE;
04976 if(!gx_getvariantchild(field, GXVF GX_VARIANT_BY_ID, &id, 0, &data)) {
04977 gx_pusherror();
04978 gx_unrefvariant(field);
04979 gx_poperror();
04980 if(gx_geterror()!=GX_ENOENT) {
04981 gxthrow;
04982 }
04983 return GX_PUTDATA_NONE;
04984 }
04985 gx_disposevariant(&field);
04986
04987 int size = 0;
04988 gxu8 *fieldbuf = 0;
04989 int ret = 0;
04990 if(gx_getvariant(data, 0, 0, &size, 0, 0)) {
04991 fieldbuf = new gxu8[size];
04992 if(!fieldbuf) gx_seterror(GX_ENOENT);
04993 else if(gx_convertvariant(data, 0, GXVT GX_VARIANT_BINARY, &size, 0, fieldbuf, size))
04994 ret = 1;
04995 }
04996
04997 if(!ret) gx_pusherror();
04998 gx_unrefvariant(data);
04999 if(!ret) {
05000 delete [] fieldbuf;
05001 gx_poperror();
05002 gxthrow;
05003 return GX_PUTDATA_NONE;
05004 }
05005
05006 gxOutData od = GX_PUTDATA(fieldbuf, size);
05007 delete [] fieldbuf;
05008 return od;
05009 }
05010 #endif
05011
05020 inline gxVariant * FieldV(int field_code, int index) GX_CONST throw(gxError) {
05021 GX_GETHANDLE(h);
05022 gxVARIANT d = doc;
05023 gxVARIANT field=0;
05024 if(!pr_getfieldfromdoc(h, d, field_code, index, &field)) {
05025 gxthrow;
05026 return 0;
05027 }
05028 #ifndef GX_DOTNET
05029 gxVariant * vr = new gxVariant(field);
05030 gx_unrefvariant(field);
05031 #else
05032 gxVariant * vr = new gxVariant();
05033 vr->_set_variant(field);
05034 #endif
05035 if(!vr){gxSystem::SetError(GX_ENOMEM);gxthrow;}
05036 return vr;
05037 }
05038
05048 inline int FieldStatus(int field_code) GX_CONST throw(gxError) {
05049 return FieldStatus(field_code, 0);
05050 }
05051
05063 inline int FieldStatus(int field_code, int index) GX_CONST throw(gxError) {
05064 int status = -1;
05065 GX_GETHANDLE(h);
05066 gxVARIANT d = doc;
05067 gxVARIANT field=0;
05068 if(!pr_getfieldfromdoc(h, d, field_code, index, &field)) {
05069 if(gx_geterror()==GX_ENOENT){
05070 return 1;
05071 }
05072 gxthrow;
05073 return -1;
05074 }
05075 int s=4;
05076 if(!gx_convertvariantchild(field,(int)PRV_CHECKSUM,0,GXVT GX_VARIANT_INT,
05077 &s,0,&status,s)) {
05078 if(gx_geterror()==GX_ENOENT){
05079 gx_unrefvariant(field);
05080 return 1;
05081 }
05082 gx_pusherror();
05083 gx_unrefvariant(field);
05084 gx_poperror();
05085 gxthrow;
05086 return -1;
05087 }
05088 gx_unrefvariant(field);
05089 return status;
05090 }
05091
05092 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
05093
05103 inline bool Prop(int field_code, int prop_code, void* data, int *sdata, int *data_type) GX_CONST throw(gxError) {
05104 GX_GETHANDLE(h);
05105 gxVARIANT d = doc;
05106 bool st = pr_getpropfromdoc(h,d,field_code, prop_code, data, sdata, data_type) != 0;
05107 gxcondthrow(!st);
05108 return st;
05109 }
05110 #else
05111
05117 inline gxOutData PropB(int field_code, int prop_code) GX_CONST throw(gxError) {
05118 const int sdata = 200*1024;
05119 char data[sdata];
05120 int data_type;
05121 int size = sdata;
05122 GX_GETHANDLE(h);
05123 gxVARIANT d = doc;
05124 if(!pr_getpropfromdoc(h,d,field_code, prop_code, data, &size, &data_type)) {
05125 gxthrow;
05126 return GX_PUTDATA_NONE;
05127 }
05128 return GX_PUTDATA(data, size);
05129 }
05130 #endif
05131
05138 inline int PropI32(int field_code, int prop_code) GX_CONST throw(gxError) {
05139 int data;
05140 int sdata = 4;
05141 int data_type;
05142 GX_GETHANDLE(h);
05143 gxVARIANT d = doc;
05144 bool st = pr_getpropfromdoc(h,d,field_code, prop_code, &data, &sdata, &data_type) != 0;
05145 gxcondthrow(!st);
05146 return st?data:0;
05147 }
05148
05156 inline int PropType(int field_code, int prop_code) GX_CONST throw(gxError) {
05157 int data_type;
05158 int sdata;
05159 GX_GETHANDLE(h);
05160 gxVARIANT d = doc;
05161 bool st = pr_getpropfromdoc(h,d,field_code, prop_code, 0, &sdata, &data_type) != 0;
05162 gxcondthrow(!st);
05163 return st ? 0 : data_type;
05164 }
05165
05170 inline bool IsValid(void) GX_CONST {
05171 if(!gxHandle::IsValid())return false;
05172 return doc != 0 ? true : false;
05173 }
05174
05175 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
05176
05183 inline bool Save(const wchar_t *filename, int filetype = PR_DFF_ZIPPED) GX_CONST throw(gxError) {
05184 bool st = pr_savedocument(*this,doc,filename,filetype)!=0;
05185 gxcondthrow(!st);
05186 return st;
05187 }
05188
05196 inline bool Save(const char *filename, int filetype = PR_DFF_ZIPPED) GX_CONST throw(gxError) {
05197 bool st = pr_savedocument(*this,doc,filename,filetype)!=0;
05198 gxcondthrow(!st);
05199 return st;
05200 }
05201
05210 inline bool SaveToMem(gxu8 **buffer, int *buflen, int filetype = PR_DFF_XML) GX_CONST throw(gxError) {
05211 bool st = pr_savedocumenttomem(*this, doc, buffer, buflen, filetype)!=0;
05212 gxcondthrow(!st);
05213 return st;
05214 }
05215 #endif
05216
05217 #ifdef GX_UNICODE
05218
05225 inline bool Save(gxInStr filename, int filetype GX_DEFARG(PR_DFF_ZIPPED)) GX_CONST throw(gxError) {
05226 GX_GETHANDLE(h);
05227 gxVARIANT d = doc;
05228 GX_GETSTRING(_filename, filename);
05229 bool st = pr_savedocument(h,d,_filename,filetype)!=0;
05230 gxcondthrow(!st);
05231 return st;
05232 }
05233 #endif
05234
05235 #ifdef GX_ASCII
05236
05243 inline bool Save(gxInAStr filename, int filetype GX_DEFARG(PR_DFF_ZIPPED)) GX_CONST throw(gxError) {
05244 GX_GETHANDLE(h);
05245 gxVARIANT d = doc;
05246 GX_GETASTRING(_filename, filename);
05247 bool st = pr_savedocument(h,d,_filename,filetype)!=0;
05248 gxcondthrow(!st);
05249 return st;
05250 }
05251 #endif
05252
05253 #if defined(GX_SWIG) || defined(GX_DOTNET)
05254
05259 inline gxOutData SaveToMem(int filetype GX_DEFARG(PR_DFF_XML)) GX_CONST throw(gxError) {
05260 gxu8 *buffer;
05261 int buflen;
05262 GX_GETHANDLE(h);
05263 gxVARIANT d = doc;
05264 if(!pr_savedocumenttomem(h, d, &buffer, &buflen, filetype)) {
05265 gxthrow;
05266 return GX_PUTDATA_NONE;
05267 }
05268 gxOutData ret = GX_PUTDATA(buffer, buflen);
05269 if(buffer) gx_globalfree(buffer);
05270 return ret;
05271 }
05272 #endif
05273
05274 };
05275
05278
05279
05283 GX_CLASS prImage
05284 #ifdef GX_DOTNET
05285 : public System::IDisposable
05286 #endif
05287 {
05288
05289 inline prImage() {}
05290 inline prImage(prImage & ) {}
05291 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
05292 inline prImage& operator= (prImage ) { return *this; }
05293 #endif
05294
05295 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL)
05296 private:
05297
05298 gxVARIANT image;
05299
05300 #endif
05301
05302 public:
05303
05305 inline ~prImage() throw(gxError) {
05306 Detach();
05307 }
05308
05310 inline void Dispose(void) {
05311 #ifdef GX_DOTNET
05312 System::GC::SuppressFinalize(this);
05313 #endif
05314 Detach();
05315 }
05316
05317 #if !defined(GX_SWIGIF)
05318 #ifndef GX_DOTNET
05319
05323 inline operator gxVARIANT () GX_CONST {
05324 return image;
05325 }
05326 #else
05327 private public:
05328 #endif
05329
05334 inline prImage(gxVARIANT src) throw(gxError) {
05335 image = 0;
05336 if(src && !gx_refvariant(src)) {
05337 gxthrow;
05338 return;
05339 }
05340 image = src;
05341 }
05342 public:
05343
05344 #endif
05345
05346 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
05347
05353 inline bool Attach(gxVARIANT src) throw(gxError) {
05354 if(!gx_refvariant(src)){
05355 gxthrow;
05356 return false;
05357 }
05358 if(image)
05359 if(!gx_unrefvariant(image)){
05360 gx_pusherror();
05361 gx_unrefvariant(src);
05362 gx_poperror();
05363 gxthrow;
05364 return false;
05365 }
05366 image = src;
05367 return true;
05368 }
05369 #endif
05370
05376 inline bool Attach(prImage &src) throw(gxError) {
05377 if(!gx_refvariant(src.image)) {
05378 gxthrow;
05379 return false;
05380 }
05381 if(image) {
05382 if(!gx_unrefvariant(image)) {
05383 gx_pusherror();
05384 gx_unrefvariant(src.image);
05385 gx_poperror();
05386 gxthrow;
05387 return false;
05388 }
05389 }
05390 #ifndef GX_DOTNET
05391 image = src;
05392 #else
05393 image = src.image;
05394 #endif
05395 return true;
05396 }
05397
05402 inline bool Detach(void) throw(gxError) {
05403 if(image){
05404 if(!gx_unrefvariant(image)) {
05405 gxthrow;
05406 return false;
05407 }
05408 image = 0;
05409 }
05410 return true;
05411 }
05412
05413 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
05414
05419 inline gxIMAGE* GxImage(void) const throw(gxError) {
05420 gxIMAGE *gim;
05421 gxassert(image);
05422 if(!image) return 0;
05423 if(!gx_imagefromvariant(&gim,image)){
05424 gxthrow;
05425 return 0;
05426 }
05427 return gim;
05428 }
05429
05435 inline const gxTRAFO* Trafo(void) const throw(gxError) {
05436 gxVARIANT vt;
05437 gxTRAFO *trf;
05438 gxassert(image);
05439 if(!image) return 0;
05440 if(!gx_getvariantchild(image,GX_VARIANT_BY_ID,(int)PRV_TRAFO,0,&vt)){
05441 gxthrow;
05442 return 0;
05443 }
05444 if(!gx_trafofromvariant(&trf,vt)){
05445 gx_pusherror();
05446 gx_unrefvariant(vt);
05447 gx_poperror();
05448 gxthrow;
05449 return 0;
05450 }
05451 gx_unrefvariant(vt);
05452 return trf;
05453 }
05454 #else
05455
05460 inline gxImage * GxImage(void) GX_CONST throw(gxError) {
05461 gxIMAGE *gim;
05462 gxassert(image);
05463 if(!image)return 0;
05464 if(!gx_imagefromvariant(&gim,image)){
05465 gxthrow;
05466 return 0;
05467 }
05468 gxImage *im = new gxImage();
05469 #ifndef GX_DOTNET
05470 gxtry {
05471 if(gim)im->Attach(gim);
05472 } gxcatch(...) {
05473 gx_pusherror();
05474 if(gim)gx_unrefimage(gim);
05475 delete im;
05476 gx_poperror();
05477 __gxthrow;
05478 return 0;
05479 }
05480 if(gim)gx_unrefimage(gim);
05481 #else
05482 if(gim) im->_set_image(gim);
05483 #endif
05484 return im;
05485 }
05486
05492 inline gxTrafo* Trafo(void) GX_CONST throw(gxError) {
05493 gxVARIANT vt;
05494 gxTRAFO *trf;
05495 gxassert(image);
05496 if(!image)return 0;
05497 if(!gx_getvariantchild(image,GXVF GX_VARIANT_BY_ID,(int)PRV_TRAFO,0,&vt)){
05498 gxthrow;
05499 return 0;
05500 }
05501 if(!gx_trafofromvariant(&trf,vt)){
05502 gx_pusherror();
05503 gx_unrefvariant(vt);
05504 gx_poperror();
05505 gxthrow;
05506 return 0;
05507 }
05508 gx_unrefvariant(vt);
05509 gxTrafo *tr=new gxTrafo();
05510 #ifndef GX_DOTNET
05511 gxtry {
05512 if(trf)tr->Attach(trf);
05513 } gxcatch(...) {
05514 gx_pusherror();
05515 if(trf)gx_unreftrafo(trf);
05516 delete tr;
05517 gx_poperror();
05518 __gxthrow;
05519 return 0;
05520 }
05521 if(trf)gx_unreftrafo(trf);
05522 #else
05523 tr->_set_trafo(trf);
05524 #endif
05525 return tr;
05526 }
05527 #endif
05528
05529
05535 inline int CaptureTime(void) GX_CONST throw(gxError) {
05536 int s=sizeof(gxi64);
05537 gxi64 captime;
05538 gxassert(image);
05539 if(!image) return 0;
05540 if(!gx_convertvariantchild(image,(int)PRV_CAPTIME,0,GX_VARIANT_INT,&s,0,&captime,s)) {
05541 gxthrow;
05542 return 0;
05543 }
05544 return int(captime/1000);
05545 }
05546
05552 inline int Page(void) GX_CONST throw(gxError) {
05553 int s=sizeof(int), page;
05554 gxassert(image);
05555 if(!image) return 0;
05556 if(!gx_convertvariantchild(image,(int)PRV_PAGE,0,GX_VARIANT_INT,&s,0,&page,s)) {
05557 gxthrow;
05558 return 0;
05559 }
05560 return page;
05561 }
05562
05568 inline int Page(int page) throw(gxError) {
05569 gxVARIANT vpage;
05570 gxassert(image);
05571 if(!image) return page;
05572 if(!gx_getvariantchild(image,GX_VARIANT_BY_ID,(int)PRV_PAGE,0,&vpage)) return page;
05573 if(!gx_updatevariantdata(vpage,(int)PRV_PAGE,GX_VARIANT_INT,sizeof(int),1,&page)) {
05574 gx_pusherror();
05575 gx_unrefvariant(vpage);
05576 gx_poperror();
05577 gxthrow;
05578 return page;
05579 }
05580 gx_unrefvariant(vpage);
05581 return page;
05582 }
05583
05590 inline int Light(void) GX_CONST throw(gxError) {
05591 int s=sizeof(int), light;
05592 gxassert(image);
05593 if(!image) return 0;
05594 if(!gx_convertvariantchild(image,(int)PRV_LIGHT,0,GX_VARIANT_INT,&s,0,&light,s)) {
05595 gxthrow;
05596 return 0;
05597 }
05598 return light;
05599 }
05600
05606 inline int Camera(void) GX_CONST throw(gxError) {
05607 int s=sizeof(int), camera;
05608 gxassert(image);
05609 if(!image) return 0;
05610 if(!gx_convertvariantchild(image,(int)PRV_CAMERA,0,GX_VARIANT_INT,&s,0,&camera,s)) {
05611 gxthrow;
05612 return 0;
05613 }
05614 return camera;
05615 }
05616
05621 inline bool IsValid(void) GX_CONST {
05622 if(!this) return false;
05623 return image ? true : false;
05624 }
05625
05626 };
05627
05628
05629
05630 #ifndef GX_MANUAL
05631 #if !defined(GX_SWIG) && !defined(GX_DOTNET) // C++
05632 #define ifDoc if(doc)
05633 #else
05634 #define ifDoc
05635 #endif
05636 #endif
05637
05642 GX_CLASS PassportReader : public gxHandle
05643 #ifdef GX_DOTNET
05644 ,public System::IDisposable
05645 #endif
05646 {
05647
05648 public:
05649
05651 inline PassportReader() throw(gxError) {
05652 #ifndef GX_DOTNET
05653 if(!gx_openmodule(this, L"prapi", L"default")) gxthrow;
05654 #else
05655 GX_GETHANDLE(h);
05656 if(!gx_openmodule(&h, L"prapi", L"default")) gxthrow;
05657 _set_handle(h.handle);
05658 #endif
05659 }
05660
05661 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
05662
05665 inline PassportReader(const wchar_t *proppath) throw(gxError) {
05666 if(!gx_openmodule(this, L"prapi", proppath)) gxthrow;
05667 }
05668
05672 inline PassportReader(const char *proppath) throw(gxError) {
05673 if(!gx_openmodule(this, "prapi", proppath)) gxthrow;
05674 }
05675 #endif
05676
05677 #ifdef GX_UNICODE
05678
05681 inline PassportReader(gxInStr proppath) throw(gxError) {
05682 GX_GETSTRING(_proppath, proppath);
05683 #ifndef GX_DOTNET
05684 if(!gx_openmodule(this, L"prapi", _proppath)) gxthrow;
05685 #else
05686 GX_GETHANDLE(h);
05687 if(!gx_openmodule(&h, L"prapi", _proppath)) gxthrow;
05688 _set_handle(h.handle);
05689 #endif
05690 }
05691 #endif
05692
05693 #ifdef GX_ASCII
05694
05697 inline PassportReader(gxInAStr proppath) throw(gxError) {
05698 GX_GETASTRING(_proppath, proppath);
05699 if(!gx_openmodule(this, "prapi", _proppath)) gxthrow;
05700 }
05701 #endif
05702
05704 inline void Dispose(void) {
05705 #ifdef GX_DOTNET
05706 System::GC::SuppressFinalize(this);
05707 #endif
05708 gxHandle::Dispose();
05709 }
05710
05711 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
05712
05722 inline bool GetDeviceList(wchar_t ***devices,int *ndevices) throw(gxError) {
05723 bool st = pr_getdevicelist(*this,devices,ndevices)!=0;
05724 gxcondthrow(!st);
05725 return st;
05726 }
05727
05738 inline bool GetDeviceList(char ***devices,int *ndevices) throw(gxError) {
05739 bool st = pr_getdevicelist(*this,devices,ndevices)!=0;
05740 gxcondthrow(!st);
05741 return st;
05742 }
05743 #endif
05744
05745 #ifdef GX_UNICODE
05746
05750 inline gxOutStrArray GetDeviceList(void) throw(gxError) {
05751 wchar_t **devices;
05752 int ndevices = 0;
05753 GX_GETHANDLE(h);
05754 if(!pr_getdevicelist(h,&devices,&ndevices)) {
05755 gxthrow;
05756 return GX_PUTGSTRINGARRAY_NONE;
05757 }
05758 return GX_PUTGSTRINGARRAY(devices, ndevices, true);
05759 }
05760 #endif
05761
05762 #ifdef GX_ASCII
05763
05767 inline gxOutAStrArray GetDeviceListA(void) throw(gxError) {
05768 char **devices;
05769 int ndevices = 0;
05770 if(!pr_getdevicelist(*this,&devices,&ndevices)) {
05771 gxthrow;
05772 return GX_PUTGASTRINGARRAY_NONE;
05773 }
05774 return GX_PUTGASTRINGARRAY(devices, ndevices, true);
05775 }
05776 #endif
05777
05778 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
05779
05790 inline bool UseDevice(wchar_t *device,int mode) throw(gxError) {
05791 bool st = pr_usedevice(*this,device,mode)!=0;
05792 gxcondthrow(!st);
05793 return st;
05794 }
05795
05807 inline bool UseDevice(char *device,int mode) throw(gxError) {
05808 bool st = pr_usedevice(*this,device,mode)!=0;
05809 gxcondthrow(!st);
05810 return st;
05811 }
05812 #endif
05813
05814 #ifdef GX_UNICODE
05815
05826 inline bool UseDevice(gxInStr device,int mode) throw(gxError) {
05827 GX_GETSTRING(_device, device);
05828 GX_GETHANDLE(h);
05829 bool st = pr_usedevice(h, _device,mode)!=0;
05830 gxcondthrow(!st);
05831 return st;
05832 }
05833 #endif
05834
05835 #ifdef GX_ASCII
05836
05847 inline bool UseDevice(gxInAStr device,int mode) throw(gxError) {
05848 GX_GETASTRING(_device, device);
05849 GX_GETHANDLE(h);
05850 bool st = pr_usedevice(h, _device,mode)!=0;
05851 gxcondthrow(!st);
05852 return st;
05853 }
05854 #endif
05855
05865 inline bool UseDevice(int devno,int mode) throw(gxError) {
05866 GX_GETHANDLE(h);
05867 bool st = pr_usedevice(h,devno,mode)!=0;
05868 gxcondthrow(!st);
05869 return st;
05870 }
05871
05877 inline bool CloseDevice(void) throw(gxError) {
05878 GX_GETHANDLE(h);
05879 bool st = pr_closedevice(h)!=0;
05880 gxcondthrow(!st);
05881 return st;
05882 }
05883
05884 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
05885
05890 inline gxHANDLE * GetDeviceHandle(void) {
05891 gxHANDLE *hctrl;
05892 return pr_getctrlhandle(*this,&hctrl) ? hctrl : (gxHANDLE*)0;
05893 }
05894 #endif
05895
05907 inline bool Calibrate(int windowid GX_DEFARG(0)) throw(gxError) {
05908 GX_GETHANDLE(h);
05909 bool st = pr_calibrate(h,windowid)!=0;
05910 gxcondthrow(!st);
05911 return st;
05912 }
05913
05922 inline bool IsCalibrated(int windowid GX_DEFARG(0)) {
05923 GX_GETHANDLE(h);
05924 return pr_iscalibrated(h,windowid)!=0;
05925 }
05926
05939 inline int TestDocument(int windowid GX_DEFARG(0)) {
05940 int state;
05941 GX_GETHANDLE(h);
05942 return pr_testdocument(h,&state,windowid) ? state : -1;
05943 }
05944
05950 inline int Lights(void) {
05951 int lights;
05952 GX_GETHANDLE(h);
05953 return pr_getlightnumber(h,&lights) ? lights : 0;
05954 }
05955
05962 inline int LightListItem(int itemno) {
05963 int lights[MAX_LIGHTS];
05964 if(itemno>=MAX_LIGHTS)return 0;
05965 GX_GETHANDLE(h);
05966 return pr_getlightlist(h,lights,MAX_LIGHTS) ? lights[itemno] : 0;
05967 }
05968
05984 inline int LightMask(int lightid,int windowid) {
05985 int lightmask;
05986 GX_GETHANDLE(h);
05987 return pr_getlightmask(h,&lightmask,lightid,windowid) ? lightmask : 0;
05988 }
05989
05995 inline int ObjectWindows(void) {
05996 int windows;
05997 GX_GETHANDLE(h);
05998 return pr_getwindownumber(h,&windows) ? windows : 0;
05999 }
06000
06009 inline bool SetStatusLed(int ledmask, int color) throw(gxError) {
06010 GX_GETHANDLE(h);
06011 bool st = pr_setstatusled(h, ledmask, color)!=0;
06012 gxcondthrow(!st);
06013 return st;
06014 }
06015
06016 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
06017
06030 inline bool BlinkStatus(int coding, int mask, int type, int iteration, unsigned int *data, unsigned int datalength) throw(gxError) {
06031 GX_GETHANDLE(h);
06032 bool st = pr_blinkstatus(h, coding, mask, type, iteration, data, datalength)!=0;
06033 gxcondthrow(!st);
06034 return st;
06035 }
06036 #endif
06037
06038 #ifndef NO_GX_STL
06039
06052 inline bool BlinkStatus(int coding, int mask, int type, int iteration, gxInIntArray data) throw(gxError) {
06053 GX_GETHANDLE(h);
06054 GX_GETININTARRAY(data);
06055 bool st = pr_blinkstatus(h, coding, mask, type, iteration,(unsigned int *)GX_GETININTARRAY_PTR(data), GX_GETININTARRAY_LEN(data))!=0;
06056 GX_FREEININTARRAY(data);
06057 gxcondthrow(!st);
06058 return st;
06059 }
06060 #endif
06061
06066 inline int TestPowerState(void) {
06067 int state;
06068 GX_GETHANDLE(h);
06069 return pr_testpower(h,&state,0) ? state : -1;
06070 }
06071
06078 inline int TestPowerLevel(void) {
06079 int state,level;
06080 GX_GETHANDLE(h);
06081 return pr_testpower(h,&state,&level) ? level : -1;
06082 }
06083
06089 inline int TestButton(int keycode) {
06090 int state;
06091 GX_GETHANDLE(h);
06092 return pr_testbutton(h,keycode,&state) ? state : -1;
06093 }
06094
06104 inline bool Suspend() throw(gxError) {
06105 GX_GETHANDLE(h);
06106 bool st = pr_suspend(h)!=0;
06107 gxcondthrow(!st);
06108 return st;
06109 }
06110
06116 inline bool WakeUp() throw(gxError) {
06117 GX_GETHANDLE(h);
06118 bool st = pr_wakeup(h)!=0;
06119 gxcondthrow(!st);
06120 return st;
06121 }
06122
06123 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
06124
06131 inline bool GetUDInfo(int *nblocks, int *sblock) throw(gxError) {
06132 GX_GETHANDLE(h);
06133 bool st = pr_getudinfo(h, nblocks, sblock) != 0;
06134 gxcondthrow(!st);
06135 return st;
06136 }
06137
06149 inline bool ReadUData(int fblock, int nblocks, void **data) throw(gxError) {
06150 GX_GETHANDLE(h);
06151 bool st = pr_readudata(h, fblock, nblocks, data) != 0;
06152 gxcondthrow(!st);
06153 return st;
06154 }
06155
06164 inline bool WriteUData(int fblock, int nblocks, const void *data) throw(gxError) {
06165 GX_GETHANDLE(h);
06166 bool st = pr_writeudata(h, fblock, nblocks, data) != 0;
06167 gxcondthrow(!st);
06168 return st;
06169 }
06170 #else
06171
06179 inline gxOutData ReadUData(int fblock, int nblocks) throw(gxError) {
06180 GX_GETHANDLE(h);
06181 void *data;
06182 if (pr_readudata(h, fblock, nblocks, &data) == 0) {
06183 gxthrow;
06184 return GX_PUTDATA_NONE;
06185 }
06186 int i,sblock;
06187 if (pr_getudinfo(h, &i, &sblock) == 0) {
06188 gxthrow;
06189 return GX_PUTDATA_NONE;
06190 }
06191 i=nblocks*sblock;
06192 gxOutData od = GX_PUTDATA(data, i);
06193 if(data) gx_globalfree(data);
06194 return od;
06195 }
06196
06205 inline bool WriteUData(int fblock, int nblocks, gxInData data) throw(gxError) {
06206 GX_GETHANDLE(h);
06207 GX_GETDATA(data);
06208 bool st = pr_writeudata(h, fblock, nblocks, GX_DATAPTR(data)) != 0;
06209 gxcondthrow(!st);
06210 return st;
06211 }
06212 #endif
06213
06219 inline int GetUDNumberOfBlocks(void) throw(gxError) {
06220 GX_GETHANDLE(h);
06221 int nblocks;
06222 int sblock;
06223 bool st = pr_getudinfo(h, &nblocks, &sblock) != 0;
06224 gxcondthrow(!st);
06225 return st ? nblocks : -1;
06226 }
06227
06233 inline int GetUDBlockSize(void) throw(gxError) {
06234 GX_GETHANDLE(h);
06235 int nblocks;
06236 int sblock;
06237 bool st = pr_getudinfo(h, &nblocks, &sblock) != 0;
06238 gxcondthrow(!st);
06239 return st ? sblock : -1;
06240 }
06241
06246 inline gxVariant * GetDeviceInfo() throw(gxError) {
06247 GX_GETHANDLE(h);
06248 gxVARIANT d;
06249 bool st = pr_getdeviceinfo(h,&d) != 0;
06250 gxcondthrow(!st);
06251 if(st) gxSystem::ClearError();
06252 if(!d) return 0;
06253 #ifndef GX_DOTNET
06254 gxVariant * vr = new gxVariant(d);
06255 gx_unrefvariant(d);
06256 #else
06257 gxVariant * vr = new gxVariant();
06258 vr->_set_variant(d);
06259 #endif
06260 if(!vr){gxSystem::SetError(GXEC GX_ENOMEM);gxthrow;}
06261 return vr;
06262 }
06263
06271 inline gxVariant * SelfTest(int condition) throw(gxError) {
06272 GX_GETHANDLE(h);
06273 gxVARIANT result;
06274 bool st = pr_selftest(h, condition, &result)!=0;
06275 gxcondthrow(!st);
06276 if(st) gxSystem::ClearError();
06277 if (!result) return 0;
06278 #ifndef GX_DOTNET
06279 gxVariant * vr = new gxVariant(result);
06280 gx_unrefvariant(result);
06281 #else
06282 gxVariant * vr = new gxVariant();
06283 vr->_set_variant(result);
06284 #endif
06285 if (!vr) { gxSystem::SetError(GXEC GX_ENOMEM); gxthrow; }
06286 return vr;
06287 }
06288
06289 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
06290
06299 inline bool ReadMagstripe(wchar_t ***tracks, int *ntracks) throw(gxError) {
06300 bool st = pr_readmagstripe(*this, tracks, ntracks)!=0;
06301 gxcondthrow(!st);
06302 return st;
06303 }
06304
06314 inline bool ReadMagstripe(char ***tracks, int *ntracks) throw(gxError) {
06315 bool st = pr_readmagstripe(*this, tracks, ntracks)!=0;
06316 gxcondthrow(!st);
06317 return st;
06318 }
06319 #endif
06320
06321 #ifdef GX_UNICODE
06322
06326 inline gxOutStrArray ReadMagstripe(void) throw(gxError) {
06327 wchar_t **tracks;
06328 int ntracks = 0;
06329 GX_GETHANDLE(h);
06330 if(!pr_readmagstripe(h, &tracks, &ntracks)) {
06331 gxthrow;
06332 return GX_PUTGSTRINGARRAY_NONE;
06333 }
06334 return GX_PUTGSTRINGARRAY(tracks, ntracks, true);
06335 }
06336 #endif
06337
06338 #ifdef GX_ASCII
06339
06343 inline gxOutAStrArray ReadMagstripeA(void) throw(gxError) {
06344 char **tracks;
06345 int ntracks = 0;
06346 GX_GETHANDLE(h);
06347 if(!pr_readmagstripe(h, &tracks, &ntracks)) {
06348 gxthrow;
06349 return GX_PUTGASTRINGARRAY_NONE;
06350 }
06351 return GX_PUTGASTRINGARRAY(tracks, ntracks, true);
06352 }
06353 #endif
06354
06355 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
06356
06367 inline bool SetEventFunction(PR_EVFUNC *eventhandler,void *param) {
06368 return pr_seteventfunction(*this,eventhandler,param)!=0;
06369 }
06370 #endif
06371
06372 #if (defined(WIN32) || defined(GX_MANUAL)) && !defined(GX_SWIG)
06373
06390 #ifndef GX_DOTNET
06391 inline bool BeginWindowMessaging(HWND hwnd, UINT base_msg GX_DEFARG(WM_USER)) throw(gxError) {
06392 bool st = pr_beginwindowmessaging(*this,hwnd, base_msg)!=0;
06393 gxcondthrow(!st);
06394 return st;
06395 }
06396 #else
06397 inline bool BeginWindowMessaging(gxInPtr hwnd, UINT base_msg GX_DEFARG(WM_USER)) throw(gxError) {
06398 GX_GETHANDLE(h);
06399 bool st = pr_beginwindowmessaging(h,hwnd.ToPointer(), base_msg)!=0;
06400 gxcondthrow(!st);
06401 return st;
06402 }
06403 #endif
06404
06413 inline bool EndWindowMessaging() throw(gxError) {
06414 GX_GETHANDLE(h);
06415 bool st = pr_endwindowmessaging(h)!=0;
06416 gxcondthrow(!st);
06417 return st;
06418 }
06419
06420 #endif
06421
06422 #if (defined(LINUX) || defined(GX_MANUAL)) && !defined(GX_SWIG)
06423
06433 inline int StartBGProcesses() throw(gxError) {
06434 bool st = pr_startbgprocesses(*this);
06435 gxcondthrow(!st);
06436 return st;
06437 }
06438
06446 inline int StopBGProcesses() {
06447 return pr_stopbgprocesses(*this);
06448 }
06449
06450 #endif
06451
06452 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
06453
06466 inline bool SetPageLight(int pages,unsigned int *lights) throw(gxError) {
06467 GX_GETHANDLE(h);
06468 bool st = pr_setpagelight(h,pages,lights)!=0;
06469 gxcondthrow(!st);
06470 return st;
06471 }
06472 #endif
06473
06474 #ifndef NO_GX_STL
06475
06488 inline bool SetPageLight(gxInIntArray lights) throw(gxError) {
06489 GX_GETHANDLE(h);
06490 GX_GETININTARRAY(lights);
06491 bool st = pr_setpagelight(h,GX_GETININTARRAY_LEN(lights),(unsigned int *)GX_GETININTARRAY_PTR(lights))!=0;
06492 GX_FREEININTARRAY(lights);
06493 gxcondthrow(!st);
06494 return st;
06495 }
06496 #endif
06497
06508 inline bool Capture(void) throw(gxError) {
06509 GX_GETHANDLE(h);
06510 bool st = pr_capture(h)!=0;
06511 gxcondthrow(!st);
06512 return st;
06513 }
06514
06525 inline int CaptureStart() throw(gxError) {
06526 GX_GETHANDLE(h);
06527 int reqid;
06528 bool st = pr_capture_start(h,&reqid)!=0;
06529 gxcondthrow(!st);
06530 return st ? reqid : -1;
06531 }
06532
06542 inline int CaptureStatus(int reqid) throw(gxError) {
06543 GX_GETHANDLE(h);
06544 int status;
06545 bool st = pr_capture_getstatus(h,reqid,&status)!=0;
06546 gxcondthrow(!st);
06547 return st ? status : -1;
06548 }
06549
06558 inline bool CaptureWait(int reqid) throw(gxError) {
06559 GX_GETHANDLE(h);
06560 bool st = pr_capture_wait(h,reqid)!=0;
06561 gxcondthrow(!st);
06562 return st;
06563 }
06564
06577 inline bool CapturePreview(int windowid GX_DEFARG(0)) throw(gxError) {
06578 GX_GETHANDLE(h);
06579 bool st = pr_capture_preview(h,windowid)!=0;
06580 gxcondthrow(!st);
06581 return st;
06582 }
06583
06598 inline prImage * GetImage(int page,int light,int type) throw(gxError) {
06599 gxVARIANT img = 0;
06600 prImage *cimg = 0;
06601 GX_GETHANDLE(h);
06602 if(!pr_getimage(h,page,light,type,&img)) {
06603 gxthrow;
06604 return cimg;
06605 }
06606
06607 #if !defined(GX_DOTNET) && !defined(GX_SWIG)
06608 if(img)
06609 #endif
06610 cimg = new prImage(img);
06611 if(img)gx_unrefvariant(img);
06612 #if !defined(GX_DOTNET) && !defined(GX_SWIG)
06613 if(img)
06614 #endif
06615 if(!cimg){gxSystem::SetError(GX_ENOMEM);gxthrow;}
06616 if(!img) gxSystem::ClearError();
06617 return cimg;
06618 }
06619
06632 inline gxVariant * GetEnhancedUV(int page, int imgtype) throw(gxError) {
06633 gxVARIANT img = 0;
06634 GX_GETHANDLE(h);
06635 if(!pr_getenhanceduv(h, page, imgtype, &img)) {
06636 gxthrow;
06637 return 0;
06638 }
06639 #ifndef GX_DOTNET
06640 gxVariant * im = new gxVariant(img);
06641 gx_unrefvariant(img);
06642 #else
06643 gxVariant * im = new gxVariant();
06644 im->_set_variant(img);
06645 #endif
06646 if(!im){gxSystem::SetError(GX_ENOMEM);gxthrow;}
06647 return im;
06648 }
06649
06650 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
06651
06664 inline bool SaveImage(int page,int light,int type,const wchar_t *filename,int filetype) throw(gxError) {
06665 bool st = pr_saveimage(*this,page,light,type,filename,filetype)!=0;
06666 gxcondthrow(!st);
06667 return st;
06668 }
06669
06684 inline bool SaveImage(int page,int light,int type,const char *filename,int filetype) throw(gxError) {
06685 bool st = pr_saveimage(*this,page,light,type,filename,filetype)!=0;
06686 gxcondthrow(!st);
06687 return st;
06688 }
06689 #endif
06690
06691 #ifdef GX_UNICODE
06692
06706 inline bool SaveImage(int page,int light,int type,gxInStr filename,int filetype) throw(gxError) {
06707 GX_GETHANDLE(h);
06708 GX_GETSTRING(_filename, filename);
06709 bool st = pr_saveimage(h,page,light,type,_filename,filetype)!=0;
06710 gxcondthrow(!st);
06711 return st;
06712 }
06713 #endif
06714
06715 #ifdef GX_ASCII
06716
06730 inline bool SaveImage(int page,int light,int type,gxInAStr filename,int filetype) throw(gxError) {
06731 GX_GETHANDLE(h);
06732 GX_GETASTRING(_filename, filename);
06733 bool st = pr_saveimage(h,page,light,type,_filename,filetype)!=0;
06734 gxcondthrow(!st);
06735 return st;
06736 }
06737 #endif
06738
06739 #if (defined(WIN32) || defined(GX_MANUAL)) && !defined(GX_DOTNET) && !defined(GX_SWIG)
06740
06757 inline bool DisplayImage(int page,int light,int type,HDC hdc,int x,int y,int xsize,int ysize,gxRCT *frame) throw(gxError) {
06758 bool st = pr_drawimage(*this,page,light,type,hdc,x,y,xsize,ysize,frame)!=0;
06759 gxcondthrow(!st);
06760 return st;
06761 }
06762 #endif
06763
06764 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
06765
06771 inline bool FingerToNist(const wchar_t *filename,gxVariant *fields) throw(gxError) {
06772 bool st = pr_fingertonist(*this,filename,(fields)?fields->_variant:0)!=0;
06773 gxcondthrow(!st);
06774 return st;
06775 }
06776
06783 inline bool FingerToNist(const char *filename,gxVariant *fields) throw(gxError) {
06784 bool st = pr_fingertonist(*this,filename,(fields)?fields->_variant:0)!=0;
06785 gxcondthrow(!st);
06786 return st;
06787 }
06788
06796 inline bool FingerToNistMem(void **buffer, int *buflen,gxVariant *fields) throw(gxError) {
06797 bool st = pr_fingertonistmem(*this,buffer,buflen,fields?fields->_variant:0)!=0;
06798 gxcondthrow(!st);
06799 return st;
06800 }
06801 #endif
06802
06803 #ifdef GX_UNICODE
06804
06810 inline bool FingerToNist(gxInStr filename,gxVariant *fields) throw(gxError) {
06811 GX_GETHANDLE(h);
06812 #ifdef GX_DOTNET
06813 gxVARIANT var = fields?(gxVARIANT)GX_GETPTR(fields->_get_variant()):0;
06814 #else
06815 gxVARIANT var = fields?fields->_variant:0;
06816 #endif
06817 GX_GETSTRING(_filename, filename);
06818 bool st = pr_fingertonist(h,_filename,var)!=0;
06819 gxcondthrow(!st);
06820 return st;
06821 }
06822 #endif
06823
06824 #ifdef GX_ASCII
06825
06831 inline bool FingerToNist(gxInAStr filename,gxVariant *fields) throw(gxError) {
06832 GX_GETHANDLE(h);
06833 GX_GETASTRING(_filename, filename);
06834 bool st = pr_fingertonist(h,_filename,(fields)?fields->_variant:0)!=0;
06835 gxcondthrow(!st);
06836 return st;
06837 }
06838 #endif
06839
06840 #if defined(GX_SWIG) || defined(GX_DOTNET)
06841
06845 inline gxOutData FingerToNistMem(gxVariant *fields) throw(gxError) {
06846 void *buffer = (void *)0;
06847 gxi32 buflen = 0;
06848 GX_GETHANDLE(h);
06849 #ifdef GX_DOTNET
06850 gxVARIANT var = fields?(gxVARIANT)GX_GETPTR(fields->_get_variant()):0;
06851 #else
06852 gxVARIANT var = fields?fields->_variant:0;
06853 #endif
06854 if(!pr_fingertonistmem(h,&buffer,&buflen,var)) {
06855 gxthrow;
06856 return GX_PUTDATA_NONE;
06857 }
06858 gxOutData ret = GX_PUTDATA(buffer, buflen);
06859 if(buffer) gx_globalfree(buffer);
06860 return ret;
06861 }
06862 #endif
06863
06875 inline bool ResetDocument(int lastpage GX_DEFARG(0)) throw(gxError) {
06876 GX_GETHANDLE(h);
06877 bool st = pr_resetdocument(h, lastpage)!=0;
06878 gxcondthrow(!st);
06879 return st;
06880 }
06881
06895 inline prDoc * GetOcr(int page,int light,int type) throw(gxError) {
06896 gxVARIANT doc = 0;
06897 prDoc *cdoc = 0;
06898 GX_GETHANDLE(h);
06899 if(!pr_getocr(h,page,light,type,&doc,0)) {
06900 gxthrow;
06901 return cdoc;
06902 }
06903 ifDoc cdoc = new prDoc(doc,h);
06904 if(doc) gx_unrefvariant(doc);
06905 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
06906 if(!doc) gxSystem::ClearError();
06907 return cdoc;
06908 }
06909
06924 inline prDoc * GetOcr(int page,int light,int type,gxVariant *ocrparams) throw(gxError) {
06925 gxVARIANT doc = 0;
06926 prDoc *cdoc = 0;
06927 GX_GETHANDLE(h);
06928 #ifdef GX_DOTNET
06929 gxVARIANT var = ocrparams?(gxVARIANT)GX_GETPTR(ocrparams->_get_variant()):0;
06930 #else
06931 gxVARIANT var = ocrparams?ocrparams->_variant:0;
06932 #endif
06933
06934 if(!pr_getocr(h,page,light,type,&doc,var)) {
06935 gxthrow;
06936 return cdoc;
06937 }
06938 ifDoc cdoc = new prDoc(doc,h);
06939 if(doc) gx_unrefvariant(doc);
06940 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
06941 if(!doc) gxSystem::ClearError();
06942 return cdoc;
06943 }
06944
06958 inline prDoc * GetMrz(int page,int light,int type) throw(gxError) {
06959 gxVARIANT doc = 0;
06960 prDoc *cdoc = 0;
06961 GX_GETHANDLE(h);
06962 if(!pr_getmrz(h,page,light,type,&doc)) {
06963 gxthrow;
06964 return cdoc;
06965 }
06966 ifDoc cdoc = new prDoc(doc,h);
06967 if(doc) gx_unrefvariant(doc);
06968 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
06969 if(!doc) gxSystem::ClearError();
06970 return cdoc;
06971 }
06972
06990 inline prDoc * GetBarcode(int page,int light,int type,int bctype,int index) throw(gxError) {
06991 gxVARIANT doc = 0;
06992 prDoc *cdoc = 0;
06993 GX_GETHANDLE(h);
06994 if(!pr_getbarcode(h,page,light,type,bctype,index,&doc)) {
06995 gxthrow;
06996 return cdoc;
06997 }
06998 ifDoc cdoc = new prDoc(doc,h);
06999 if(doc) gx_unrefvariant(doc);
07000 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
07001 if(!doc) gxSystem::ClearError();
07002 return cdoc;
07003 }
07004
07018 inline prDoc * GetDocumentRect(int page,int light,int type) throw(gxError) {
07019 gxVARIANT doc = 0;
07020 prDoc *cdoc = 0;
07021 GX_GETHANDLE(h);
07022 if(!pr_getdocumentrect(h,page,light,type,&doc)) {
07023 gxthrow;
07024 return cdoc;
07025 }
07026 ifDoc cdoc = new prDoc(doc,h);
07027 if(doc) gx_unrefvariant(doc);
07028 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
07029 if(!doc) gxSystem::ClearError();
07030 return cdoc;
07031 }
07032
07043 inline prDoc * Recognize(int page) throw(gxError) {
07044 gxVARIANT doc = 0;
07045 prDoc *cdoc = 0;
07046 GX_GETHANDLE(h);
07047 if(!pr_recognize(h,page,&doc)) {
07048 gxthrow;
07049 return cdoc;
07050 }
07051 ifDoc cdoc = new prDoc(doc,h);
07052 if(doc) gx_unrefvariant(doc);
07053 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
07054 if(!doc) gxSystem::ClearError();
07055 return cdoc;
07056 }
07057
07058 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
07059
07068 inline prDoc * Analyze(gxVariant *page, int tasklen, int *task) throw(gxError) {
07069 gxVARIANT doc = 0;
07070 prDoc *cdoc = 0;
07071 GX_GETHANDLE(h);
07072 if(!page) { gxSystem::SetError(GX_EINVAL, L"(page)"); gxthrow; return cdoc; }
07073 #ifdef GX_DOTNET
07074 gxVARIANT var = page ? (gxVARIANT)GX_GETPTR(page->_get_variant()) : 0;
07075 #else
07076 gxVARIANT var = page ? page->_variant : 0;
07077 #endif
07078 if(!pr_analyze(h, var, tasklen, task, &doc)) {
07079 gxthrow;
07080 return cdoc;
07081 }
07082 ifDoc cdoc = new prDoc(doc,h);
07083 if(doc) gx_unrefvariant(doc);
07084 ifDoc if(!cdoc) { gxSystem::SetError(GX_ENOMEM); gxthrow; }
07085 if(!doc) gxSystem::ClearError();
07086 return cdoc;
07087 }
07088
07098 inline prDoc * Analyze(gxu8 *buffer, int buflen) throw(gxError) {
07099 gxVARIANT doc = 0;
07100 prDoc *cdoc = 0;
07101 GX_GETHANDLE(h);
07102 if(!pr_analyze(h, buffer, buflen, &doc)) {
07103 gxthrow;
07104 return cdoc;
07105 }
07106 ifDoc cdoc = new prDoc(doc,h);
07107 if(doc) gx_unrefvariant(doc);
07108 ifDoc if(!cdoc) { gxSystem::SetError(GX_ENOMEM); gxthrow; }
07109 if(!doc) gxSystem::ClearError();
07110 return cdoc;
07111 }
07112 #endif
07113
07114 #ifndef NO_GX_STL
07115
07123 inline prDoc * Analyze(gxVariant *page, gxInIntArray task) throw(gxError) {
07124 gxVARIANT doc = 0;
07125 prDoc *cdoc = 0;
07126 GX_GETHANDLE(h);
07127 if(!page) { gxSystem::SetError(GX_EINVAL); gxthrow; return cdoc; }
07128 #ifdef GX_DOTNET
07129 gxVARIANT var = page ? (gxVARIANT)GX_GETPTR(page->_get_variant()) : 0;
07130 #else
07131 gxVARIANT var = page ? page->_variant : 0;
07132 #endif
07133 GX_GETININTARRAY(task);
07134 bool st = pr_analyze(h, var, GX_GETININTARRAY_LEN(task), GX_GETININTARRAY_PTR(task), &doc)!=0;
07135 GX_FREEININTARRAY(task);
07136 if(!st) {
07137 gxthrow;
07138 return cdoc;
07139 }
07140 ifDoc cdoc = new prDoc(doc,h);
07141 if(doc) gx_unrefvariant(doc);
07142 ifDoc if(!cdoc) { gxSystem::SetError(GX_ENOMEM); gxthrow; }
07143 if(!doc) gxSystem::ClearError();
07144 return cdoc;
07145 }
07146 #endif
07147
07148 #if defined(GX_SWIG) || defined(GX_DOTNET)
07149
07157 inline prDoc * Analyze(gxInData buffer) throw(gxError) {
07158 gxVARIANT doc = 0;
07159 prDoc *cdoc = 0;
07160 GX_GETHANDLE(h);
07161 GX_GETDATA(buffer);
07162 bool st = pr_analyze(h, (gxu8*)GX_DATAPTR(buffer), GX_DATALEN(buffer), &doc)!=0;
07163 GX_FREEDATA(buffer);
07164 if(!st) {
07165 gxthrow;
07166 return cdoc;
07167 }
07168 ifDoc cdoc = new prDoc(doc,h);
07169 if(doc) gx_unrefvariant(doc);
07170 ifDoc if(!cdoc) { gxSystem::SetError(GX_ENOMEM); gxthrow; }
07171 if(!doc) gxSystem::ClearError();
07172 return cdoc;
07173 }
07174 #endif
07175
07176 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
07177
07187 inline prDoc * ResolveMrzText(const wchar_t **lines,int nlines) throw(gxError) {
07188 gxVARIANT doc = 0;
07189 prDoc *cdoc = 0;
07190 if(!pr_resolvemrztext(*this,lines,nlines,&doc)) {
07191 gxthrow;
07192 return cdoc;
07193 }
07194 ifDoc cdoc = new prDoc(doc,*this);
07195 if(doc) gx_unrefvariant(doc);
07196 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
07197 if(!doc) gxSystem::ClearError();
07198 return cdoc;
07199 }
07200
07211 inline prDoc * ResolveMrzText(const char **lines,int nlines) throw(gxError) {
07212 gxVARIANT doc = 0;
07213 prDoc *cdoc = 0;
07214 if(!pr_resolvemrztext(*this,lines,nlines,&doc)) {
07215 gxthrow;
07216 return cdoc;
07217 }
07218 ifDoc cdoc = new prDoc(doc,*this);
07219 if(doc) gx_unrefvariant(doc);
07220 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
07221 if(!doc) gxSystem::ClearError();
07222 return cdoc;
07223 }
07224 #endif
07225
07226 #ifdef GX_UNICODE
07227
07236 inline prDoc * ResolveMrzText(gxInStrArray lines) throw(gxError) {
07237 gxVARIANT doc = 0;
07238 prDoc *cdoc = 0;
07239 GX_GETHANDLE(h);
07240 GX_GETINSTRARRAY(lines);
07241 bool st = pr_resolvemrztext(h,(const wchar_t**)GX_GETINSTRARRAY_PTR(lines),GX_GETINSTRARRAY_LEN(lines),&doc)!=0;
07242 GX_FREEINSTRARRAY(lines);
07243 if(!st) {
07244 gxthrow;
07245 return cdoc;
07246 }
07247 ifDoc cdoc = new prDoc(doc,h);
07248 if(doc) gx_unrefvariant(doc);
07249 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
07250 if(!doc) gxSystem::ClearError();
07251 return cdoc;
07252 }
07253 #endif
07254
07255 #ifdef GX_ASCII
07256
07265 inline prDoc * ResolveMrzText(gxInAStrArray lines) throw(gxError) {
07266 gxVARIANT doc = 0;
07267 prDoc *cdoc = 0;
07268 GX_GETHANDLE(h);
07269 GX_GETINASTRARRAY(lines);
07270 bool st = pr_resolvemrztext(h,(const char**)GX_GETINASTRARRAY_PTR(lines),GX_GETINASTRARRAY_LEN(lines),&doc)!=0;
07271 GX_FREEINASTRARRAY(lines);
07272 if(!st) {
07273 gxthrow;
07274 return cdoc;
07275 }
07276 ifDoc cdoc = new prDoc(doc,h);
07277 if(doc) gx_unrefvariant(doc);
07278 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
07279 if(!doc) gxSystem::ClearError();
07280 return cdoc;
07281 }
07282 #endif
07283
07284 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
07285
07293 inline prDoc * ResolveMagstripe(const wchar_t **tracks, int ntracks) throw(gxError) {
07294 gxVARIANT doc = 0;
07295 prDoc *cdoc = 0;
07296 if(!pr_resolvemagstripe(*this, tracks, ntracks, &doc)) {
07297 gxthrow;
07298 return cdoc;
07299 }
07300 ifDoc cdoc = new prDoc(doc,*this);
07301 if(doc) gx_unrefvariant(doc);
07302 ifDoc if(!cdoc) { gxSystem::SetError(GX_ENOMEM); gxthrow; }
07303 if(!doc) gxSystem::ClearError();
07304 return cdoc;
07305 }
07306
07315 inline prDoc * ResolveMagstripe(const char **tracks, int ntracks) throw(gxError) {
07316 gxVARIANT doc = 0;
07317 prDoc *cdoc = 0;
07318 if(!pr_resolvemagstripe(*this, tracks, ntracks, &doc)) {
07319 gxthrow;
07320 return cdoc;
07321 }
07322 ifDoc cdoc = new prDoc(doc, *this);
07323 if(doc) gx_unrefvariant(doc);
07324 ifDoc if(!cdoc) { gxSystem::SetError(GX_ENOMEM); gxthrow; }
07325 if(!doc) gxSystem::ClearError();
07326 return cdoc;
07327 }
07328 #endif
07329
07330 #ifdef GX_UNICODE
07331
07338 inline prDoc * ResolveMagstripe(gxInStrArray tracks) throw(gxError) {
07339 gxVARIANT doc = 0;
07340 prDoc *cdoc = 0;
07341 GX_GETHANDLE(h);
07342 GX_GETINSTRARRAY(tracks);
07343 bool st = pr_resolvemagstripe(h, (const wchar_t**)GX_GETINSTRARRAY_PTR(tracks), GX_GETINSTRARRAY_LEN(tracks), &doc)!=0;
07344 GX_FREEINSTRARRAY(tracks);
07345 if(!st) {
07346 gxthrow;
07347 return cdoc;
07348 }
07349 ifDoc cdoc = new prDoc(doc,h);
07350 if(doc) gx_unrefvariant(doc);
07351 ifDoc if(!cdoc) { gxSystem::SetError(GX_ENOMEM); gxthrow; }
07352 if(!doc) gxSystem::ClearError();
07353 return cdoc;
07354 }
07355 #endif
07356
07357 #ifdef GX_ASCII
07358
07365 inline prDoc * ResolveMagstripe(gxInAStrArray tracks) throw(gxError) {
07366 gxVARIANT doc = 0;
07367 prDoc *cdoc = 0;
07368 GX_GETHANDLE(h);
07369 GX_GETINASTRARRAY(tracks);
07370 bool st = pr_resolvemagstripe(h, (const char**)GX_GETINASTRARRAY_PTR(tracks), GX_GETINASTRARRAY_LEN(tracks), &doc)!=0;
07371 GX_FREEINASTRARRAY(tracks);
07372 if(!st) {
07373 gxthrow;
07374 return cdoc;
07375 }
07376 ifDoc cdoc = new prDoc(doc,h);
07377 if(doc) gx_unrefvariant(doc);
07378 ifDoc if(!cdoc) { gxSystem::SetError(GX_ENOMEM); gxthrow; }
07379 if(!doc) gxSystem::ClearError();
07380 return cdoc;
07381 }
07382 #endif
07383
07384 #if !defined(GX_DOTNET) && !defined(GX_SWIG)
07385
07395 inline bool GetRfidCardList(wchar_t ***cards,int *ncards) throw(gxError) {
07396 bool st = pr_getrfidcardlist(*this,cards,ncards)!=0;
07397 gxcondthrow(!st);
07398 return st;
07399 }
07400
07411 inline bool GetRfidCardList(char ***cards,int *ncards) throw(gxError) {
07412 bool st = pr_getrfidcardlist(*this,cards,ncards)!=0;
07413 gxcondthrow(!st);
07414 return st;
07415 }
07416 #endif
07417
07418 #ifdef GX_UNICODE
07419
07423 inline gxOutStrArray GetRfidCardList(void) throw(gxError) {
07424 wchar_t **cards;
07425 int ncards = 0;
07426 GX_GETHANDLE(h);
07427 if(!pr_getrfidcardlist(h,&cards,&ncards)) {
07428 gxthrow;
07429 return GX_PUTGSTRINGARRAY_NONE;
07430 }
07431 return GX_PUTGSTRINGARRAY(cards, ncards, true);
07432 }
07433 #endif
07434
07435 #ifdef GX_ASCII
07436
07440 inline gxOutAStrArray GetRfidCardListA(void) throw(gxError) {
07441 char **cards;
07442 int ncards = 0;
07443 if(!pr_getrfidcardlist(*this,&cards,&ncards)) {
07444 gxthrow;
07445 return GX_PUTGASTRINGARRAY_NONE;
07446 }
07447 return GX_PUTGASTRINGARRAY(cards, ncards, true);
07448 }
07449 #endif
07450
07451 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
07452
07459 inline bool ConnectRfidCard(const wchar_t *card) throw(gxError) {
07460 bool st = pr_connectrfidcard(*this,card)!=0;
07461 gxcondthrow(!st);
07462 return st;
07463 }
07464
07471 inline bool ConnectRfidCard(const char *card) throw(gxError) {
07472 bool st = pr_connectrfidcard(*this,card)!=0;
07473 gxcondthrow(!st);
07474 return st;
07475 }
07476
07483 inline bool DisconnectRfidCard(const wchar_t *card) throw(gxError) {
07484 bool st = pr_disconnectrfidcard(*this,card)!=0;
07485 gxcondthrow(!st);
07486 return st;
07487 }
07488
07495 inline bool DisconnectRfidCard(const char *card) throw(gxError) {
07496 bool st = pr_disconnectrfidcard(*this,card)!=0;
07497 gxcondthrow(!st);
07498 return st;
07499 }
07500
07501 #endif
07502
07503 #ifdef GX_UNICODE
07504
07511 inline bool ConnectRfidCard(gxInStr card) throw(gxError) {
07512 GX_GETHANDLE(h);
07513 GX_GETSTRING(_card, card);
07514 bool st = pr_connectrfidcard(h,_card)!=0;
07515 gxcondthrow(!st);
07516 return st;
07517 }
07518
07525 inline bool DisconnectRfidCard(gxInStr card) throw(gxError) {
07526 GX_GETHANDLE(h);
07527 GX_GETSTRING(_card, card);
07528 bool st = pr_disconnectrfidcard(h,_card)!=0;
07529 gxcondthrow(!st);
07530 return st;
07531 }
07532
07533 #endif
07534
07535 #ifdef GX_ASCII
07536
07543 inline bool ConnectRfidCard(gxInAStr card) throw(gxError) {
07544 GX_GETHANDLE(h);
07545 GX_GETASTRING(_card, card);
07546 bool st = pr_connectrfidcard(h,_card)!=0;
07547 gxcondthrow(!st);
07548 return st;
07549 }
07550
07557 inline bool DisconnectRfidCard(gxInAStr card) throw(gxError) {
07558 GX_GETHANDLE(h);
07559 GX_GETASTRING(_card, card);
07560 bool st = pr_disconnectrfidcard(h,_card)!=0;
07561 gxcondthrow(!st);
07562 return st;
07563 }
07564
07565 #endif
07566
07567 #if !defined(GX_DOTNET) && !defined(GX_SWIG)
07568
07581 inline bool GetRfidFile(const wchar_t *card,int fileid,void **data,int *sdata) throw(gxError) {
07582 bool st = pr_getrfidfile(*this,card,fileid,data,sdata)!=0;
07583 gxcondthrow(!st);
07584 return st;
07585 }
07586
07595 inline bool CheckRfidFileHash(const wchar_t *card,int fileid) throw(gxError) {
07596 bool st = pr_checkrfidfilehash(*this,card,fileid)!=0;
07597 gxcondthrow(!st);
07598 return st;
07599 }
07600
07614 inline bool GetRfidFile(const char *card,int fileid,void **data,int *sdata) throw(gxError) {
07615 bool st = pr_getrfidfile(*this,card,fileid,data,sdata)!=0;
07616 gxcondthrow(!st);
07617 return st;
07618 }
07619
07628 inline bool CheckRfidFileHash(const char *card,int fileid) throw(gxError) {
07629 bool st = pr_checkrfidfilehash(*this,card,fileid)!=0;
07630 gxcondthrow(!st);
07631 return st;
07632 }
07633 #endif
07634
07635 #if defined(GX_SWIG) || defined(GX_DOTNET)
07636
07637 #ifdef GX_UNICODE
07638
07645 inline gxOutData GetRfidFile(gxInStr card, int fileid) throw(gxError) {
07646 GX_GETSTRING(_card, card);
07647 GX_GETHANDLE(h);
07648 void *data;
07649 int sdata;
07650 if(!pr_getrfidfile(h,_card,fileid,&data,&sdata)) {
07651 gxthrow;
07652 return GX_PUTDATA_NONE;
07653 }
07654 gxOutData od = GX_PUTDATA(data, sdata);
07655 if(data) gx_globalfree(data);
07656 return od;
07657 }
07658 #endif
07659
07660 #ifdef GX_ASCII
07661
07668 inline gxOutData GetRfidFile(gxInAStr card,int fileid) throw(gxError) {
07669 GX_GETASTRING(_card, card);
07670 GX_GETHANDLE(h);
07671 void *data;
07672 int sdata;
07673 if(!pr_getrfidfile(h, _card,fileid,data,sdata)) {
07674 gxthrow;
07675 return GX_PUTDATA_NONE;
07676 }
07677 gxOutData od = GX_PUTDATA(data, sdata);
07678 if(data) gx_globalfree(data);
07679 return od;
07680 }
07681 #endif
07682
07683 #endif
07684
07685 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
07686
07694 inline int GetRfidFileStart(const wchar_t *card, int fileid) throw(gxError) {
07695 int reqid;
07696 bool st = pr_getrfidfile_start(*this, card, fileid, &reqid)!=0;
07697 gxcondthrow(!st);
07698 return st ? reqid : -1;
07699 }
07700
07708 inline int GetRfidFileStart(const char *card, int fileid) throw(gxError) {
07709 int reqid;
07710 bool st = pr_getrfidfile_start(*this, card, fileid, &reqid)!=0;
07711 gxcondthrow(!st);
07712 return st ? reqid : -1;
07713 }
07714
07715 #endif
07716
07717 #ifdef GX_UNICODE
07718
07725 inline int GetRfidFileStart(gxInStr card, int fileid) throw(gxError) {
07726 GX_GETHANDLE(h);
07727 GX_GETSTRING(_card, card);
07728 int reqid;
07729 bool st = pr_getrfidfile_start(h,_card,fileid,&reqid)!=0;
07730 gxcondthrow(!st);
07731 return st ? reqid : -1;
07732 }
07733 #endif
07734
07735 #ifdef GX_ASCII
07736
07743 inline int GetRfidFileStart(gxInAStr card, int fileid) throw(gxError) {
07744 GX_GETHANDLE(h);
07745 GX_GETASTRING(_card, card);
07746 int reqid;
07747 bool st = pr_getrfidfile_start(h,_card,fileid,&reqid)!=0;
07748 gxcondthrow(!st);
07749 return st ? reqid : -1;
07750 }
07751 #endif
07752
07762 inline int GetRfidFileGetStatus(int reqid) throw(gxError) {
07763 GX_GETHANDLE(h);
07764 int status;
07765 bool st = pr_getrfidfile_getstatus(h,reqid,&status)!=0;
07766 gxcondthrow(!st);
07767 return st? status : -1;
07768 }
07769
07770 #if !defined(GX_DOTNET) && !defined(GX_SWIG)
07771
07780 inline bool GetRfidFileWait(int reqid, void **data, int *sdata) throw(gxError) {
07781 bool st = pr_getrfidfile_wait(*this,reqid,data,sdata)!=0;
07782 gxcondthrow(!st);
07783 return st;
07784 }
07785 #else
07786
07792 inline gxOutData GetRfidFileWait(int reqid) throw(gxError) {
07793 GX_GETHANDLE(h);
07794 void *data;
07795 int sdata;
07796 if(!pr_getrfidfile_wait(h,reqid,&data,&sdata)){
07797 gxthrow;
07798 return GX_PUTDATA_NONE;
07799 }
07800 gxOutData od = GX_PUTDATA(data, sdata);
07801 if(data) gx_globalfree(data);
07802 return od;
07803 }
07804 #endif
07805
07812 inline bool GetRfidFileStop() throw(gxError) {
07813 GX_GETHANDLE(h);
07814 bool st = pr_getrfidfile_stop(h)!=0;
07815 gxcondthrow(!st);
07816 return st;
07817 }
07818
07819 #ifdef GX_UNICODE
07820
07828 inline bool CheckRfidFileHash(gxInStr card, int fileid) throw(gxError) {
07829 GX_GETHANDLE(h);
07830 GX_GETSTRING(_card, card);
07831 bool st = pr_checkrfidfilehash(h,_card,fileid)!=0;
07832 gxcondthrow(!st);
07833 return st;
07834 }
07835 #endif
07836
07837 #ifdef GX_ASCII
07838
07846 inline bool CheckRfidFileHash(gxInAStr card, int fileid) throw(gxError) {
07847 GX_GETHANDLE(h);
07848 GX_GETASTRING(_card, card);
07849 bool st = pr_checkrfidfilehash(h,_card,fileid)!=0;
07850 gxcondthrow(!st);
07851 return st;
07852 }
07853 #endif
07854
07855 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
07856
07864 inline prDoc * ResolveRfidData(const void *data, int sdata) throw(gxError) {
07865 gxVARIANT doc = 0;
07866 prDoc *cdoc = 0;
07867 if(!pr_resolverfiddata(*this,data,sdata,&doc)) {
07868 gxthrow;
07869 return cdoc;
07870 }
07871 ifDoc cdoc = new prDoc(doc,*this);
07872 if(doc) gx_unrefvariant(doc);
07873 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
07874 if(!doc) gxSystem::ClearError();
07875 return cdoc;
07876 }
07877 #else
07878
07885 inline prDoc * ResolveRfidData(gxInData data) throw(gxError) {
07886 gxVARIANT doc = 0;
07887 prDoc *cdoc = 0;
07888 GX_GETHANDLE(h);
07889 GX_GETDATA(data);
07890 bool st = pr_resolverfiddata(h,GX_DATAPTR(data),GX_DATALEN(data),&doc)!=0;
07891 GX_FREEDATA(data);
07892 if(!st) {
07893 gxthrow;
07894 return cdoc;
07895 }
07896 ifDoc cdoc = new prDoc(doc,h);
07897 if(doc) gx_unrefvariant(doc);
07898 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
07899 if(!doc) gxSystem::ClearError();
07900 return cdoc;
07901 }
07902 #endif
07903
07904 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
07905
07914 inline bool GetApplications(const wchar_t *card, int **apps, int *napps) throw(gxError) {
07915 bool st = pr_getapplications(*this, card, apps, napps)!=0;
07916 gxcondthrow(!st);
07917 return st;
07918 }
07919
07928 inline bool GetApplications(const char *card, int **apps, int *napps) throw(gxError) {
07929 bool st = pr_getapplicationsa(*this, card, apps, napps)!=0;
07930 gxcondthrow(!st);
07931 return st;
07932 }
07933 #else
07934
07940 inline gxOutIntArray GetApplications(gxInStr card) throw(gxError) {
07941 GX_GETHANDLE(h);
07942 GX_GETSTRING(_card, card);
07943 int apps_len = 0;
07944 int *apps_ptr = 0;
07945 gxOutIntArray apps = GX_INTARRAY_NONE;
07946 bool st = pr_getapplications(h, _card, &apps_ptr, &apps_len)!=0;
07947 if(apps_ptr && apps_len){
07948 apps = GX_PUTINTARRAY(apps_ptr, apps_len);
07949 gx_globalfree(apps_ptr);
07950 }
07951 return apps;
07952 }
07953 #endif
07954
07955
07956 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
07957
07965 inline bool SelectApplication(const wchar_t *card, PR_APP_TYPE Application) throw(gxError) {
07966 bool st = pr_selectapplication(*this,card,Application)!=0;
07967 gxcondthrow(!st);
07968 return st;
07969 }
07970
07978 inline bool SelectApplication(const char *card, PR_APP_TYPE Application) throw(gxError) {
07979 bool st = pr_selectapplicationa(*this,card,Application)!=0;
07980 gxcondthrow(!st);
07981 return st;
07982 }
07983
07984 #endif
07985
07986 #ifdef GX_UNICODE
07987
07995 inline bool SelectApplication(gxInStr card, PR_APP_TYPE Application) throw(gxError) {
07996 GX_GETHANDLE(h);
07997 GX_GETSTRING(_card, card);
07998 bool st = pr_selectapplication(h,_card,Application)!=0;
07999 gxcondthrow(!st);
08000 return st;
08001 }
08002
08003 #endif
08004
08005 #ifdef GX_ASCII
08006
08014 inline bool SelectApplication(gxInAStr card, PR_APP_TYPE Application) throw(gxError) {
08015 GX_GETHANDLE(h);
08016 GX_GETASTRING(_card, card);
08017 bool st = pr_selectapplication(h,_card,Application)!=0;
08018 gxcondthrow(!st);
08019 return st;
08020 }
08021
08022 #endif
08023
08024
08025 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
08026
08034 inline bool MakeBAC(const wchar_t *card, const wchar_t **lines, int nlines) throw(gxError) {
08035 bool st = pr_makebac(*this,card,lines,nlines)!=0;
08036 gxcondthrow(!st);
08037 return st;
08038 }
08039
08047 inline bool MakeBAC(const char *card, const char **lines, int nlines) throw(gxError) {
08048 bool st = pr_makebac(*this,card,lines,nlines)!=0;
08049 gxcondthrow(!st);
08050 return st;
08051 }
08052
08053 #endif
08054
08055 #ifdef GX_UNICODE
08056
08063 inline bool MakeBAC(gxInStr card, gxInStrArray lines) throw(gxError) {
08064 GX_GETHANDLE(h);
08065 GX_GETSTRING(_card, card);
08066 GX_GETINSTRARRAY(lines);
08067 bool st = pr_makebac(h,_card,(const wchar_t**)GX_GETINSTRARRAY_PTR(lines),GX_GETINSTRARRAY_LEN(lines))!=0;
08068 GX_FREEINSTRARRAY(lines);
08069 gxcondthrow(!st);
08070 return st;
08071 }
08072
08073 #endif
08074
08075 #ifdef GX_ASCII
08076
08083 inline bool MakeBAC(gxInAStr card, gxInAStrArray lines) throw(gxError) {
08084 GX_GETHANDLE(h);
08085 GX_GETASTRING(_card, card);
08086 GX_GETINASTRARRAY(lines);
08087 bool st = pr_makebac(h,_card,(const char**)GX_GETINASTRARRAY_PTR(lines),GX_GETINASTRARRAY_LEN(lines))!=0;
08088 GX_FREEINASTRARRAY(lines);
08089 gxcondthrow(!st);
08090 return st;
08091 }
08092
08093 #endif
08094
08095 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
08096
08106 inline bool MakePACE(const wchar_t *card, const wchar_t **lines, int nlines, int PasswordType) throw(gxError) {
08107 bool st = pr_makepace(*this,card,lines,nlines,PasswordType)!=0;
08108 gxcondthrow(!st);
08109 return st;
08110 }
08111
08121 inline bool MakePACE(const char *card, const char **lines, int nlines, int PasswordType) throw(gxError) {
08122 bool st = pr_makepace(*this,card,lines,nlines,PasswordType)!=0;
08123 gxcondthrow(!st);
08124 return st;
08125 }
08126 #endif
08127
08128 #ifdef GX_UNICODE
08129
08138 inline bool MakePACE(gxInStr card, gxInStrArray lines, int PasswordType) throw(gxError) {
08139 GX_GETHANDLE(h);
08140 GX_GETSTRING(_card, card);
08141 GX_GETINSTRARRAY(lines);
08142 bool st = pr_makepace(h,_card,(const wchar_t**)GX_GETINSTRARRAY_PTR(lines),GX_GETINSTRARRAY_LEN(lines),PasswordType)!=0;
08143 GX_FREEINSTRARRAY(lines);
08144 gxcondthrow(!st);
08145 return st;
08146 }
08147 #endif
08148
08149 #ifdef GX_ASCII
08150
08159 inline bool MakePACE(gxInAStr card, gxInAStrArray lines, int PasswordType) throw(gxError) {
08160 GX_GETHANDLE(h);
08161 GX_GETASTRING(_card, card);
08162 GX_GETINASTRARRAY(lines);
08163 bool st = pr_makepace(h,_card,(const char**)GX_GETINASTRARRAY_PTR(lines),GX_GETINASTRARRAY_LEN(lines),PasswordType)!=0;
08164 GX_FREEINASTRARRAY(lines);
08165 gxcondthrow(!st);
08166 return st;
08167 }
08168 #endif
08169
08170 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
08171
08180 inline int GetNextAuthentication(const wchar_t *card, int ForceNext = false) throw(gxError) {
08181 int Authentication;
08182 bool st = pr_getnextauthentication(*this,card,&Authentication,ForceNext)!=0;
08183 gxcondthrow(!st);
08184 return st ? Authentication : -1;
08185 }
08186
08195 inline int GetNextAuthentication(const char *card, int ForceNext = false) throw(gxError) {
08196 int Authentication;
08197 bool st = pr_getnextauthentication(*this,card,&Authentication,ForceNext)!=0;
08198 gxcondthrow(!st);
08199 return st ? Authentication : -1;
08200 }
08201
08214 inline int DoAuthentication(const wchar_t *card, int Authentication, const wchar_t **AuthData GX_DEFARG(0), int Lines GX_DEFARG(0), int PasswordType GX_DEFARG(PR_PACE_PW_MRZ)) throw(gxError) {
08215 bool st = pr_doauthentication(*this, card, Authentication, AuthData, Lines, PasswordType)!=0;
08216 gxcondthrow(!st);
08217 return st;
08218 }
08219
08232 inline int DoAuthentication(const char *card, int Authentication, const char **AuthData GX_DEFARG(0), int Lines GX_DEFARG(0), int PasswordType GX_DEFARG(PR_PACE_PW_MRZ)) throw(gxError) {
08233 bool st = pr_doauthenticationa(*this,card, Authentication, AuthData, Lines, PasswordType)!=0;
08234 gxcondthrow(!st);
08235 return st;
08236 }
08237
08244 inline bool MakePassiveAuth(const wchar_t *card) throw(gxError) {
08245 bool st = pr_makepassiveauth(*this,card)!=0;
08246 gxcondthrow(!st);
08247 return st;
08248 }
08249
08256 inline bool MakePassiveAuth(const char *card) throw(gxError) {
08257 bool st = pr_makepassiveauth(*this,card)!=0;
08258 gxcondthrow(!st);
08259 return st;
08260 }
08261
08271 inline bool MakeActiveAuth(const wchar_t *card) throw(gxError) {
08272 bool st = pr_makeactiveauth(*this,card)!=0;
08273 gxcondthrow(!st);
08274 return st;
08275 }
08276
08286 inline bool MakeActiveAuth(const char *card) throw(gxError) {
08287 bool st = pr_makeactiveauth(*this,card)!=0;
08288 gxcondthrow(!st);
08289 return st;
08290 }
08291
08298 inline bool MakeChipAuth(const wchar_t *card) throw(gxError) {
08299 bool st = pr_makechipauth(*this,card)!=0;
08300 gxcondthrow(!st);
08301 return st;
08302 }
08303
08310 inline bool MakeChipAuth(const char *card) throw(gxError) {
08311 bool st = pr_makechipauth(*this,card)!=0;
08312 gxcondthrow(!st);
08313 return st;
08314 }
08315
08322 inline bool MakeTerminalAuth(const wchar_t *card) throw(gxError) {
08323 bool st = pr_maketerminalauth(*this,card)!=0;
08324 gxcondthrow(!st);
08325 return st;
08326 }
08327
08334 inline bool MakeTerminalAuth(const char *card) throw(gxError) {
08335 bool st = pr_maketerminalauth(*this,card)!=0;
08336 gxcondthrow(!st);
08337 return st;
08338 }
08339
08348 inline bool InitTerminalAuth(const wchar_t *card, void **data, int *sdata) throw(gxError) {
08349 bool st = pr_initta(*this, card, data, sdata)!=0;
08350 gxcondthrow(!st);
08351 return st;
08352 }
08353
08362 inline bool InitTerminalAuth(const char *card, void **data, int *sdata) throw(gxError) {
08363 bool st = pr_initta(*this, card, data, sdata)!=0;
08364 gxcondthrow(!st);
08365 return st;
08366 }
08367
08376 inline bool CompleteTerminalAuth(const wchar_t *card, const void *data, int sdata) throw(gxError) {
08377 bool st = pr_completeta(*this, card, data, sdata)!=0;
08378 gxcondthrow(!st);
08379 return st;
08380 }
08381
08390 inline bool CompleteTerminalAuth(const char *card, const void *data, int sdata) throw(gxError) {
08391 bool st = pr_completeta(*this, card, data, sdata)!=0;
08392 gxcondthrow(!st);
08393 return st;
08394 }
08395
08403 inline bool LoadCertFile(const wchar_t *certificate, const wchar_t *privateKey = NULL) throw(gxError) {
08404 bool st = pr_loadcertfile(*this, certificate, privateKey)!=0;
08405 gxcondthrow(!st);
08406 return st;
08407 }
08408
08416 inline bool LoadCertFile(const char *certificate, const char *privateKey = NULL) throw(gxError) {
08417 bool st = pr_loadcertfile(*this, certificate, privateKey)!=0;
08418 gxcondthrow(!st);
08419 return st;
08420 }
08421
08428 inline bool LoadCertFromStore(const wchar_t *storename) throw(gxError) {
08429 bool st = pr_loadcertfromstore(*this, storename)!=0;
08430 gxcondthrow(!st);
08431 return st;
08432 }
08433
08440 inline bool LoadCertFromStore(const char *storename) throw(gxError) {
08441 bool st = pr_loadcertfromstore(*this, storename)!=0;
08442 gxcondthrow(!st);
08443 return st;
08444 }
08445
08455 inline bool LoadCertFileFromMem(void *certificate_data, unsigned int certificate_length, void *privateKey_data = NULL, unsigned int privateKey_length = 0) throw(gxError) {
08456 bool st = pr_loadcertfrommem(*this, certificate_data, certificate_length, privateKey_data, privateKey_length)!=0;
08457 gxcondthrow(!st);
08458 return st;
08459 }
08460
08461 #endif
08462
08463 #if defined(GX_SWIG) || defined(GX_DOTNET)
08464
08471 inline bool LoadCertFileFromMem(gxInData certificate, gxInData privateKey) throw(gxError) {
08472 GX_GETHANDLE(h);
08473 GX_GETDATA(certificate);
08474 bool st;
08475 if(privateKey!=GX_NULLPTR) {
08476 GX_GETDATA(privateKey);
08477 st = pr_loadcertfrommem(h, (void*)GX_DATAPTR(certificate), (unsigned int)GX_DATALEN(certificate), (void*)GX_DATAPTR(privateKey), (unsigned int)GX_DATALEN(privateKey))!=0;
08478 GX_FREEDATA(privateKey);
08479 }
08480 else{
08481 st = pr_loadcertfrommem(h, (void*)GX_DATAPTR(certificate), (unsigned int)GX_DATALEN(certificate), 0, 0)!=0;
08482 }
08483
08484 GX_FREEDATA(certificate);
08485 gxcondthrow(!st);
08486 return st;
08487 }
08488 #endif
08489 #ifdef GX_UNICODE
08490
08499 inline int GetNextAuthentication(gxInStr card, int ForceNext GX_DEFARG(false)) throw(gxError) {
08500 int Authentication;
08501 GX_GETHANDLE(h);
08502 GX_GETSTRING(_card, card);
08503 bool st = pr_getnextauthentication(h,_card,&Authentication,ForceNext)!=0;
08504 gxcondthrow(!st);
08505 return st ? Authentication : -1;
08506 }
08507
08519 inline int DoAuthentication(gxInStr card, int Authentication, gxInStrArray AuthData, int PasswordType GX_DEFARG(PR_PACE_PW_MRZ)) throw(gxError) {
08520 GX_GETHANDLE(h);
08521 GX_GETSTRING(_card, card);
08522 GX_GETINSTRARRAY(AuthData);
08523 bool st = pr_doauthentication(h, _card, Authentication, (const wchar_t**)GX_GETINSTRARRAY_PTR(AuthData), GX_GETINSTRARRAY_LEN(AuthData), PasswordType)!=0;
08524 GX_FREEINSTRARRAY(AuthData);
08525 gxcondthrow(!st);
08526 return st;
08527 }
08528
08537 inline int DoAuthentication(gxInStr card, int Authentication) throw(gxError) {
08538 GX_GETHANDLE(h);
08539 GX_GETSTRING(_card, card);
08540 bool st = pr_doauthentication(h, _card, Authentication, 0, 0, 0)!=0;
08541 gxcondthrow(!st);
08542 return st;
08543 }
08544
08551 inline bool MakePassiveAuth(gxInStr card) throw(gxError) {
08552 GX_GETHANDLE(h);
08553 GX_GETSTRING(_card, card);
08554 bool st = pr_makepassiveauth(h,_card)!=0;
08555 gxcondthrow(!st);
08556 return st;
08557 }
08558
08568 inline bool MakeActiveAuth(gxInStr card) throw(gxError) {
08569 GX_GETHANDLE(h);
08570 GX_GETSTRING(_card, card);
08571 bool st = pr_makeactiveauth(h,_card)!=0;
08572 gxcondthrow(!st);
08573 return st;
08574 }
08575
08582 inline bool MakeChipAuth(gxInStr card) throw(gxError) {
08583 GX_GETHANDLE(h);
08584 GX_GETSTRING(_card, card);
08585 bool st = pr_makechipauth(h,_card)!=0;
08586 gxcondthrow(!st);
08587 return st;
08588 }
08589
08596 inline bool MakeTerminalAuth(gxInStr card) throw(gxError) {
08597 GX_GETHANDLE(h);
08598 GX_GETSTRING(_card, card);
08599 bool st = pr_maketerminalauth(h,_card)!=0;
08600 gxcondthrow(!st);
08601 return st;
08602 }
08603
08604 #if defined(GX_SWIG) || defined(GX_DOTNET)
08605
08610 inline gxOutData InitTerminalAuth(gxInStr card) throw(gxError) {
08611 GX_GETSTRING(_card, card);
08612 GX_GETHANDLE(h);
08613 void *data;
08614 int sdata;
08615 if(!pr_initta(h, _card, &data, &sdata)) {
08616 gxthrow;
08617 return GX_PUTDATA_NONE;
08618 }
08619 gxOutData od = GX_PUTDATA(data, sdata);
08620 if(data) gx_globalfree(data);
08621 return od;
08622 }
08623
08631 inline bool CompleteTerminalAuth(gxInStr card, gxInData data) throw(gxError) {
08632 GX_GETSTRING(_card, card);
08633 GX_GETHANDLE(h);
08634 GX_GETDATA(data);
08635 bool st = pr_completeta(h, _card, GX_DATAPTR(data), GX_DATALEN(data))!=0;
08636 gxcondthrow(!st);
08637 return st;
08638 }
08639 #endif
08640
08648 inline bool LoadCertFile(gxInStr certificate, gxInStr privateKey ) throw(gxError) {
08649 GX_GETHANDLE(h);
08650 GX_GETSTRING(_certificate, certificate);
08651 GX_GETSTRING(_privateKey, privateKey);
08652 bool st = pr_loadcertfile(h,_certificate,_privateKey)!=0;
08653 gxcondthrow(!st);
08654 return st;
08655 }
08656
08663 inline bool LoadCertFromStore(gxInStr storename) throw(gxError) {
08664 GX_GETHANDLE(h);
08665 GX_GETSTRING(_storename, storename);
08666 bool st = pr_loadcertfromstore(h,_storename)!=0;
08667 gxcondthrow(!st);
08668 return st;
08669 }
08670
08671 #endif
08672
08673 #ifdef GX_ASCII
08674
08683 inline int GetNextAuthentication(gxInAStr card, int ForceNext GX_DEFARG(false)) throw(gxError) {
08684 int Authentication;
08685 GX_GETHANDLE(h);
08686 GX_GETASTRING(_card, card);
08687 bool st = pr_getnextauthentication(h,_card,&Authentication,ForceNext)!=0;
08688 gxcondthrow(!st);
08689 return st ? Authentication : -1;
08690 }
08691
08703 inline int DoAuthentication(gxInAStr card, int Authentication, gxInAStrArray AuthData, int PasswordType GX_DEFARG(PR_PACE_PW_MRZ)) throw(gxError) {
08704 GX_GETHANDLE(h);
08705 GX_GETASTRING(_card, card);
08706 GX_GETINASTRARRAY(AuthData);
08707 bool st = pr_doauthenticationa(h, _card, Authentication, (const char **)GX_GETINASTRARRAY_PTR(AuthData), GX_GETINASTRARRAY_LEN(AuthData), PasswordType)!=0;
08708 GX_FREEINASTRARRAY(AuthData);
08709 gxcondthrow(!st);
08710 return st;
08711 }
08712
08721 inline int DoAuthentication(gxInAStr card, int Authentication) throw(gxError) {
08722 GX_GETHANDLE(h);
08723 GX_GETASTRING(_card, card);
08724 bool st = pr_doauthenticationa(h, _card, Authentication, 0, 0, 0)!=0;
08725 gxcondthrow(!st);
08726 return st;
08727 }
08728
08735 inline bool MakePassiveAuth(gxInAStr card) throw(gxError) {
08736 GX_GETHANDLE(h);
08737 GX_GETASTRING(_card, card);
08738 bool st = pr_makepassiveauth(h,_card)!=0;
08739 gxcondthrow(!st);
08740 return st;
08741 }
08742
08752 inline bool MakeActiveAuth(gxInAStr card) throw(gxError) {
08753 GX_GETHANDLE(h);
08754 GX_GETASTRING(_card, card);
08755 bool st = pr_makeactiveauth(h,_card)!=0;
08756 gxcondthrow(!st);
08757 return st;
08758 }
08759
08766 inline bool MakeChipAuth(gxInAStr card) throw(gxError) {
08767 GX_GETHANDLE(h);
08768 GX_GETASTRING(_card, card);
08769 bool st = pr_makechipauth(h,_card)!=0;
08770 gxcondthrow(!st);
08771 return st;
08772 }
08773
08780 inline bool MakeTerminalAuth(gxInAStr card) throw(gxError) {
08781 GX_GETHANDLE(h);
08782 GX_GETASTRING(_card, card);
08783 bool st = pr_maketerminalauth(h,_card)!=0;
08784 gxcondthrow(!st);
08785 return st;
08786 }
08787
08788 #if defined(GX_SWIG) || defined(GX_DOTNET)
08789
08794 inline gxOutData InitTerminalAuth(gxInAStr card) throw(gxError) {
08795 GX_GETASTRING(_card, card);
08796 GX_GETHANDLE(h);
08797 void *data;
08798 int sdata;
08799 if(!pr_initta(h, _card, &data, &sdata)) {
08800 gxthrow;
08801 return GX_PUTDATA_NONE;
08802 }
08803 gxOutData od = GX_PUTDATA(data, sdata);
08804 if(data) gx_globalfree(data);
08805 return od;
08806 }
08807
08815 inline bool CompleteTerminalAuth(gxInAStr card, gxInData data) throw(gxError) {
08816 GX_GETASTRING(_card, card);
08817 GX_GETHANDLE(h);
08818 GX_GETDATA(data);
08819 bool st = pr_completeta(h, _card, GX_DATAPTR(data), GX_DATALEN(data))!=0;
08820 gxcondthrow(!st);
08821 return st;
08822 }
08823 #endif
08824
08832 inline bool LoadCertFile(gxInAStr certificate, gxInAStr privateKey ) throw(gxError) {
08833 GX_GETHANDLE(h);
08834 GX_GETASTRING(_certificate, certificate);
08835 GX_GETASTRING(_privateKey, privateKey);
08836 bool st = pr_loadcertfile(h,_certificate,_privateKey)!=0;
08837 gxcondthrow(!st);
08838 return st;
08839 }
08840
08847 inline bool LoadCertFromStore(gxInAStr storename) throw(gxError) {
08848 GX_GETHANDLE(h);
08849 GX_GETASTRING(_storename, storename);
08850 bool st = pr_loadcertfromstore(h,_storename)!=0;
08851 gxcondthrow(!st);
08852 return st;
08853 }
08854
08855 #endif
08856
08863 inline bool ClearCertList(int sel) throw(gxError) {
08864 GX_GETHANDLE(h);
08865 bool st = pr_clearcertlist(h, sel)!=0;
08866 gxcondthrow(!st);
08867 return st;
08868 }
08869
08870 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
08871
08877 inline gxVariant * GetRfidCardInfo(const wchar_t *card) throw(gxError) {
08878 gxVARIANT cardinfo;
08879 bool st = pr_getrfidcardinfo(*this,card,&cardinfo)!=0;
08880 gxcondthrow(!st);
08881 if(st) gxSystem::ClearError();
08882 if(!cardinfo) return 0;
08883 gxVariant * vr = new gxVariant(cardinfo);
08884 gx_unrefvariant(cardinfo);
08885 if(!vr){gxSystem::SetError(GXEC GX_ENOMEM);gxthrow;}
08886 return vr;
08887 }
08888
08894 inline gxVariant * GetRfidCardInfo(const char *card) throw(gxError) {
08895 gxVARIANT cardinfo;
08896 bool st = pr_getrfidcardinfo(*this,card,&cardinfo)!=0;
08897 gxcondthrow(!st);
08898 if(st) gxSystem::ClearError();
08899 if(!cardinfo) return 0;
08900 gxVariant * vr = new gxVariant(cardinfo);
08901 gx_unrefvariant(cardinfo);
08902 if(!vr){gxSystem::SetError(GXEC GX_ENOMEM);gxthrow;}
08903 return vr;
08904 }
08905
08912 inline gxVariant* GetCertificateId(const char *card, int Authentication) throw(gxError) {
08913 gxVARIANT Id;
08914 bool st = pr_getcertificateid(*this,card,Authentication,&Id)!= 0;
08915 gxcondthrow(!st);
08916 if(st) gxSystem::ClearError();
08917 if(!Id) return 0;
08918 gxVariant *variant = new gxVariant(Id);
08919 gx_unrefvariant(Id);
08920 if(!variant){gxSystem::SetError(GXEC GX_ENOMEM);gxthrow;}
08921 return variant;
08922 }
08923
08930 inline gxVariant* GetCertificateId(const wchar_t *card, int Authentication) throw(gxError) {
08931 gxVARIANT Id;
08932 bool st = pr_getcertificateid(*this,card,Authentication,&Id)!= 0;
08933 gxcondthrow(!st);
08934 if(st) gxSystem::ClearError();
08935 if(!Id) return 0;
08936 gxVariant *variant = new gxVariant(Id);
08937 gx_unrefvariant(Id);
08938 if(!variant){gxSystem::SetError(GXEC GX_ENOMEM);gxthrow;}
08939 return variant;
08940 }
08941
08942 #endif
08943
08944 #ifdef GX_UNICODE
08945
08951 inline gxVariant * GetRfidCardInfo(gxInStr card) throw(gxError) {
08952 GX_GETHANDLE(h);
08953 GX_GETSTRING(_card, card);
08954 gxVARIANT cardinfo;
08955 bool st = pr_getrfidcardinfo(h,_card,&cardinfo)!=0;
08956 gxcondthrow(!st);
08957 if(st) gxSystem::ClearError();
08958 if(!cardinfo) return 0;
08959 #ifndef GX_DOTNET
08960 gxVariant * vr = new gxVariant(cardinfo);
08961 gx_unrefvariant(cardinfo);
08962 #else
08963 gxVariant * vr = new gxVariant();
08964 vr->_set_variant(cardinfo);
08965 #endif
08966 if(!vr){gxSystem::SetError(GXEC GX_ENOMEM);gxthrow;}
08967 return vr;
08968 }
08969
08976 inline gxVariant* GetCertificateId(gxInStr card, int Authentication) throw(gxError) {
08977 GX_GETHANDLE(h);
08978 GX_GETSTRING(_card, card);
08979 gxVARIANT Id;
08980 bool st = pr_getcertificateid(h,_card,Authentication,&Id)!= 0;
08981 gxcondthrow(!st);
08982 if(st) gxSystem::ClearError();
08983 if(!Id) return 0;
08984 #ifndef GX_DOTNET
08985 gxVariant *variant = new gxVariant(Id);
08986 gx_unrefvariant(Id);
08987 #else
08988 gxVariant *variant = new gxVariant();
08989 variant->_set_variant(Id);
08990 #endif
08991 if(!variant){gxSystem::SetError(GXEC GX_ENOMEM);gxthrow;}
08992 return variant;
08993 }
08994
08995
08996 #endif
08997
08998 #ifdef GX_ASCII
08999
09005 inline gxVariant * GetRfidCardInfo(gxInAStr card) throw(gxError) {
09006 GX_GETHANDLE(h);
09007 GX_GETASTRING(_card, card);
09008 gxVARIANT cardinfo;
09009 bool st = pr_getrfidcardinfo(h,_card,&cardinfo)!=0;
09010 gxcondthrow(!st);
09011 if(st) gxSystem::ClearError();
09012 if(!cardinfo) return 0;
09013 gxVariant * vr = new gxVariant(cardinfo);
09014 gx_unrefvariant(cardinfo);
09015 if(!vr){gxSystem::SetError(GXEC GX_ENOMEM);gxthrow;}
09016 return vr;
09017 }
09018
09025 inline gxVariant* GetCertificateId(gxInAStr card, int Authentication) throw(gxError) {
09026 GX_GETHANDLE(h);
09027 GX_GETASTRING(_card, card);
09028 gxVARIANT Id=0;
09029 bool st = pr_getcertificateid(h,_card,Authentication,&Id)!= 0;
09030 gxcondthrow(!st);
09031 if(st) gxSystem::ClearError();
09032 if(!Id) return 0;
09033 gxVariant *variant = new gxVariant(Id);
09034 gx_unrefvariant(Id);
09035 if(!variant){gxSystem::SetError(GXEC GX_ENOMEM);gxthrow;}
09036 return variant;
09037 }
09038
09039 #endif
09040
09051 inline prDoc * CompareFace(int page, int face_no) throw(gxError) {
09052 gxVARIANT doc = 0;
09053 prDoc *cdoc = 0;
09054 GX_GETHANDLE(h);
09055 if(!pr_compareface(h,page,face_no,&doc)) {
09056 gxthrow;
09057 return cdoc;
09058 }
09059 ifDoc cdoc = new prDoc(doc,h);
09060 if(doc) gx_unrefvariant(doc);
09061 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
09062 if(!doc) gxSystem::ClearError();
09063 return cdoc;
09064 }
09065
09066 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
09067
09077 inline gxVariant * DecodeLatentImage(int page, int light, int type, const wchar_t *decpar) throw(gxError) {
09078 gxVARIANT image;
09079 bool st = pr_decodelatentimage(*this, page, light, type, decpar, &image)!=0;
09080 gxcondthrow(!st);
09081 if(st) gxSystem::ClearError();
09082 if(!image) return 0;
09083 gxVariant * vr = new gxVariant(image);
09084 gx_unrefvariant(image);
09085 if(!vr){gxSystem::SetError(GXEC GX_ENOMEM);gxthrow;}
09086 return vr;
09087 }
09088 #endif
09089
09090 #ifdef GX_UNICODE
09091
09101 inline gxVariant * DecodeLatentImage(int page, int light, int type, gxInStr decpar) throw(gxError) {
09102 GX_GETHANDLE(h);
09103 GX_GETSTRING(_decpar, decpar);
09104 gxVARIANT image;
09105 bool st = pr_decodelatentimage(h, page, light, type, _decpar, &image)!=0;
09106 gxcondthrow(!st);
09107 if(st) gxSystem::ClearError();
09108 if(!image) return 0;
09109 #ifndef GX_DOTNET
09110 gxVariant * vr = new gxVariant(image);
09111 gx_unrefvariant(image);
09112 #else
09113 gxVariant * vr = new gxVariant();
09114 vr->_set_variant(image);
09115 #endif
09116 if(!vr){gxSystem::SetError(GXEC GX_ENOMEM);gxthrow;}
09117 return vr;
09118 }
09119 #endif
09120
09121 #if !defined(GX_SWIG) && !defined(GX_DOTNET)
09122
09129 inline prDoc * LoadDocument(const wchar_t *filename) throw(gxError) {
09130 gxVARIANT doc = 0;
09131 prDoc *cdoc = 0;
09132 if(!pr_loaddocument(*this,filename,&doc)) {
09133 gxthrow;
09134 return cdoc;
09135 }
09136 ifDoc cdoc = new prDoc(doc,*this);
09137 if(doc) gx_unrefvariant(doc);
09138 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
09139 if(!doc) gxSystem::ClearError();
09140 return cdoc;
09141 }
09142
09150 inline prDoc * LoadDocument(const char *filename) throw(gxError) {
09151 gxVARIANT doc = 0;
09152 prDoc *cdoc = 0;
09153 if(!pr_loaddocument(*this,filename,&doc)) {
09154 gxthrow;
09155 return cdoc;
09156 }
09157 ifDoc cdoc = new prDoc(doc,*this);
09158 if(doc) gx_unrefvariant(doc);
09159 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
09160 if(!doc) gxSystem::ClearError();
09161 return cdoc;
09162 }
09163
09172 inline prDoc * LoadDocumentFromMem(const gxu8 *buffer, gxi32 buflen) throw(gxError) {
09173 gxVARIANT doc = 0;
09174 prDoc *cdoc = 0;
09175 if(!pr_loaddocumentfrommem(*this, buffer, buflen, &doc)) {
09176 gxthrow;
09177 return cdoc;
09178 }
09179 ifDoc cdoc = new prDoc(doc,*this);
09180 if(doc) gx_unrefvariant(doc);
09181 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
09182 if(!doc) gxSystem::ClearError();
09183 return cdoc;
09184 }
09185
09186 #endif
09187
09188 #ifdef GX_UNICODE
09189
09196 inline prDoc * LoadDocument(gxInStr filename) throw(gxError) {
09197 gxVARIANT doc = 0;
09198 prDoc *cdoc = 0;
09199 GX_GETHANDLE(h);
09200 GX_GETSTRING(_filename, filename);
09201 if(!pr_loaddocument(h,_filename,&doc)) {
09202 gxthrow;
09203 return cdoc;
09204 }
09205 ifDoc cdoc = new prDoc(doc,h);
09206 if(doc) gx_unrefvariant(doc);
09207 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
09208 if(!doc) gxSystem::ClearError();
09209 return cdoc;
09210 }
09211 #endif
09212
09213 #ifdef GX_ASCII
09214
09221 inline prDoc * LoadDocument(gxInAStr filename) throw(gxError) {
09222 gxVARIANT doc = 0;
09223 prDoc *cdoc = 0;
09224 GX_GETHANDLE(h);
09225 GX_GETASTRING(_filename, filename);
09226 if(!pr_loaddocument(h,_filename,&doc)) {
09227 gxthrow;
09228 return cdoc;
09229 }
09230 ifDoc cdoc = new prDoc(doc,h);
09231 if(doc) gx_unrefvariant(doc);
09232 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
09233 if(!doc) gxSystem::ClearError();
09234 return cdoc;
09235 }
09236 #endif
09237
09238 #if defined(GX_SWIG) || defined(GX_DOTNET)
09239
09246 inline prDoc * LoadDocumentFromMem(gxInData buffer) throw(gxError) {
09247 gxVARIANT doc = 0;
09248 prDoc *cdoc = 0;
09249 GX_GETHANDLE(h);
09250 GX_GETDATA(buffer);
09251 bool st = pr_loaddocumentfrommem(h, (const gxu8*)GX_DATAPTR(buffer), GX_DATALEN(buffer), &doc)!=0;
09252 GX_FREEDATA(buffer);
09253 if(!st) {
09254 gxthrow;
09255 return cdoc;
09256 }
09257 ifDoc cdoc = new prDoc(doc, h);
09258 if(doc) gx_unrefvariant(doc);
09259 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
09260 if(!doc) gxSystem::ClearError();
09261 return cdoc;
09262 }
09263 #endif
09264
09270 inline prDoc * GetDocumentRoot() throw(gxError) {
09271 gxVARIANT doc = 0;
09272 prDoc *cdoc = 0;
09273 GX_GETHANDLE(h);
09274 if(!pr_getdocumentroot(h,&doc)) {
09275 gxthrow;
09276 return cdoc;
09277 }
09278 ifDoc cdoc = new prDoc(doc,h);
09279 if(doc) gx_unrefvariant(doc);
09280 ifDoc if(!cdoc){gxSystem::SetError(GX_ENOMEM);gxthrow;}
09281 if(!doc) gxSystem::ClearError();
09282 return cdoc;
09283 }
09284 };
09285
09286 #ifndef GX_MANUAL
09287 #undef ifDoc
09288 #endif
09289
09290
09291 #endif
09292
09293 #ifdef GX_NAMESPACES
09294 }
09295 #endif
09296
09297 #ifdef __BORLANDC__
09298 #pragma warn .rch
09299 #endif
09300 #ifdef _MSC_VER
09301 #pragma warning(pop)
09302 #endif
09303
09304 #endif
