424 lines
14 KiB
C++
424 lines
14 KiB
C++
#include "../../sdk/hginclude/huagaoxxx_warraper_ex.h"
|
|
|
|
#include "../../../sdk/include/huagao/brand.h"
|
|
#include "../../sdk/hginclude/utils.h"
|
|
#include "../hgdev/scanner_manager.h"
|
|
#include <iostream>
|
|
|
|
#include <lang/app_language.h>
|
|
#include "../hgdev/common_setting.h"
|
|
|
|
#if defined(WIN32) || defined(_WIN64)
|
|
#include <fileapi.h>
|
|
#else
|
|
#include <sys/vfs.h>
|
|
#include <string.h>
|
|
#endif
|
|
#include <math.h>
|
|
|
|
|
|
#define MAKE_VERSION(a, b, c, d) \
|
|
((((unsigned long long)(a) & 0x0ffff) << 48) \
|
|
| (((unsigned long long)(b) & 0x0ffff) << 32) \
|
|
| (((unsigned long long)(c) & 0x0ffff) << 16) \
|
|
| (((unsigned long long)(d) & 0x0ffff) << 0))
|
|
|
|
std::string g_scanner_path = "";
|
|
static std::string g_sane_name = "";
|
|
static std::string g_sane_ver = "";
|
|
|
|
namespace err_map
|
|
{
|
|
struct
|
|
{
|
|
int sane;
|
|
int scanner;
|
|
}g_err_map[] =
|
|
{ {SANE_STATUS_GOOD, SCANNER_ERR_OK}
|
|
, {SANE_STATUS_UNSUPPORTED, SCANNER_ERR_DEVICE_NOT_SUPPORT}
|
|
, {SANE_STATUS_CANCELLED, SCANNER_ERR_USER_CANCELED}
|
|
, {SANE_STATUS_DEVICE_BUSY, SCANNER_ERR_DEVICE_BUSY}
|
|
, {SANE_STATUS_INVAL, SCANNER_ERR_INVALID_PARAMETER}
|
|
, {SANE_STATUS_EOF, SCANNER_ERR_NO_DATA}
|
|
, {SANE_STATUS_JAMMED, SCANNER_ERR_DEVICE_PAPER_JAMMED}
|
|
, {SANE_STATUS_NO_DOCS, SCANNER_ERR_DEVICE_NO_PAPER}
|
|
, {SANE_STATUS_COVER_OPEN, SCANNER_ERR_DEVICE_COVER_OPENNED}
|
|
, {SANE_STATUS_IO_ERROR, SCANNER_ERR_IO}
|
|
, {SANE_STATUS_NO_MEM, SCANNER_ERR_INSUFFICIENT_MEMORY}
|
|
, {SANE_STATUS_ACCESS_DENIED, SCANNER_ERR_ACCESS_DENIED}
|
|
};
|
|
|
|
static int sane_2_scanner(int sane)
|
|
{
|
|
for (size_t i = 0; i < _countof(g_err_map); ++i)
|
|
{
|
|
if (g_err_map[i].sane == sane)
|
|
return g_err_map[i].scanner;
|
|
}
|
|
|
|
return sane;
|
|
}
|
|
static int scanner_2_sane(int scanner)
|
|
{
|
|
for (size_t i = 0; i < _countof(g_err_map); ++i)
|
|
{
|
|
if (g_err_map[i].scanner == scanner)
|
|
return g_err_map[i].sane;
|
|
}
|
|
|
|
return scanner;
|
|
}
|
|
}
|
|
extern "C"
|
|
{
|
|
static void language_changed(int cp, void* param)
|
|
{
|
|
reload_setting_string_from_pak(cp, nullptr);
|
|
hg_scanner_mgr::instance()->on_language_changed();
|
|
}
|
|
|
|
scanner_err hg_scanner_initialize(sane_callback callback, void* reserve)
|
|
{
|
|
std::string name(""),
|
|
pe(utils::get_module_full_path()),
|
|
path(PATH_SEPARATOR),
|
|
scanner(g_scanner_path),
|
|
sane(utils::get_module_full_path((g_sane_name + "." + DLL_EXTESION).c_str()));
|
|
size_t pos = pe.rfind(path[0]);
|
|
|
|
if(pos++ == std::string::npos)
|
|
pos = 0;
|
|
name = pe.substr(pos);
|
|
pe.erase(pos);
|
|
|
|
#if !defined(WIN32) && !defined(_WIN64)
|
|
g_scanner_path = utils::get_module_full_path((std::string(SCANNER_DRIVER_PART_NAME) + "." + DLL_EXTESION).c_str());
|
|
scanner = g_scanner_path;
|
|
#endif
|
|
pos = g_scanner_path.rfind(path[0]);
|
|
if (pos++ != std::string::npos)
|
|
g_scanner_path.erase(pos);
|
|
|
|
utils::init_log(LOG_TYPE_FILE);
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Module device: [%u.%u.%u.%u] - %s\n", VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, GET_BUILD_VER, scanner.c_str());
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Module sane : [%s] - %s\n", g_sane_ver.c_str(), sane.c_str());
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Module exe : %s\n", (pe + name).c_str());
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Current Path : %s\n", utils::get_command_result("pwd").c_str());
|
|
|
|
if (lang_initialize() == -1)
|
|
{
|
|
utils::to_log(LOG_LEVEL_FATAL, "No language package found!\n");
|
|
return SCANNER_ERR_LANG_PAK_LOST;
|
|
}
|
|
else
|
|
{
|
|
std::string lang(utils::get_ini_value("language", "code-page", nullptr));
|
|
if(!lang.empty())
|
|
{
|
|
lang_set_code_page(atoi(lang.c_str()));
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Found the language specified by user: %s, code-page after set = %d\n", lang.c_str(), lang_get_cur_code_page());
|
|
}
|
|
}
|
|
register_language_changed_notify(language_changed, true);
|
|
|
|
hg_scanner_mgr::set_version(VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, GET_BUILD_VER);
|
|
hg_scanner_mgr::set_exe_name(pe.c_str(), name.c_str());
|
|
hg_scanner_mgr::instance(callback);
|
|
|
|
return SCANNER_ERR_OK;
|
|
}
|
|
void hg_scanner_uninitialize(void)
|
|
{
|
|
register_language_changed_notify(language_changed, false);
|
|
hg_scanner_mgr::clear();
|
|
utils::uninit();
|
|
}
|
|
|
|
unsigned long long hg_scanner_get_version(void)
|
|
{
|
|
return MAKE_VERSION(VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, GET_BUILD_VER);
|
|
}
|
|
|
|
scanner_err hg_scanner_enum(ScannerInfo* scanner_list, long* count, bool local_only)
|
|
{
|
|
return hg_scanner_mgr::instance()->hg_scanner_enum(scanner_list, count, local_only);
|
|
}
|
|
|
|
scanner_err hg_scanner_open(scanner_handle* h, const char* name, bool shared, const char* user, const char* pwd, const char* check, char* rsc)
|
|
{
|
|
return hg_scanner_mgr::instance()->hg_scanner_open(h, name, shared, user, pwd, check, rsc);
|
|
}
|
|
|
|
scanner_err hg_scanner_close(scanner_handle h, bool force)
|
|
{
|
|
return hg_scanner_mgr::instance()->hg_scanner_close(h, force);
|
|
}
|
|
|
|
scanner_err hg_scanner_get_parameter(scanner_handle h, const char* name, char* data, long* len, SANE_Int* id)
|
|
{
|
|
return hg_scanner_mgr::instance()->hg_scanner_get_parameter(h, name, data, len, id);
|
|
}
|
|
|
|
scanner_err hg_scanner_set_parameter(scanner_handle h, const char* name, void* data, long* len)
|
|
{
|
|
return hg_scanner_mgr::instance()->hg_scanner_set_parameter(h, name, data, len);
|
|
}
|
|
|
|
scanner_err hg_scanner_start(scanner_handle h, void* async_event, int num)
|
|
{
|
|
return hg_scanner_mgr::instance()->hg_scanner_start(h, async_event, num);
|
|
}
|
|
|
|
scanner_err hg_scanner_stop(scanner_handle h)
|
|
{
|
|
return hg_scanner_mgr::instance()->hg_scanner_stop(h);
|
|
}
|
|
|
|
scanner_err hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len)
|
|
{
|
|
return hg_scanner_mgr::instance()->hg_scanner_get_img_info(h, bmi, len);
|
|
}
|
|
|
|
scanner_err hg_scanner_read_img_data(scanner_handle h, unsigned char* data, long* len)
|
|
{
|
|
return hg_scanner_mgr::instance()->hg_scanner_read_img_data(h, data, len);
|
|
}
|
|
|
|
|
|
scanner_err hg_scanner_get_status(scanner_handle h, int setstutas)
|
|
{
|
|
return hg_scanner_mgr::instance()->hg_scanner_get_status(h, setstutas);
|
|
}
|
|
|
|
scanner_err hg_scanner_reset(scanner_handle h)
|
|
{
|
|
return hg_scanner_mgr::instance()->hg_scanner_reset(h);
|
|
}
|
|
|
|
scanner_err hg_scanner_control(scanner_handle h, unsigned long code, void* data, unsigned* len)
|
|
{
|
|
return hg_scanner_mgr::instance()->hg_scanner_control(h, code, data, len);
|
|
}
|
|
|
|
void hg_scanner_set_sane_info(const char* name, const char* ver)
|
|
{
|
|
g_sane_name = name;
|
|
g_sane_ver = ver;
|
|
}
|
|
const char* hg_scanner_err_name(int err)
|
|
{
|
|
RETURN_IF(err, SANE_STATUS_GOOD);
|
|
RETURN_IF(err, SANE_STATUS_UNSUPPORTED);
|
|
RETURN_IF(err, SANE_STATUS_CANCELLED);
|
|
RETURN_IF(err, SANE_STATUS_DEVICE_BUSY);
|
|
RETURN_IF(err, SANE_STATUS_INVAL);
|
|
RETURN_IF(err, SANE_STATUS_EOF);
|
|
RETURN_IF(err, SANE_STATUS_JAMMED);
|
|
RETURN_IF(err, SANE_STATUS_NO_DOCS);
|
|
RETURN_IF(err, SANE_STATUS_COVER_OPEN);
|
|
RETURN_IF(err, SANE_STATUS_IO_ERROR);
|
|
RETURN_IF(err, SANE_STATUS_NO_MEM);
|
|
RETURN_IF(err, SANE_STATUS_ACCESS_DENIED);
|
|
RETURN_IF(err, SCANNER_ERR_INVALID_PARAMETER);
|
|
RETURN_IF(err, SCANNER_ERR_USER_CANCELED);
|
|
RETURN_IF(err, SCANNER_ERR_INSUFFICIENT_MEMORY);
|
|
RETURN_IF(err, SCANNER_ERR_ACCESS_DENIED);
|
|
RETURN_IF(err, SCANNER_ERR_IO_PENDING);
|
|
RETURN_IF(err, SCANNER_ERR_NOT_EXACT);
|
|
RETURN_IF(err, SCANNER_ERR_CONFIGURATION_CHANGED);
|
|
RETURN_IF(err, SCANNER_ERR_RELOAD_IMAGE_PARAM);
|
|
RETURN_IF(err, SCANNER_ERR_RELOAD_OPT_PARAM);
|
|
RETURN_IF(err, SCANNER_ERR_NOT_OPEN);
|
|
RETURN_IF(err, SCANNER_ERR_NOT_START);
|
|
RETURN_IF(err, SCANNER_ERR_NOT_ANY_MORE);
|
|
RETURN_IF(err, SCANNER_ERR_NO_DATA);
|
|
RETURN_IF(err, SCANNER_ERR_HAS_DATA_YET);
|
|
RETURN_IF(err, SCANNER_ERR_OUT_OF_RANGE);
|
|
RETURN_IF(err, SCANNER_ERR_IO);
|
|
RETURN_IF(err, SCANNER_ERR_TIMEOUT);
|
|
RETURN_IF(err, SCANNER_ERR_OPEN_FILE_FAILED);
|
|
RETURN_IF(err, SCANNER_ERR_CREATE_FILE_FAILED);
|
|
RETURN_IF(err, SCANNER_ERR_WRITE_FILE_FAILED);
|
|
RETURN_IF(err, SCANNER_ERR_DATA_DAMAGED);
|
|
RETURN_IF(err, SCANNER_ERR_OPENED_BY_OTHER_PROCESS);
|
|
RETURN_IF(err, SCANNER_ERR_USB_INIT_FAILED);
|
|
RETURN_IF(err, SCANNER_ERR_USB_REGISTER_PNP_FAILED);
|
|
RETURN_IF(err, SCANNER_ERR_USB_CLAIM_INTERFACE_FAILED);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_NOT_FOUND);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_NOT_SUPPORT);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_BUSY);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_SLEEPING);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_COUNT_MODE);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_STOPPED);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_COVER_OPENNED);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_NO_PAPER);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_FEEDING_PAPER);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_DOUBLE_FEEDING);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_PAPER_JAMMED);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_STAPLE_ON);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_PAPER_SKEW);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_SIZE_CHECK);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_DOGEAR);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_NO_IMAGE);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_SCANN_ERROR);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_PC_BUSY);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_ISLOCK);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_MAYBE_IS_HOLE);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_DEVS_BOOTING);
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_UNKNOWN_STATUS);
|
|
|
|
if (err == SCANNER_ERR_LANG_PAK_LOST)
|
|
return "SCANNER_ERR_LANG_PAK_LOST";
|
|
|
|
// NOTE: multi-thread unsafe here
|
|
static char g_unk_err[80] = { 0 };
|
|
sprintf(g_unk_err, "Unknown error: 0x%X", err);
|
|
|
|
return g_unk_err;
|
|
}
|
|
const char* hg_scanner_err_description(int err)
|
|
{
|
|
if (err < 0x100)
|
|
err = err_map::sane_2_scanner(err);
|
|
|
|
if (err == SCANNER_ERR_OPENED_BY_OTHER_PROCESS && *hg_scanner_mgr::instance()->last_open_message())
|
|
return hg_scanner_mgr::instance()->last_open_message();
|
|
|
|
RETURN_DESC_IF(err, SCANNER_ERR_OK);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NOT_SUPPORT);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_USER_CANCELED);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_BUSY);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_INVALID_PARAMETER);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_NO_DATA);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_PAPER_JAMMED);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NO_PAPER);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_COVER_OPENNED);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_IO);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_INSUFFICIENT_MEMORY);
|
|
|
|
RETURN_DESC_IF(err, SCANNER_ERR_ACCESS_DENIED);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_INSUFFICIENT_MEMORY);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_ACCESS_DENIED);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_IO_PENDING);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_NOT_EXACT);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_CONFIGURATION_CHANGED);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_RELOAD_IMAGE_PARAM);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_RELOAD_OPT_PARAM);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_NOT_OPEN);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_NOT_START);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_NOT_ANY_MORE);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_NO_DATA);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_HAS_DATA_YET);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_OUT_OF_RANGE);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_IO);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_TIMEOUT);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_OPEN_FILE_FAILED);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_CREATE_FILE_FAILED);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_WRITE_FILE_FAILED);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DATA_DAMAGED);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_OPENED_BY_OTHER_PROCESS);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_USB_INIT_FAILED);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_USB_REGISTER_PNP_FAILED);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_USB_CLAIM_INTERFACE_FAILED);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NOT_FOUND);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NOT_SUPPORT);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_BUSY);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_SLEEPING);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_COUNT_MODE);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_STOPPED);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_COVER_OPENNED);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NO_PAPER);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_FEEDING_PAPER);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_DOUBLE_FEEDING);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_PAPER_JAMMED);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_STAPLE_ON);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_PAPER_SKEW);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_SIZE_CHECK);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_DOGEAR);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NO_IMAGE);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_SCANN_ERROR);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_PC_BUSY);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_ISLOCK);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_MAYBE_IS_HOLE);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_DEVS_BOOTING);
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_UNKNOWN_STATUS);
|
|
if (err == SCANNER_ERR_LANG_PAK_LOST)
|
|
return "SCANNER_ERR_LANG_PAK_LOST";
|
|
|
|
// NOTE: multi-thread unsafe here
|
|
static char g_unk_err[80] = { 0 };
|
|
strcpy(g_unk_err, from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_UNKNOWN_ERROR));
|
|
sprintf(g_unk_err + strlen(g_unk_err), ":0x%x", err);
|
|
|
|
return g_unk_err;
|
|
}
|
|
bool hg_scanner_log_is_enable(int level)
|
|
{
|
|
return level >= utils::get_log_level() && utils::get_log_type() != LOG_TYPE_NONE;
|
|
}
|
|
void hg_scanner_log(const char* info, int level)
|
|
{
|
|
utils::log_info(info, level);
|
|
}
|
|
|
|
const char* hg_scanner_image_statu_name(int img_statu)
|
|
{
|
|
RETURN_IF(img_statu, SANE_Image_Statu_OK);
|
|
RETURN_IF(img_statu, SANE_Image_Statu_Blank);
|
|
RETURN_IF(img_statu, SANE_Image_Statu_Double);
|
|
RETURN_IF(img_statu, SANE_Image_Statu_Jammed);
|
|
|
|
// NOTE: multi-thread unsafe here
|
|
static char g_unk_statu[80] = { 0 };
|
|
sprintf(g_unk_statu, "Unknowned image statu: 0x%X", img_statu);
|
|
|
|
return g_unk_statu;
|
|
}
|
|
|
|
int hg_get_full_path_of_module(char* buf, size_t* size, const char* part_name)
|
|
{
|
|
if(!size)
|
|
return EINVAL;
|
|
|
|
std::string fullp(utils::get_module_full_path(part_name));
|
|
if(fullp.empty())
|
|
return ENOENT;
|
|
|
|
if(*size <= fullp.length())
|
|
{
|
|
*size = fullp.length() + 4;
|
|
|
|
return ENOMEM;
|
|
}
|
|
|
|
strcpy(buf, fullp.c_str());
|
|
*size = fullp.length();
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
#if defined(WIN32) || defined(_WIN64)
|
|
|
|
BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, LPVOID reserved)
|
|
{
|
|
if (reason == DLL_PROCESS_ATTACH)
|
|
{
|
|
if (g_scanner_path.empty())
|
|
{
|
|
char path[MAX_PATH] = { 0 };
|
|
|
|
GetModuleFileNameA(inst, path, _countof(path) - 1);
|
|
// if (strrchr(path, '\\'))
|
|
{
|
|
// strrchr(path, '\\')[1] = 0;
|
|
g_scanner_path = path;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
#endif
|