fpsapi.h

Go to the documentation of this file.

#ifndef FPSAPI_INCL
#define FPSAPI_INCL
/*******************************************************************************
 * FPS API 2009-2012 (c) ARH Inc.
 * 2013.03.01 v1.2.1.9
 ******************************************************************************/
#ifdef GX_DOTNET
    #using "gxdotnet7.dll"
#endif
#include "gxsd.h"
#include "fpstypes.h"
#include "gximage.h"

#if defined(WIN32) && !defined(GX_DOTNET)
    #include <windows.h>
#endif
/******************************************************************************/
#ifdef _MSC_VER
    #pragma warning(push)
    #pragma warning(disable : 4786)     /* truncated debug info */
#endif
#ifdef __BORLANDC__
    #pragma warn -rch
#endif
/******************************************************************************/
#ifdef GX_NAMESPACES
    namespace fps {
    using namespace gx;
#endif

#ifndef GX_MANUAL
/* .NET Workarounds */
#ifdef GX_DOTNET
    #pragma unmanaged
    #define _GX_ENOENT 2
    #define _FPS_UMODE_DISCONNECT 0
    #define gxPG4 _gxPG4
    #ifdef WIN32
        #define HWND void*
        #define UINT unsigned int
    #endif
    #define GXVF GX_VARIANT_FLAGS::
    #define GXEC GX_ERROR_CODES::
#else
    #define _GX_ENOENT GX_ENOENT
    #define _FPS_UMODE_DISCONNECT FPS_UMODE_DISCONNECT
    #define GXVF
    #define GXEC
#endif
#endif/* GX_MANUAL */

#if !defined(GX_SWIGIF) && !defined(GX_MANUAL)  /*(*/

/*******************************************************************************
 * call codes
 ******************************************************************************/

/* Call codes for the Fingerprint Scanner routines. */
enum {
    FPS_CALL_GROUP_FPSAPI                   = 0x20080000,                   /* Caller ID of the fpsapi module */
    FPSAPI_CALL_USEDEVICE                   = FPS_CALL_GROUP_FPSAPI+2,      /* Call code of the fps_usedevice() function (Unicode version). */
    FPSAPI_CALL_USEDEVICEA                  = FPS_CALL_GROUP_FPSAPI+3,      /* Call code of the fps_usedevice() function (ASCII version). */
    FPSAPI_CALL_CALIBRATE                   = FPS_CALL_GROUP_FPSAPI+60,     /* Call code of the fps_calibrate() function */
    FPSAPI_CALL_ISCALIBRATED                = FPS_CALL_GROUP_FPSAPI+61,     /* Call code of the fps_iscalibrated() function */
    FPSAPI_CALL_SETEVENTFUNCTION            = FPS_CALL_GROUP_FPSAPI+11,     /* Call code of the fps_seteventfunction() function */
    FPSAPI_CALL_TEST_PRESENCE               = FPS_CALL_GROUP_FPSAPI+63,     /* Call code of the fps_testpresence() function */
    FPSAPI_CALL_CAPTURE_GETSTATUS           = FPS_CALL_GROUP_FPSAPI+15,     /* Call code of the fps_capture_getstatus() function */
    FPSAPI_CALL_CAPTURE_WAIT                = FPS_CALL_GROUP_FPSAPI+16,     /* Call code of the fps_capture_wait() function */
    FPSAPI_CALL_CAPTURE_PREVIEW             = FPS_CALL_GROUP_FPSAPI+64,     /* Call code of the fps_capture_preview() function */
    FPSAPI_CALL_SAVEIMAGE                   = FPS_CALL_GROUP_FPSAPI+19,     /* Call code of the fps_saveimage() function (Unicode version). */
    FPSAPI_CALL_SAVEIMAGEA                  = FPS_CALL_GROUP_FPSAPI+20,     /* Call code of the fps_saveimage() function (ASCII version). */
    FPSAPI_CALL_DRAWIMAGE                   = FPS_CALL_GROUP_FPSAPI+21,     /* Call code of the fps_drawimage() function */
    FPSAPI_CALL_SET_STATUS_LED              = FPS_CALL_GROUP_FPSAPI+68,     /* Call code of the fps_setstatusled() function */
    FPSAPI_CALL_TEST_POWER                  = FPS_CALL_GROUP_FPSAPI+69,     /* Call code of the fps_testpower() function */
    FPSAPI_CALL_TEST_BUTTON                 = FPS_CALL_GROUP_FPSAPI+70,     /* Call code of the fps_testbutton() function */
    FPSAPI_CALL_BEGIN_WINDOW_MESSAGING      = FPS_CALL_GROUP_FPSAPI+82,     /* Call code of the fps_beginwindowmessaging() function */
    FPSAPI_CALL_END_WINDOW_MESSAGING        = FPS_CALL_GROUP_FPSAPI+83,     /* Call code of the fps_endwindowmessaging() function */
    FPSAPI_CALL_GET_BUTTON_EVENT            = FPS_CALL_GROUP_FPSAPI+84,     /* Call code of the fps_getbuttonevent() function */
    FPSAPI_CALL_SUSPEND                     = FPS_CALL_GROUP_FPSAPI+85,     /* Call code of the fps_suspend() function */
    FPSAPI_CALL_WAKEUP                      = FPS_CALL_GROUP_FPSAPI+86,     /* Call code of the fps_wakeup() function */
    FPSAPI_CALL_GET_UDINFO                  = FPS_CALL_GROUP_FPSAPI+94,     /* Call code of the fps_getudinfo() function */
    FPSAPI_CALL_READ_UD                     = FPS_CALL_GROUP_FPSAPI+95,     /* Call code of the fps_readudata() function */
    FPSAPI_CALL_WRITE_UD                    = FPS_CALL_GROUP_FPSAPI+96,     /* Call code of the fps_writeudata() function */
    FPSAPI_CALL_GETIMAGE_V                  = FPS_CALL_GROUP_FPSAPI+130,    /* Call code of the fps_getimage() function */
    FPSAPI_CALL_GETDEVICEINFO               = FPS_CALL_GROUP_FPSAPI+131,    /* Call code of the fps_getdeviceinfo() function */
    FPSAPI_CALL_CAPTURE                     = FPS_CALL_GROUP_FPSAPI+136,    /* Call code of the fps_capture() function */
    FPSAPI_CALL_CAPTURE_START               = FPS_CALL_GROUP_FPSAPI+137,    /* Call code of the fps_capture_start() function */
    FPSAPI_CALL_RESETFINGERLIST             = FPS_CALL_GROUP_FPSAPI+138,    /* Call code of the fps_resetfingerlist() function */
    FPSAPI_CALL_FINGERSTONIST               = FPS_CALL_GROUP_FPSAPI+139,    /* Call code of the fps_fingertonist() function */
    FPSAPI_CALL_FINGERSTONISTA              = FPS_CALL_GROUP_FPSAPI+140,    /* Call code of the fps_fingertonista() function */
    FPSAPI_CALL_FINGERSTONISTMEM            = FPS_CALL_GROUP_FPSAPI+141,    /* Call code of the fps_fingertonistmem() function */
    FPSAPI_CALL_GETDEVICELIST               = FPS_CALL_GROUP_FPSAPI+147,    /* Call code of the fps_getfingerdevicelist() function (Unicode version). */
    FPSAPI_CALL_GETDEVICELISTA              = FPS_CALL_GROUP_FPSAPI+148,    /* Call code of the fps_getfingerdevicelist() function (ASCII version). */
    FPSAPI_CALL_CAPTURE_STOP                = FPS_CALL_GROUP_FPSAPI+149,    /* Call code of the fps_capture_stop() function */
    FPSAPI_CALL_NISTFINGERQUALITY           = FPS_CALL_GROUP_FPSAPI+150,    /* Call code of the fps_nistfingerquality() function  */
    FPSAPI_CALL_BLINK_STATUS                = FPS_CALL_GROUP_FPSAPI+151,    /* Call code of the fps_blinkstatus() function */
};

/*******************************************************************************
 * module structures
 ******************************************************************************/

/*
    Parameter structure for the fps_..._getstatus asynchronous functions.
*/
struct FPSAPI_PARM_GETSTATUS {
    int reqid;              /* Id returned by the fps_..._start asynchronous function. */
    int status;             /* The state of the process in percent, it can be negative when the task is in
                                preprocess state. */
};

/*
    Parameter structure for the fps_getdevicelist() function (Unicode version).
*/
struct FPSAPI_PARM_GETDEVICELIST {
    wchar_t **devices;      /* List of the device names. */
    bool *calibrated;       /* Obsolete parameter. */
    int ndevices;           /* Number of devices */
};

/*
    Parameter structure for the fps_getdevicelist() function (ASCII version).
*/
struct FPSAPI_PARM_GETDEVICELISTA {
    char **devices;         /* List of the device names. */
    bool *calibrated;       /* Obsolete parameter. */
    int ndevices;           /* Number of the devices. */
};

/*
    Parameter structure for the fps_usedevice() function (Unicode version).
*/
struct FPSAPI_PARM_USEDEVICE {
    const wchar_t *device;  /* Name of the device to connect to. */
    int mode;               /* Connection mode. The possible values are defined in the FPS_USAGEMODE
                                enumeration. Generally the FPS_UMODE_FULL_CONTROL is recommended to use. */
};

/*
    Parameter structure for the fps_usedevice() function (ASCII version).
*/
struct FPSAPI_PARM_USEDEVICEA {
    const char *device;     /* Name of the device to connect to. */
    int mode;               /* Connection mode. The possible values are defined in the FPS_USAGEMODE
                                enumeration. Generally the FPS_UMODE_FULL_CONTROL is recommended to use. */
};

/*
    Parameter structure for the fps_calibrate() function.
*/
struct FPSAPI_PARM_CALIBRATE {
    int windowid;           /* Id of the used window. The possible values are defined in the FPS_WINDOW_ID
                                enumeration. */
};

/*
    Parameter structure for the fps_iscalibrated() function.
*/
struct FPSAPI_PARM_ISCALIBRATED {
    int windowid;           /* Id of the used window. The possible values are defined in the FPS_WINDOW_ID
                                enumeration. */
};

#endif/* GX_SWIGIF GX_MANUAL )*/
#if !defined(GX_SWIGIF) && !(defined(GX_MANUAL) && defined(GX_DOTNET))  /*(*/

typedef void GXAPI FPS_EVFUNC(int event,int param1,int param2,void* uparam);

#endif/* GX_SWIGIF GX_MANUAL GX_DOTNET )*/
#if !defined(GX_SWIGIF) && !defined(GX_MANUAL)  /*(*/

/*
    Parameter structure for the fps_seteventfunction() function.
*/
struct FPSAPI_PARM_SETEVENTFUNCTION {
    FPS_EVFUNC *func;       /* Reference to the callback function. */
    void *param;            /* User parameter. */
};

/*
    Parameter structure for the fps_testpresence() function.
*/
struct FPSAPI_PARM_TEST_PRESENCE {
    int state;              /* The result of the presence test. */
    int windowid;           /* Id of the used window. The possible values are defined in the FPS_WINDOW_ID
                                enumeration. */
};

/*
    Parameter structure for the fps_capture_wait() function.
*/
struct FPSAPI_PARM_CAPTURE_WAIT {
    int reqid;              /* Id returned by the fps_capture_start() function. */
};

/*
    Parameter structure for the fps_capture_preview() function.
*/
struct FPSAPI_PARM_CAPTURE_PREVIEW {
    int windowid;           /* Id of the used window. The possible values are defined in the FPS_WINDOW_ID enumeration. */
};

/*
    Parameter structure for the fps_getimage() function.
*/
struct FPSAPI_PARM_GETIMAGE_V {
    int smode;              /* The actual scan mode of the image. The possible values are defined in
                                FPS_IMPRESSION_TYPE enumeration. */
    int position;           /* The finger position. The possible values are defined in the
                                FPS_POSITION enumeration. */
    int type;               /* The type of the image. The possible values are defined in the FPS_IMAGE_TYPE
                                enumeration. If the type is FPS_IT_PREVIEW the smode and position parameters have no meanings. */
    gxVARIANT img;          /* Reference for the image. */
};

/*
    Parameter structure for the fps_saveimage() function (Unicode version).
*/
struct FPSAPI_PARM_SAVEIMAGE {
    int smode;              /* The actual scan mode of the image. The possible values are defined in
                                FPS_IMPRESSION_TYPE enumeration. */
    int position;           /* The finger position. The possible values are defined in the
                                FPS_POSITION enumeration. */
    int type;               /* The type of the image. The possible values are defined in the FPS_IMAGE_TYPE
                                enumeration. If the type is FPS_IT_PREVIEW the smode and position parameters have no meanings. */
    const wchar_t *filename;/* The name of the file for saving the image. */
    int filetype;           /* The type of the file. The currently supported file types are defined in the file gximage.h . */
};

/*
    Parameter structure for the fps_saveimage() function (ASCII version).
*/
struct FPSAPI_PARM_SAVEIMAGEA {
    int smode;              /* The actual scan mode of the image. The possible values are defined in
                                FPS_IMPRESSION_TYPE enumeration. */
    int position;           /* The finger position. The possible values are defined in the
                                FPS_POSITION enumeration. */
    int type;               /* The type of the image. The possible values are defined in the FPS_IMAGE_TYPE
                                enumeration. If the type is FPS_IT_PREVIEW the smode and position parameters have no meanings. */
    const char *filename;   /* The name of the file for saving the image. */
    int filetype;           /* The type of the file. The currently supported file types are defined in the file gximage.h . */
};

#if defined(WIN32) && !defined(GX_DOTNET)

/*
    Parameter structure for the fps_drawimage() function.
*/
struct FPSAPI_PARM_DRAWIMAGE {
    int smode;              /* The actual scan mode of the image. The possible values are defined in
                                FPS_IMPRESSION_TYPE enumeration. */
    int position;           /* The finger position. The possible values are defined in the
                                FPS_POSITION enumeration. */
    int type;               /* The type of the image. The possible values are defined in the FPS_IMAGE_TYPE
                                enumeration. If the type is FPS_IT_PREVIEW the smode and position parameters have no meanings. */
    HDC hdc;                /* Handle to the device context. */
    int x;                  /* Left side of the drawing area. */
    int y;                  /* Upper side of the drawing area. */
    int xsize;              /* Horizontal size of the drawing area. */
    int ysize;              /* Vertical size of the drawing area. */
    gxRCT *frame;           /* Frame of the area of the image to display. */
};

#endif/* WIN32 GX_DOTNET */

/*
    Parameter structure for the fps_nistfingerquality() function.
*/
struct FPSAPI_PARM_NISTFINGERQUALITY {
    int position;           /* The finger position. The possible values are defined in the FPS_POSITION enumeration. */
    int quality;            /* Finger NIST quality value */
};

/*
    Parameter structure for the fps_setstatusled() function.
*/
struct FPSAPI_PARM_SET_STATUS_LED {
    int ledmask;            /* Mask representing the status leds. Each bit represents a status led on the device. */
    int color;              /* The color to display on the specified status leds. The predefined values of the lights
                                are stored in the FPS_STATUS_LED_COLOR enumeration. Bit 7 represents the on/off
                                parameter of the light so any value below 80 hex means led off.*/
};

/*
    Parameter structure for the fps_blinkstatus() function.
*/
struct FPSAPI_PARM_BLINK_STATUS {
    int coding;             /* Coding of the data. The possible values are:
                                0: stop pulses,
                                1: data[odd]: time duration output high level [ms], data[even]: time duration output low level [ms]
                            */
    int iteration;          /* Number of repeat, 0 menas forever. */
    int mask;               /* Mask representing the status leds and buzzer. Each bit represents a status led or buzzer on the device. */
    int type;               /* Led color id or buzzer id. Its predefined values are stored in the
                                \ref FPS_STATUS_LED_COLOR and \ref FPS_BUZZER enumerations. */
    unsigned int datalength;/* Length of the data, (maximum 16). */
    unsigned int *data;     /* Data of blinking. */
};
/*
    Parameter structure for the fps_testpower() function.
*/
struct FPSAPI_PARM_TEST_POWER {
    int state;              /* Device state mask. */
    int level;              /* Battery power level. */
};

/*
    Parameter structure for the fps_testbutton() function.
*/
struct FPSAPI_PARM_TEST_BUTTON {
    int code;               /* Code of the button. */
    int state;              /* State of the button. */
};

/*
    Parameter structure for the fps_getbuttonevent() function.
*/
struct FPSAPI_PARM_GET_BUTTON_EVENT {
    int code;               /* Code of the button. */
    int state;              /* State of the button. */
};

/*
    Parameter structure for the fps_beginwindowmessaging() function.
*/
struct FPSAPI_PARM_BEGIN_WINDOW_MESSAGING {
#if defined(WIN32)
    HWND hwnd;              /* Window handle to send the messages to. */
    UINT base_msg;          /* Message id base. */
#else
    int rfu1;
#endif
};

/*
    Parameter structure for the fps_getudinfo() function.
*/
struct FPSAPI_PARM_GET_UDINFO {
    int nblocks;            /* Number of blocks. */
    int sblock;             /* Size of a block. */
};

/*
    Parameter structure for the fps_readudata() function.
*/
struct FPSAPI_PARM_READ_UD {
    int fblock;             /* First block to read. */
    int nblocks;            /* Number of blocks to read. */
    void *data;             /* Bytes read. */
};

/*
    Parameter structure for the fps_writeudata() function.
*/
struct FPSAPI_PARM_WRITE_UD {
    int fblock;             /* First block to write. */
    int nblocks;            /* Number of blocks to write. */
    const void *data;       /* Bytes to write. */
};

/*
    Parameter structure for the fps_getdeviceinfo() function.
*/
struct FPSAPI_PARM_GETDEVICEINFO {
    gxVARIANT devinfo;      /* Device info. */
};

/*
    Parameter structure for the fps_capture() function.
*/
struct FPSAPI_PARM_CAPTURE {
    int timeout;        /* Timeout. */
    int quality;        /* Quality. */
    int mode;           /* Capture mode. */
    int fingerlist;     /* Finger list. */
};

/*
    Parameter structure for the fps_capture_start() function.
*/
struct FPSAPI_PARM_CAPTURE_START {
    int timeout;        /* Timeout. */
    int quality;        /* Quality. */
    int mode;           /* Capture mode. */
    int fingerlist;     /* Finger list. */
    int reqid;          /* Returned id for use in fps_capture_getstatus()
                        and fps_capture_wait() functions. */
};

/*
    Parameter structure for the fps_fingertonist() function.
*/
struct FPSAPI_PARM_FINGERSTONIST {
    const wchar_t *filename;    /* The name of the file for saving the data. */
    gxVARIANT       fields;     /* List of fields to add to the record. */
};

/*
    Parameter structure for the fps_fingertonista() function.
*/
struct FPSAPI_PARM_FINGERSTONISTA {
    const char *filename;   /* The name of the file for saving the data. */
    gxVARIANT   fields;     /* List of fields to add to the record. */
};

/*
    Parameter structure for the fps_fingertonistmem() function.
*/
struct FPSAPI_PARM_FINGERSTONISTMEM {
    void    **buffer;       /* Pointer to a memory area pointer. */
    gxi32   *buflen;        /* Size of memory area. */
    gxVARIANT   fields;     /* List of fields to add to the record. */
};

#endif/* GX_SWIGIF GX_MANUAL )*/

/*******************************************************************************
 * functions
 ******************************************************************************/

#if !defined(NO_GX_FUNCTIONS) && !defined(GX_SWIGIF)    /*(*/

inline int fps_getdevicelist(gxHANDLE handle,wchar_t ***devices,int *ndevices) {
    struct FPSAPI_PARM_GETDEVICELIST gdl;
    int ret;
    assert(devices && ndevices);
    ret = gx_call(handle, FPSAPI_CALL_GETDEVICELIST, &gdl);
    *devices = gdl.devices;
    *ndevices = gdl.ndevices;
    return ret;
}

inline int fps_getdevicelista(gxHANDLE handle,char ***devices,int *ndevices) {
    struct FPSAPI_PARM_GETDEVICELISTA gdl;
    int ret;
    assert(devices && ndevices);
    ret = gx_call(handle, FPSAPI_CALL_GETDEVICELISTA, &gdl);
    *devices = gdl.devices;
    *ndevices = gdl.ndevices;
    return ret;
}

#ifdef __cplusplus

inline int fps_getdevicelist(gxHANDLE handle,char ***devices,int *ndevices) {
    return fps_getdevicelista(handle,devices,ndevices);
}
#endif

inline int fps_usedevice(gxHANDLE handle,const wchar_t *device,int mode) {
    struct FPSAPI_PARM_USEDEVICE ud;
    assert(device);
    ud.device = device;
    ud.mode = mode;
    return gx_call(handle, FPSAPI_CALL_USEDEVICE, &ud);
}

inline int fps_usedevicea(gxHANDLE handle,const char *device,int mode) {
    struct FPSAPI_PARM_USEDEVICEA ud;
    assert(device);
    ud.device = device;
    ud.mode = mode;
    return gx_call(handle, FPSAPI_CALL_USEDEVICEA, &ud);
}

inline int fps_usedevicen(gxHANDLE handle,int devno,int mode) {
    char **devlist;
    int ndev,ret;
    assert(devno>=0);

    if(!fps_getdevicelista(handle,&devlist,&ndev))return 0;
    if(ndev<=devno){
        if(ndev)gx_globalfree(devlist);
        gx_seterror(_GX_ENOENT,L"No device found");
        return false;
    }

    ret=fps_usedevicea(handle,devlist[devno],mode);
    gx_globalfree(devlist);
    return ret;
}

#ifdef __cplusplus

inline int fps_usedevice(gxHANDLE handle,const char *device,int mode) {
    return fps_usedevicea(handle,device,mode);
}

inline int fps_usedevice(gxHANDLE handle,int devno,int mode) {
    return fps_usedevicen(handle,devno,mode);
}
#endif

inline int fps_closedevice(gxHANDLE handle) {
    struct FPSAPI_PARM_USEDEVICEA ud;
    ud.device = 0;
    ud.mode=_FPS_UMODE_DISCONNECT;
    return gx_call(handle, FPSAPI_CALL_USEDEVICEA, &ud);
}
#if 0

inline int fps_calibrate(gxHANDLE handle,int windowid GX_DEFARG(0)) {
    struct FPSAPI_PARM_CALIBRATE cal;
    cal.windowid = windowid;
    return gx_call(handle, FPSAPI_CALL_CALIBRATE, &cal);
}

inline int fps_iscalibrated(gxHANDLE handle,int windowid GX_DEFARG(0)) {
    struct FPSAPI_PARM_ISCALIBRATED cal;
    cal.windowid = windowid;
    return gx_call(handle, FPSAPI_CALL_ISCALIBRATED, &cal);
}
#endif

inline int fps_testpresence(gxHANDLE handle,int *state,int windowid GX_DEFARG(0)) {
    struct FPSAPI_PARM_TEST_PRESENCE td;
    int ret;
    assert(state);
    td.windowid = windowid;
    ret = gx_call(handle, FPSAPI_CALL_TEST_PRESENCE, &td);
    if(state)*state = td.state;
    return ret;
}

inline int fps_setstatusled(gxHANDLE handle, int ledmask, int color) {
    struct FPSAPI_PARM_SET_STATUS_LED led;
    led.ledmask = ledmask;
    led.color = color;
    return gx_call(handle, FPSAPI_CALL_SET_STATUS_LED, &led);
}

inline int fps_blinkstatus(gxHANDLE handle, int coding, int mask, int type, int iteration, unsigned int *data, unsigned int datalength) {

    struct FPSAPI_PARM_BLINK_STATUS out_data;

    out_data.coding = coding;
    out_data.mask = mask;
    out_data.type = type;
    out_data.iteration = iteration;
    out_data.data = data;
    out_data.datalength = datalength;

    return gx_call(handle, FPSAPI_CALL_BLINK_STATUS, &out_data);
}
inline int fps_testpower(gxHANDLE handle, int *state, int *level) {
    struct FPSAPI_PARM_TEST_POWER tp;
    int ret;
    assert(state);
    ret = gx_call(handle, FPSAPI_CALL_TEST_POWER, &tp);
    if(state)*state = tp.state;
    if(level)*level = tp.level;
    return ret;
}

inline int fps_testbutton(gxHANDLE handle, int keycode, int *state) {
    struct FPSAPI_PARM_TEST_BUTTON bt;
    int ret;
    assert(state);
    bt.code = keycode;
    ret = gx_call(handle, FPSAPI_CALL_TEST_BUTTON, &bt);
    if(state)*state = bt.state;
    return ret;
}

inline int fps_getbuttonevent(gxHANDLE handle, int *keycode, int *state) {
    struct FPSAPI_PARM_GET_BUTTON_EVENT bt;
    int ret;
    assert(state);
    assert(keycode);
    ret = gx_call(handle, FPSAPI_CALL_GET_BUTTON_EVENT, &bt);
    if(state)*state = bt.state;
    if(keycode)*keycode = bt.code;
    return ret;
}

inline int fps_suspend(gxHANDLE handle) {
    return gx_call(handle,FPSAPI_CALL_SUSPEND,0);
}

inline int fps_wakeup(gxHANDLE handle) {
    return gx_call(handle,FPSAPI_CALL_WAKEUP,0);
}

inline int fps_getudinfo(gxHANDLE handle, int *nblocks, int *sblock) {
    struct FPSAPI_PARM_GET_UDINFO gi;
    int ret;
    assert(nblocks);
    assert(sblock);
    ret = gx_call(handle, FPSAPI_CALL_GET_UDINFO, &gi);
    if(nblocks)*nblocks = gi.nblocks;
    if(sblock)*sblock = gi.sblock;
    return ret;
}

inline int fps_readudata(gxHANDLE handle, int fblock, int nblocks, void **data) {
    struct FPSAPI_PARM_READ_UD ru;
    int ret;
    assert(data);
    ru.fblock = fblock;
    ru.nblocks = nblocks;
    ret = gx_call(handle, FPSAPI_CALL_READ_UD, &ru);
    if(data)*data = ru.data;
    return ret;
}

inline int fps_writeudata(gxHANDLE handle, int fblock, int nblocks, const void *data) {
    struct FPSAPI_PARM_WRITE_UD wu;
    wu.fblock = fblock;
    wu.nblocks = nblocks;
    wu.data = data;
    return gx_call(handle, FPSAPI_CALL_WRITE_UD, &wu);
}

inline int fps_getdeviceinfo(gxHANDLE handle, gxVARIANT *devinfo) {
    struct FPSAPI_PARM_GETDEVICEINFO gdi;
    int ret;
    assert(devinfo);
    ret = gx_call(handle, FPSAPI_CALL_GETDEVICEINFO, &gdi);
    if(ret && devinfo)*devinfo = gdi.devinfo;
    return ret;
}

inline int fps_seteventfunction(gxHANDLE handle, FPS_EVFUNC *eventhandler, void *param) {
    struct FPSAPI_PARM_SETEVENTFUNCTION sef;
    sef.func = eventhandler;
    sef.param = param;
    return gx_call(handle, FPSAPI_CALL_SETEVENTFUNCTION, &sef);
}

#if (defined(WIN32) || defined(GX_MANUAL)) && !defined(GX_SWIG)

inline int fps_beginwindowmessaging(gxHANDLE handle, HWND hwnd, UINT base_msg GX_DEFARG(WM_USER)) {
    struct FPSAPI_PARM_BEGIN_WINDOW_MESSAGING bwm;
    bwm.hwnd = hwnd;
    bwm.base_msg = base_msg;
    return gx_call(handle,FPSAPI_CALL_BEGIN_WINDOW_MESSAGING,&bwm);
}

inline int fps_endwindowmessaging(gxHANDLE handle) {
    return gx_call(handle,FPSAPI_CALL_END_WINDOW_MESSAGING,0);
}

#endif/* WIN32 GX_SWIG */

#if (defined(LINUX) || defined(GX_MANUAL)) && !defined(GX_SWIG)

inline int fps_startbgprocesses(gxHANDLE handle) {
    struct FPSAPI_PARM_BEGIN_WINDOW_MESSAGING bwm;
    return gx_call(handle,FPSAPI_CALL_BEGIN_WINDOW_MESSAGING,&bwm);
}

inline int fps_stopbgprocesses(gxHANDLE handle) {
    return gx_call(handle,FPSAPI_CALL_END_WINDOW_MESSAGING,0);
}

#endif/* LINUX GX_SWIG */

inline int fps_capture(gxHANDLE handle, int timeout, int quality, int mode, int fingerlist) {
    struct FPSAPI_PARM_CAPTURE param;
    param.timeout = timeout;
    param.quality = quality;
    param.mode = mode;
    param.fingerlist = fingerlist;
    return gx_call(handle, FPSAPI_CALL_CAPTURE, &param);
}

inline int fps_capture_start(gxHANDLE handle, int timeout, int quality, int mode,
                                  int fingerlist, int *reqid) {
    struct FPSAPI_PARM_CAPTURE_START param;
    int ret;
    param.timeout = timeout;
    param.quality = quality;
    param.mode = mode;
    param.fingerlist = fingerlist;
    ret = gx_call(handle, FPSAPI_CALL_CAPTURE_START, &param);
    if(reqid) *reqid = param.reqid;
    return ret;
}

inline int fps_capture_getstatus(gxHANDLE handle,int reqid,int *status) {
    struct FPSAPI_PARM_GETSTATUS stat;
    int ret;
    assert(status);
    stat.reqid = reqid;
    ret = gx_call(handle, FPSAPI_CALL_CAPTURE_GETSTATUS, &stat);
    if(status) *status = stat.status;
    return ret;
}

inline int fps_capture_stop(gxHANDLE handle) {
    return gx_call(handle, FPSAPI_CALL_CAPTURE_STOP, 0);
}

inline int fps_capture_wait(gxHANDLE handle,int reqid) {
    struct FPSAPI_PARM_CAPTURE_WAIT cap;
    cap.reqid = reqid;
    return gx_call(handle, FPSAPI_CALL_CAPTURE_WAIT, &cap);
}

inline int fps_capture_preview(gxHANDLE handle,int windowid GX_DEFARG(0)) {
    struct FPSAPI_PARM_CAPTURE_PREVIEW cap;
    cap.windowid = windowid;
    return gx_call(handle, FPSAPI_CALL_CAPTURE_PREVIEW, &cap);
}

inline int fps_getimage(gxHANDLE handle,int smode,int position,int type,gxVARIANT *img) {
    struct FPSAPI_PARM_GETIMAGE_V gi;
    int ret;
    assert(img);
    gi.smode = smode;
    gi.position = position;
    gi.type = type;
    ret = gx_call(handle, FPSAPI_CALL_GETIMAGE_V, &gi);
    *img = gi.img;
    return ret;
}

inline int fps_saveimage(gxHANDLE handle,int smode,int position,int type,const wchar_t *filename,int filetype) {
    struct FPSAPI_PARM_SAVEIMAGE si;
    si.smode = smode;
    si.position = position;
    si.type = type;
    si.filename = filename;
    si.filetype = filetype;
    return gx_call(handle, FPSAPI_CALL_SAVEIMAGE, &si);
}

inline int fps_saveimagea(gxHANDLE handle,int smode,int position,int type,const char *filename,int filetype) {
    struct FPSAPI_PARM_SAVEIMAGEA si;
    si.smode = smode;
    si.position = position;
    si.type = type;
    si.filename = filename;
    si.filetype = filetype;
    return gx_call(handle, FPSAPI_CALL_SAVEIMAGEA, &si);
}

#ifdef __cplusplus

inline int fps_saveimage(gxHANDLE handle,int smode,int position,int type,const char *filename,int filetype) {
    return fps_saveimagea(handle,smode,position,type,filename,filetype);
}
#endif

#if (defined(WIN32) || defined(GX_MANUAL)) && !defined(GX_DOTNET)

inline int fps_drawimage(gxHANDLE handle,int smode,int position,int type,HDC hdc,int x,int y,int xsize,int ysize,gxRCT *frame) {
    struct FPSAPI_PARM_DRAWIMAGE di;
    di.smode = smode;
    di.position = position;
    di.type = type;
    di.hdc = hdc;
    di.x = x;
    di.y = y;
    di.xsize = xsize;
    di.ysize = ysize;
    di.frame = frame;
    return gx_call(handle, FPSAPI_CALL_DRAWIMAGE, &di);
}
#endif/* WIN32 GX_DOTNET */

inline int fps_fingertonist(gxHANDLE handle,const wchar_t *filename,gxVARIANT fields) {
    struct FPSAPI_PARM_FINGERSTONIST fn;
    fn.filename = filename;
    fn.fields = fields;
    return gx_call(handle, FPSAPI_CALL_FINGERSTONIST, &fn);
}

inline int fps_fingertonista(gxHANDLE handle,const char *filename,gxVARIANT fields) {
    struct FPSAPI_PARM_FINGERSTONISTA fn;
    fn.filename = filename;
    fn.fields = fields;
    return gx_call(handle, FPSAPI_CALL_FINGERSTONISTA, &fn);
}

#ifdef __cplusplus

inline int fps_fingertonist(gxHANDLE handle,const char *filename,gxVARIANT fields) {
    return fps_fingertonista(handle,filename,fields);
}
#endif

inline int fps_fingertonistmem(gxHANDLE handle,void **buffer, int *buflen,gxVARIANT fields) {
    struct FPSAPI_PARM_FINGERSTONISTMEM fn;
    fn.buffer = buffer;
    fn.buflen = buflen;
    fn.fields = fields;
    return gx_call(handle, FPSAPI_CALL_FINGERSTONISTMEM, &fn);
}

inline int fps_nistfingerquality(gxHANDLE handle, int *quality, int position) {
    struct FPSAPI_PARM_NISTFINGERQUALITY nistqualityparam;
    int ret;
    nistqualityparam.position = position;
    ret = gx_call(handle, FPSAPI_CALL_NISTFINGERQUALITY, &nistqualityparam);
    if(ret && quality) *quality = nistqualityparam.quality;
    return ret;
}

inline int fps_resetfingerlist(gxHANDLE handle) {
    return gx_call(handle, FPSAPI_CALL_RESETFINGERLIST, (void*)0);
}

#endif  /*)*/

#ifdef GX_DOTNET
    #pragma managed
    #undef gxPG4
#endif

/******************************************************************************/
#if !defined(NO_GX_CLASSES) /*(*/

#if !defined(GX_MANUAL) && defined(GX_DOTNET)
//cannot compile without this
private __value struct fps_dotnetfix { gxVARIANT dat; };
#endif

GX_CLASS FingerPrintScanner : public gxHandle
#ifdef GX_DOTNET
,public System::IDisposable
#endif
{

public:

    inline FingerPrintScanner() throw(gxError) {
#ifndef GX_DOTNET
        if(!gx_openmodule(this, L"prapi", L"default")) gxthrow;
#else
        GX_GETHANDLE(h);
        if(!gx_openmodule(&h, L"prapi", L"default")) gxthrow;
        _set_handle(h.handle);
#endif
    }

    inline void Dispose(void) {
#ifdef GX_DOTNET
        System::GC::SuppressFinalize(this);
#endif
        gxHandle::Dispose();
    }

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool GetDeviceList(wchar_t ***devices,int *ndevices) throw(gxError) {
        bool st = fps_getdevicelist(*this,devices,ndevices)!=0;
        gxcondthrow(!st);
        return st;
    }

    inline bool GetDeviceList(char ***devices,int *ndevices) throw(gxError) {
        bool st = fps_getdevicelist(*this,devices,ndevices)!=0;
        gxcondthrow(!st);
        return st;
    }
#endif

#ifdef GX_UNICODE

    inline gxOutStrArray GetDeviceList(void) throw(gxError) {
        wchar_t **devices;
        int ndevices = 0;
        GX_GETHANDLE(h);
        if(!fps_getdevicelist(h,&devices,&ndevices)) {
            gxthrow;
            return GX_PUTGSTRINGARRAY_NONE;
        }
        return GX_PUTGSTRINGARRAY(devices, ndevices, true);
    }
#endif

#ifdef GX_ASCII

    inline gxOutAStrArray GetDeviceListA(void) throw(gxError) {
        char **devices;
        int ndevices = 0;
        if(!fps_getdevicelist(*this,&devices,&ndevices)) {
            gxthrow;
            return GX_PUTGASTRINGARRAY_NONE;
        }
        return GX_PUTGASTRINGARRAY(devices, ndevices, true);
    }
#endif

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool UseDevice(const wchar_t *device,int mode) throw(gxError) {
        bool st = fps_usedevice(*this,device,mode)!=0;
        gxcondthrow(!st);
        return st;
    }

    inline bool UseDevice(const char *device,int mode) throw(gxError) {
        bool st = fps_usedevice(*this,device,mode)!=0;
        gxcondthrow(!st);
        return st;
    }
#endif

#ifdef GX_UNICODE

    inline bool UseDevice(gxInStr device,int mode) throw(gxError) {
        GX_GETSTRING(_device, device);
        GX_GETHANDLE(h);
        bool st = fps_usedevice(h, _device,mode)!=0;
        gxcondthrow(!st);
        return st;
    }
#endif

#ifdef GX_ASCII

    inline bool UseDevice(gxInAStr device,int mode) throw(gxError) {
        GX_GETASTRING(_device, device);
        GX_GETHANDLE(h);
        bool st = fps_usedevice(h, _device,mode)!=0;
        gxcondthrow(!st);
        return st;
    }
#endif

    inline bool UseDevice(int devno,int mode) throw(gxError) {
        GX_GETHANDLE(h);
        bool st = fps_usedevice(h,devno,mode)!=0;
        gxcondthrow(!st);
        return st;
    }

    inline bool CloseDevice(void) throw(gxError) {
        GX_GETHANDLE(h);
        bool st = fps_closedevice(h)!=0;
        gxcondthrow(!st);
        return st;
    }
#if 0

    inline bool Calibrate(int windowid GX_DEFARG(0)) throw(gxError) {
        GX_GETHANDLE(h);
        bool st = fps_calibrate(h,windowid)!=0;
        gxcondthrow(!st);
        return st;
    }

    inline bool IsCalibrated(int windowid GX_DEFARG(0)) {
        GX_GETHANDLE(h);
        return fps_iscalibrated(h,windowid)!=0;
    }
#endif

    inline int TestPresence(int windowid GX_DEFARG(0)) {
        int state;
        GX_GETHANDLE(h);
        return fps_testpresence(h,&state,windowid) ? state : -1;
    }

    inline bool SetStatusLed(int ledmask, int color) throw(gxError) {
        GX_GETHANDLE(h);
        bool st = fps_setstatusled(h, ledmask, color)!=0;
        gxcondthrow(!st);
        return st;
    }

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool BlinkStatus(int coding, int mask, int type, int iteration, unsigned int *data, unsigned int datalength) throw(gxError) {
        GX_GETHANDLE(h);
        bool st = fps_blinkstatus(h, coding, mask, type, iteration, data, datalength)!=0;
        gxcondthrow(!st);
        return st;
    }
#endif

#ifndef NO_GX_STL

    inline bool BlinkStatus(int coding, int mask, int type, int iteration, gxInIntArray data) {
        GX_GETHANDLE(h);
        GX_GETININTARRAY(data);
        bool st = fps_blinkstatus(h, coding, mask, type, iteration,(unsigned int *)GX_GETININTARRAY_PTR(data), GX_GETININTARRAY_LEN(data))!=0;
        GX_FREEININTARRAY(data);
        gxcondthrow(!st);
        return st;
    }
#endif

    inline int TestPowerState(void) {
        int state;
        GX_GETHANDLE(h);
        return fps_testpower(h,&state,0) ? state : -1;
    }

    inline int TestPowerLevel(void) {
        int state,level;
        GX_GETHANDLE(h);
        return fps_testpower(h,&state,&level) ? level : -1;
    }

    inline int TestButton(int keycode) {
        int state;
        GX_GETHANDLE(h);
        return fps_testbutton(h,keycode,&state) ? state : -1;
    }

    inline bool Suspend() {
        GX_GETHANDLE(h);
        bool st = fps_suspend(h)!=0;
        gxcondthrow(!st);
        return st;
    }

    inline bool WakeUp() {
        GX_GETHANDLE(h);
        bool st = fps_wakeup(h)!=0;
        gxcondthrow(!st);
        return st;
    }

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool GetUDInfo(int *nblocks, int *sblock) throw(gxError) {
        GX_GETHANDLE(h);
        bool st = fps_getudinfo(h, nblocks, sblock) != 0;
        gxcondthrow(!st);
        return st;
    }

    inline bool ReadUData(int fblock, int nblocks, void **data) throw(gxError) {
        GX_GETHANDLE(h);
        bool st = fps_readudata(h, fblock, nblocks, data) != 0;
        gxcondthrow(!st);
        return st;
    }

    inline bool WriteUData(int fblock, int nblocks, const void *data) throw(gxError) {
        GX_GETHANDLE(h);
        bool st = fps_writeudata(h, fblock, nblocks, data) != 0;
        gxcondthrow(!st);
        return st;
    }
#else

    inline gxOutData ReadUData(int fblock, int nblocks) throw(gxError) {
        GX_GETHANDLE(h);
        void *data;
        if (fps_readudata(h, fblock, nblocks, &data) == 0) {
            gxthrow;
            return GX_PUTDATA_NONE;
        }
        int i,sblock;
        if (fps_getudinfo(h, &i, &sblock) == 0) {
            gxthrow;
            return GX_PUTDATA_NONE;
        }
        i=nblocks*sblock;
        gxOutData od = GX_PUTDATA(data, i);
        if(data) gx_globalfree(data);
        return od;
    }

    inline bool WriteUData(int fblock, int nblocks, gxInData data) throw(gxError) {
        GX_GETHANDLE(h);
        GX_GETDATA(data);
        bool st = fps_writeudata(h, fblock, nblocks, GX_DATAPTR(data)) != 0;
        gxcondthrow(!st);
        return st;
    }
#endif /* GX_SWIG && GX_DOTNET */

    inline int GetUDNumberOfBlocks(void) throw(gxError) {
        GX_GETHANDLE(h);
        int nblocks;
        int sblock;
        bool st = fps_getudinfo(h, &nblocks, &sblock) != 0;
        gxcondthrow(!st);
        return st ? nblocks : -1;
    }

    inline int GetUDBlockSize(void) throw(gxError) {
        GX_GETHANDLE(h);
        int nblocks;
        int sblock;
        bool st = fps_getudinfo(h, &nblocks, &sblock) != 0;
        gxcondthrow(!st);
        return st ? sblock : -1;
    }

    inline gxVariant * GetDeviceInfo() throw(gxError) {
        GX_GETHANDLE(h);
        gxVARIANT d;
        bool st = fps_getdeviceinfo(h,&d) != 0;
        gxcondthrow(!st);
        if(st) gxSystem::ClearError();
        if(!d) return 0;
        #ifndef GX_DOTNET
            gxVariant * vr = new gxVariant(d);
            gx_unrefvariant(d);
        #else
            gxVariant * vr = new gxVariant();
            vr->_set_variant(d);
        #endif
        if(!vr){gxSystem::SetError(GXEC GX_ENOMEM);gxthrow;}
        return vr;
    }

#if !defined(GX_SWIGIF) && !defined(GX_DOTNET)

    inline bool SetEventFunction(FPS_EVFUNC *eventhandler,void *param) {
        return fps_seteventfunction(*this,eventhandler,param)!=0;
    }
#endif

#if (defined(WIN32) || defined(GX_MANUAL)) && !defined(GX_SWIG)

#ifndef GX_DOTNET
    inline bool BeginWindowMessaging(HWND hwnd, UINT base_msg GX_DEFARG(WM_USER)) {
        bool st = fps_beginwindowmessaging(*this,hwnd, base_msg)!=0;
        gxcondthrow(!st);
        return st;
    }
#else
    inline bool BeginWindowMessaging(gxInPtr hwnd, UINT base_msg GX_DEFARG(WM_USER)) {
        GX_GETHANDLE(h);
        bool st = fps_beginwindowmessaging(h,hwnd.ToPointer(), base_msg)!=0;
        gxcondthrow(!st);
        return st;
    }
#endif

    inline bool EndWindowMessaging() {
        GX_GETHANDLE(h);
        bool st = fps_endwindowmessaging(h)!=0;
        gxcondthrow(!st);
        return st;
    }

#endif/* WIN32 GX_SWIG */

#if (defined(LINUX) || defined(GX_MANUAL)) && !defined(GX_SWIG)

    inline int StartBGProcesses() throw(gxError) {
        bool st = fps_startbgprocesses(*this);
        gxcondthrow(!st);
        return st;
    }

    inline int StopBGProcesses() {
        return fps_stopbgprocesses(*this);
    }

#endif/* LINUX GX_SWIG */

    inline bool Capture(int timeout, int quality, int mode, int fingerlist) throw(gxError) {
        GX_GETHANDLE(h);
        bool st = fps_capture(h, timeout, quality, mode, fingerlist)!=0;
        gxcondthrow(!st);
        return st;
    }

    inline int CaptureStart(int timeout, int quality, int mode, int fingerlist) throw(gxError) {
        GX_GETHANDLE(h);
        int reqid;
        bool st = fps_capture_start(h, timeout, quality, mode, fingerlist, &reqid)!=0;
        gxcondthrow(!st);
        return st ? reqid : -1;
    }

    inline int CaptureStatus(int reqid) throw(gxError) {
        GX_GETHANDLE(h);
        int status;
        bool st = fps_capture_getstatus(h,reqid,&status)!=0;
        gxcondthrow(!st);
        return st ? status : -1;
    }

    inline bool CaptureStop() throw(gxError) {
        GX_GETHANDLE(h);
        bool st = fps_capture_stop(h)!=0;
        gxcondthrow(!st);
        return st;
    }

    inline bool CaptureWait(int reqid) throw(gxError) {
        GX_GETHANDLE(h);
        bool st = fps_capture_wait(h,reqid)!=0;
        gxcondthrow(!st);
        return st;
    }

    inline bool CapturePreview(int windowid GX_DEFARG(0)) throw(gxError) {
        GX_GETHANDLE(h);
        bool st = fps_capture_preview(h,windowid)!=0;
        gxcondthrow(!st);
        return st;
    }

    inline gxVariant * GetImage(int smode,int position,int type) throw(gxError) {
        gxVARIANT img = 0;
        gxVariant *vimg = 0;
        GX_GETHANDLE(h);
        if(!fps_getimage(h,smode,position,type,&img)) {
            gxthrow;
            return vimg;
        }

#if !defined(GX_DOTNET) && !defined(GX_SWIG)
        if(img)
#endif
        #ifndef GX_DOTNET
        {
            vimg = new gxVariant(img);
            if(img)gx_unrefvariant(img);
        }
        #else
        {
            vimg = new gxVariant();
            vimg->_set_variant(img);
        }
        #endif
#if !defined(GX_DOTNET) && !defined(GX_SWIG)
        if(img)
#endif
            if(!vimg){gxSystem::SetError(GX_ENOMEM);gxthrow;}
        if(!img) gxSystem::ClearError();
        return vimg;
    }

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool SaveImage(int smode,int position,int type,const wchar_t *filename,int filetype) throw(gxError) {
        bool st = fps_saveimage(*this,smode,position,type,filename,filetype)!=0;
        gxcondthrow(!st);
        return st;
    }

    inline bool SaveImage(int smode,int position,int type,const char *filename,int filetype) throw(gxError) {
        bool st = fps_saveimage(*this,smode,position,type,filename,filetype)!=0;
        gxcondthrow(!st);
        return st;
    }
#endif

#ifdef GX_UNICODE

    inline bool SaveImage(int smode,int position,int type,gxInStr filename,int filetype) throw(gxError) {
        GX_GETHANDLE(h);
        GX_GETSTRING(_filename, filename);
        bool st = fps_saveimage(h,smode,position,type,_filename,filetype)!=0;
        gxcondthrow(!st);
        return st;
    }
#endif

#ifdef GX_ASCII

    inline bool SaveImage(int smode,int position,int type,gxInAStr filename,int filetype) throw(gxError) {
        GX_GETHANDLE(h);
        GX_GETASTRING(_filename, filename);
        bool st = fps_saveimage(h,smode,position,type,_filename,filetype)!=0;
        gxcondthrow(!st);
        return st;
    }
#endif

#if (defined(WIN32) || defined(GX_MANUAL)) && !defined(GX_DOTNET) && !defined(GX_SWIG)

    inline bool DisplayImage(int smode,int position,int type,HDC hdc,int x,int y,int xsize,int ysize,gxRCT *frame) throw(gxError) {
        bool st = fps_drawimage(*this,smode,position,type,hdc,x,y,xsize,ysize,frame)!=0;
        gxcondthrow(!st);
        return st;
    }
#endif

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool FingerToNist(const wchar_t *filename,gxVariant *fields) throw(gxError) {
        bool st = fps_fingertonist(*this,filename,(fields)?fields->_variant:0)!=0;
        gxcondthrow(!st);
        return st;
    }

    inline bool FingerToNist(const char *filename,gxVariant *fields) throw(gxError) {
        bool st = fps_fingertonist(*this,filename,(fields)?fields->_variant:0)!=0;
        gxcondthrow(!st);
        return st;
    }

    inline bool FingerToNistMem(void **buffer, int *buflen,gxVariant *fields) throw(gxError) {
        bool st = fps_fingertonistmem(*this,buffer,buflen,fields?fields->_variant:0)!=0;
        gxcondthrow(!st);
        return st;
    }
#endif

#ifdef GX_UNICODE

    inline bool FingerToNist(gxInStr filename,gxVariant *fields) throw(gxError) {
        GX_GETHANDLE(h);
#ifdef GX_DOTNET
        gxVARIANT var = fields?(gxVARIANT)GX_GETPTR(fields->_get_variant()):0;
#else
        gxVARIANT var = fields?fields->_variant:0;
#endif
        GX_GETSTRING(_filename, filename);
        bool st = fps_fingertonist(h,_filename,var)!=0;
        gxcondthrow(!st);
        return st;
    }
#endif

#ifdef GX_ASCII

    inline bool FingerToNist(gxInAStr filename,gxVariant *fields) throw(gxError) {
        GX_GETHANDLE(h);
        GX_GETASTRING(_filename, filename);
        bool st = fps_fingertonist(h,_filename,(fields)?fields->_variant:0)!=0;
        gxcondthrow(!st);
        return st;
    }
#endif

#if defined(GX_SWIG) || defined(GX_DOTNET)

    inline gxOutData FingerToNistMem(gxVariant *fields) throw(gxError) {
        void *buffer = (void *)0;
        gxi32 buflen = 0;
        GX_GETHANDLE(h);
#ifdef GX_DOTNET
        gxVARIANT var = fields?(gxVARIANT)GX_GETPTR(fields->_get_variant()):0;
#else
        gxVARIANT var = fields?fields->_variant:0;
#endif
        if(!fps_fingertonistmem(h,&buffer,&buflen,var)) {
            gxthrow;
            return GX_PUTDATA_NONE;
        }
        gxOutData ret = GX_PUTDATA(buffer, buflen);
        if(buffer) gx_globalfree(buffer);
        return ret;
    }
#endif

    inline int NistFingerQuality(int position) throw(gxError) {
        int quality;
        GX_GETHANDLE(h);
        if(!fps_nistfingerquality(h, &quality, position)) quality = -1;
        gxcondthrow(quality<0);
        return quality;
    }

    inline bool ResetFingerList(void) throw(gxError) {
        GX_GETHANDLE(h);
        bool st = fps_resetfingerlist(h)!=0;
        gxcondthrow(!st);
        return st;
    }
};

/******************************************************************************/
#endif/* NO_GX_CLASSES )*/
/******************************************************************************/
#ifdef GX_NAMESPACES
    }
#endif
/******************************************************************************/
#ifdef __BORLANDC__
    #pragma warn .rch
#endif
#ifdef _MSC_VER
    #pragma warning(pop)
#endif
/******************************************************************************/
#endif/* FPSAPI_INCL */

---

Generated  for Fingerprint Scanner
(c) ARH Inc.