lmh188
/
code_device
mirror of http://192.168.10.5:8099/sane/code_device.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

replace lang_load_string by from_default_language

This commit is contained in:
gb 2023-11-10 16:45:27 +08:00
parent b26e658613
commit 525dfeebac
9 changed files with 134 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

205
hgdriver/hgdev/common_setting.cpp
View File

@ -2,10 +2,9 @@
#include "sane/sane_option_definitions.h" #include "sane/sane_option_definitions.h"
#include <lang/app_language.h> #include <lang/app_language.h>
#define MAKE_ID_AND_STR(id) id, lang_load_string(id, nullptr) #define MAKE_ID_AND_STR(l936) l936
static struct _fixed_option static struct _fixed_option
{ {
int str_id;
std::string str; std::string str;
int enum_val; int enum_val;
} }
@ -13,130 +12,130 @@ static struct _fixed_option
g_color_mode[] = g_color_mode[] =
{ {
{MAKE_ID_AND_STR(ID_OPTION_VALUE_YSMS_HB), COLOR_MODE_BLACK_WHITE }, {MAKE_ID_AND_STR(OPTION_VALUE_YSMS_HB), COLOR_MODE_BLACK_WHITE },
{MAKE_ID_AND_STR(ID_OPTION_VALUE_YSMS_256JHD), COLOR_MODE_256_GRAY}, {MAKE_ID_AND_STR(OPTION_VALUE_YSMS_256JHD), COLOR_MODE_256_GRAY},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_YSMS_24WCS), COLOR_MODE_24_BITS}, {MAKE_ID_AND_STR(OPTION_VALUE_YSMS_24WCS), COLOR_MODE_24_BITS},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_YSMS_YSZDSB), COLOR_MODE_AUTO_MATCH} {MAKE_ID_AND_STR(OPTION_VALUE_YSMS_YSZDSB), COLOR_MODE_AUTO_MATCH}
}, },
g_multi_out[] = g_multi_out[] =
{ {
{MAKE_ID_AND_STR(ID_OPTION_VALUE_DLSCLX_CS_HD_HB), MULTI_OUT_ALL}, {MAKE_ID_AND_STR(OPTION_VALUE_DLSCLX_CS_HD_HB), MULTI_OUT_ALL},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_DLSCLX_CS_HD), MULTI_COLOR_AND_GRAY}, {MAKE_ID_AND_STR(OPTION_VALUE_DLSCLX_CS_HD), MULTI_COLOR_AND_GRAY},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_DLSCLX_CS_HB), MULTI_COLOR_AND_BW}, {MAKE_ID_AND_STR(OPTION_VALUE_DLSCLX_CS_HB), MULTI_COLOR_AND_BW},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_DLSCLX_HD_HB), MULTI_GRAY_AND_BW} {MAKE_ID_AND_STR(OPTION_VALUE_DLSCLX_HD_HB), MULTI_GRAY_AND_BW}
}, },
g_rid_color[] = g_rid_color[] =
{ {
{MAKE_ID_AND_STR(ID_OPTION_VALUE_HDHHBTX_CSYZQ_BCS), RID_COLOR_NONE}, {MAKE_ID_AND_STR(OPTION_VALUE_HDHHBTX_CSYZQ_BCS), RID_COLOR_NONE},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_HDHHBTX_CSYZQ_CHS), RID_COLOR_RID_RED}, {MAKE_ID_AND_STR(OPTION_VALUE_HDHHBTX_CSYZQ_CHS), RID_COLOR_RID_RED},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_HDHHBTX_CSYZQ_CLS), RID_COLOR_RID_GREEN}, {MAKE_ID_AND_STR(OPTION_VALUE_HDHHBTX_CSYZQ_CLS), RID_COLOR_RID_GREEN},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_HDHHBTX_CSYZQ_CHULANSE), RID_COLOR_RID_BLUE}, {MAKE_ID_AND_STR(OPTION_VALUE_HDHHBTX_CSYZQ_CHULANSE), RID_COLOR_RID_BLUE},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_HDHHBTX_CSYZQ_HSZQ), RID_COLOR_ENHANCE_RED}, {MAKE_ID_AND_STR(OPTION_VALUE_HDHHBTX_CSYZQ_HSZQ), RID_COLOR_ENHANCE_RED},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_HDHHBTX_CSYZQ_LSZQ), RID_COLOR_ENHANCE_GREEN}, {MAKE_ID_AND_STR(OPTION_VALUE_HDHHBTX_CSYZQ_LSZQ), RID_COLOR_ENHANCE_GREEN},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_HDHHBTX_CSYZQ_LANSEZENGQIANG), RID_COLOR_ENHANCE_BLUE} {MAKE_ID_AND_STR(OPTION_VALUE_HDHHBTX_CSYZQ_LANSEZENGQIANG), RID_COLOR_ENHANCE_BLUE}
}, },
g_paper[] = g_paper[] =
{ {
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_A3), PAPER_A3}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_A3), PAPER_A3},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_A4), PAPER_A4}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_A4), PAPER_A4},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_A5), PAPER_A5}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_A5), PAPER_A5},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_A6), PAPER_A6}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_A6), PAPER_A6},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_B4), PAPER_B4}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_B4), PAPER_B4},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_B5), PAPER_B5}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_B5), PAPER_B5},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_B6), PAPER_B6}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_B6), PAPER_B6},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_8K), PAPER_8K}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_8K), PAPER_8K},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_16K), PAPER_16K}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_16K), PAPER_16K},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_Letter), PAPER_LETTER}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_Letter), PAPER_LETTER},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_A4HX), PAPER_A4_LATERAL}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_A4HX), PAPER_A4_LATERAL},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_A5HX), PAPER_A5_LATERAL}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_A5HX), PAPER_A5_LATERAL},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_A6HX), PAPER_A6_LATERAL}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_A6HX), PAPER_A6_LATERAL},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_B5HX), PAPER_B5_LATERAL}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_B5HX), PAPER_B5_LATERAL},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_B6HX), PAPER_B6_LATERAL}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_B6HX), PAPER_B6_LATERAL},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_16KHX), PAPER_16K_LATERAL}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_16KHX), PAPER_16K_LATERAL},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_LetterHX), PAPER_LETTER_LATERAL}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_LetterHX), PAPER_LETTER_LATERAL},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_DoubleLetter), PAPER_DOUBLE_LETTER}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_DoubleLetter), PAPER_DOUBLE_LETTER},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_LEGAL), PAPER_LEGAL}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_LEGAL), PAPER_LEGAL},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_PPYSCC), PAPER_AUTO_MATCH}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_PPYSCC), PAPER_AUTO_MATCH},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_ZDSMCC), PAPER_MAX_SIZE}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_ZDSMCC), PAPER_MAX_SIZE},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_ZDSMCCZDCQ), PAPER_MAX_SIZE_CLIP}, {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_ZDSMCCZDCQ), PAPER_MAX_SIZE_CLIP},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZZCC_SLSJ), PAPER_TRIGEMINY} {MAKE_ID_AND_STR(OPTION_VALUE_ZZCC_SLSJ), PAPER_TRIGEMINY}
}, },
g_page[] = g_page[] =
{ {
{MAKE_ID_AND_STR(ID_OPTION_VALUE_SMYM_DM), PAGE_SINGLE}, {MAKE_ID_AND_STR(OPTION_VALUE_SMYM_DM), PAGE_SINGLE},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_SMYM_SM), PAGE_DOUBLE}, {MAKE_ID_AND_STR(OPTION_VALUE_SMYM_SM), PAGE_DOUBLE},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_SMYM_TGKBYTY), PAGE_OMIT_EMPTY}, {MAKE_ID_AND_STR(OPTION_VALUE_SMYM_TGKBYTY), PAGE_OMIT_EMPTY},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_SMYM_TGKBYFPZ), PAGE_OMIT_EMPTY_RECEIPT}, {MAKE_ID_AND_STR(OPTION_VALUE_SMYM_TGKBYFPZ), PAGE_OMIT_EMPTY_RECEIPT},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_SMYM_DZ), PAGE_FOLIO} {MAKE_ID_AND_STR(OPTION_VALUE_SMYM_DZ), PAGE_FOLIO}
}, },
g_sharpen[] = g_sharpen[] =
{ {
{MAKE_ID_AND_STR(ID_OPTION_VALUE_RHYMH_W), SHARPEN_NONE}, {MAKE_ID_AND_STR(OPTION_VALUE_RHYMH_W), SHARPEN_NONE},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_RHYMH_RH), SHARPEN_SHARPEN}, {MAKE_ID_AND_STR(OPTION_VALUE_RHYMH_RH), SHARPEN_SHARPEN},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_RHYMH_JYBRH), SHARPEN_SHARPEN_MORE}, {MAKE_ID_AND_STR(OPTION_VALUE_RHYMH_JYBRH), SHARPEN_SHARPEN_MORE},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_RHYMH_MH), SHARPEN_HAZY}, {MAKE_ID_AND_STR(OPTION_VALUE_RHYMH_MH), SHARPEN_HAZY},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_RHYMH_JYBMH), SHARPEN_HAZY_MORE} {MAKE_ID_AND_STR(OPTION_VALUE_RHYMH_JYBMH), SHARPEN_HAZY_MORE}
}, },
g_fill_bkg[] = g_fill_bkg[] =
{ {
{MAKE_ID_AND_STR(ID_OPTION_VALUE_BJTCFS_TDBX), FILL_BKG_CONVEX_POLYGON}, {MAKE_ID_AND_STR(OPTION_VALUE_BJTCFS_TDBX), FILL_BKG_CONVEX_POLYGON},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_BJTCFS_ADBX), FILL_BKG_CONCAVE_POLYGON} {MAKE_ID_AND_STR(OPTION_VALUE_BJTCFS_ADBX), FILL_BKG_CONCAVE_POLYGON}
}, },
g_scan_mode[] = g_scan_mode[] =
{ {
{MAKE_ID_AND_STR(ID_OPTION_VALUE_SMZS_LXSM), SCAN_MODE_CONTINUOUS}, {MAKE_ID_AND_STR(OPTION_VALUE_SMZS_LXSM), SCAN_MODE_CONTINUOUS},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_SMZS_SMZDZS), SCAN_MODE_GIVEN_COUNT} {MAKE_ID_AND_STR(OPTION_VALUE_SMZS_SMZDZS), SCAN_MODE_GIVEN_COUNT}
}, },
g_text_direction[] = g_text_direction[] =
{ {
{MAKE_ID_AND_STR(ID_OPTION_VALUE_WGFX_0), TEXT_DIRECTION_0}, {MAKE_ID_AND_STR(OPTION_VALUE_WGFX_0), TEXT_DIRECTION_0},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_WGFX_90), TEXT_DIRECTION_90}, {MAKE_ID_AND_STR(OPTION_VALUE_WGFX_90), TEXT_DIRECTION_90},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_WGFX_180), TEXT_DIRECTION_180}, {MAKE_ID_AND_STR(OPTION_VALUE_WGFX_180), TEXT_DIRECTION_180},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_WGFX__90), TEXT_DIRECTION_270}, {MAKE_ID_AND_STR(OPTION_VALUE_WGFX__90), TEXT_DIRECTION_270},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_WGFX_ZDWBFXSB), TEXT_DIRECTION_AUTO} {MAKE_ID_AND_STR(OPTION_VALUE_WGFX_ZDWBFXSB), TEXT_DIRECTION_AUTO}
}, },
g_permeate_lv[] = g_permeate_lv[] =
{ {
{MAKE_ID_AND_STR(ID_OPTION_VALUE_FZSTDJ_JR), PERMAEATE_WEAKER}, {MAKE_ID_AND_STR(OPTION_VALUE_FZSTDJ_JR), PERMAEATE_WEAKER},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_FZSTDJ_R), PERMAEATE_WEAK}, {MAKE_ID_AND_STR(OPTION_VALUE_FZSTDJ_R), PERMAEATE_WEAK},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_FZSTDJ_YB), PERMAEATE_ORDINARY}, {MAKE_ID_AND_STR(OPTION_VALUE_FZSTDJ_YB), PERMAEATE_ORDINARY},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_FZSTDJ_Q), PERMAEATE_STRONG}, {MAKE_ID_AND_STR(OPTION_VALUE_FZSTDJ_Q), PERMAEATE_STRONG},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_FZSTDJ_JQ), PERMAEATE_STRONGER} {MAKE_ID_AND_STR(OPTION_VALUE_FZSTDJ_JQ), PERMAEATE_STRONGER}
}, },
g_img_quality[] = g_img_quality[] =
{ {
{MAKE_ID_AND_STR(ID_OPTION_VALUE_HZ_W), IMG_NONE}, {MAKE_ID_AND_STR(OPTION_VALUE_HZ_W), IMG_NONE},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_HZ_SDYX), IMG_SPEED}, {MAKE_ID_AND_STR(OPTION_VALUE_HZ_SDYX), IMG_SPEED},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_HZ_HZYX), IMG_QUALITY} {MAKE_ID_AND_STR(OPTION_VALUE_HZ_HZYX), IMG_QUALITY}
}, },
g_paper_strenght[]= g_paper_strenght[]=
{ {
{MAKE_ID_AND_STR(ID_OPTION_VALUE_FZQD_R),PAPER_WEAK}, {MAKE_ID_AND_STR(OPTION_VALUE_FZQD_R),PAPER_WEAK},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_FZQD_YB),PAPER_AVERAGE}, {MAKE_ID_AND_STR(OPTION_VALUE_FZQD_YB),PAPER_AVERAGE},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_FZQD_Q),PAPER_STRONG} {MAKE_ID_AND_STR(OPTION_VALUE_FZQD_Q),PAPER_STRONG}
}, },
g_sleep_time[]= g_sleep_time[]=
{ {
{MAKE_ID_AND_STR(ID_OPTION_VALUE_XMSJ_BXM),SLEEP_TIME_0MIN}, {MAKE_ID_AND_STR(OPTION_VALUE_XMSJ_BXM),SLEEP_TIME_0MIN},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_XMSJ_WFZ),SLEEP_TIME_5MIN}, {MAKE_ID_AND_STR(OPTION_VALUE_XMSJ_WFZ),SLEEP_TIME_5MIN},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_XMSJ_SFZ),SLEEP_TIME_10MIN}, {MAKE_ID_AND_STR(OPTION_VALUE_XMSJ_SFZ),SLEEP_TIME_10MIN},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_XMSJ_BXS),SLEEP_TIME_30MIN}, {MAKE_ID_AND_STR(OPTION_VALUE_XMSJ_BXS),SLEEP_TIME_30MIN},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_XMSJ_YXS),SLEEP_TIME_60MIN}, {MAKE_ID_AND_STR(OPTION_VALUE_XMSJ_YXS),SLEEP_TIME_60MIN},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_XMSJ_LXS),SLEEP_TIME_120MIN}, {MAKE_ID_AND_STR(OPTION_VALUE_XMSJ_LXS),SLEEP_TIME_120MIN},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_XMSJ_SXS),SLEEP_TIME_240MIN}, {MAKE_ID_AND_STR(OPTION_VALUE_XMSJ_SXS),SLEEP_TIME_240MIN},
}, },
g_fold_type[] = g_fold_type[] =
{ {
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZYDZ),FOLD_TYPE_LEFT_RIGHT}, {MAKE_ID_AND_STR(OPTION_VALUE_ZYDZ),FOLD_TYPE_LEFT_RIGHT},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_SXDZ),FOLD_TYPE_UP_DOWN}, {MAKE_ID_AND_STR(OPTION_VALUE_SXDZ),FOLD_TYPE_UP_DOWN},
{MAKE_ID_AND_STR(ID_OPTION_VALUE_ZDDZ),FOLD_TYPE_AUTO} {MAKE_ID_AND_STR(OPTION_VALUE_ZDDZ),FOLD_TYPE_AUTO}
}; };
int g_paper_hx[] = { PAPER_A4, PAPER_A4_LATERAL int g_paper_hx[] = { PAPER_A4, PAPER_A4_LATERAL
@ -242,7 +241,7 @@ static int match_best(struct _fixed_option* arr, size_t num, std::string& val, b
exact = true; exact = true;
for (size_t i = 0; i < num; ++i) for (size_t i = 0; i < num; ++i)
{ {
if (arr[i].str == val) if (val == from_default_language(arr[i].str.c_str()))
return arr[i].enum_val; return arr[i].enum_val;
} }
@ -253,17 +252,12 @@ static int match_best(struct _fixed_option* arr, size_t num, std::string& val, b
static std::string get_str(struct _fixed_option* arr, int num, int enm, int default_v = 0) static std::string get_str(struct _fixed_option* arr, int num, int enm, int default_v = 0)
{ {
if (enm >= 0 && enm < num) if (enm >= 0 && enm < num)
return arr[enm].str; return from_default_language(arr[enm].str.c_str());
else else
return arr[default_v].str; return from_default_language(arr[default_v].str.c_str());
}
static void reload_string(struct _fixed_option* arr, int num)
{
for (int i = 0; i < num; ++i)
arr[i].str = lang_load_string(arr[i].str_id, nullptr);
} }
#define RELOAD_STRING(arr) reload_string(arr, ARRAY_SIZE(arr))
#define INVOKE_MATCH(arr, val, yes) match_best(arr, ARRAY_SIZE(arr), val, yes) #define INVOKE_MATCH(arr, val, yes) match_best(arr, ARRAY_SIZE(arr), val, yes)
#define INVOKE_STR(arr, val, def) get_str(arr, ARRAY_SIZE(arr), val, def) #define INVOKE_STR(arr, val, def) get_str(arr, ARRAY_SIZE(arr), val, def)
#define SET_DEFAULT_ON_FAIL(map_array, ind, val, def) \ #define SET_DEFAULT_ON_FAIL(map_array, ind, val, def) \
@ -527,16 +521,16 @@ int double_paper_flag_from_option_value(std::string& opt_val, bool* exact)
if (exact) if (exact)
*exact = true; *exact = true;
if (opt_val == lang_load_string(ID_OPTION_VALUE_SZTPCL_SCTXBJXSM, nullptr)) if (opt_val == from_default_language(OPTION_VALUE_SZTPCL_SCTXBJXSM, nullptr))
return DOUBLE_PAPER_CONTINUE | DOUBLE_PAPER_SAVE_IMG; return DOUBLE_PAPER_CONTINUE | DOUBLE_PAPER_SAVE_IMG;
else if (opt_val == lang_load_string(ID_OPTION_VALUE_SZTPCL_SCTXBTZSM, nullptr)) else if (opt_val == from_default_language(OPTION_VALUE_SZTPCL_SCTXBTZSM, nullptr))
return DOUBLE_PAPER_SAVE_IMG; return DOUBLE_PAPER_SAVE_IMG;
else if (opt_val == lang_load_string(ID_OPTION_VALUE_SZTPCL_DQTXBJXSM, nullptr)) else if (opt_val == from_default_language(OPTION_VALUE_SZTPCL_DQTXBJXSM, nullptr))
return DOUBLE_PAPER_CONTINUE; return DOUBLE_PAPER_CONTINUE;
else else
{ {
if (exact) if (exact)
*exact = opt_val == lang_load_string(ID_OPTION_VALUE_SZTPCL_DQTXBTZSM, nullptr); *exact = opt_val == from_default_language(OPTION_VALUE_SZTPCL_DQTXBTZSM, nullptr);
} }
return 0; return 0;
} }
@ -546,14 +540,14 @@ std::string double_paper_flag_to_option_value(int flag)
if (is_continue_when_double_paper(flag)) if (is_continue_when_double_paper(flag))
{ {
if (is_save_img_when_double_paper(flag)) if (is_save_img_when_double_paper(flag))
return lang_load_string(ID_OPTION_VALUE_SZTPCL_SCTXBJXSM, nullptr); return from_default_language(OPTION_VALUE_SZTPCL_SCTXBJXSM, nullptr);
else else
return lang_load_string(ID_OPTION_VALUE_SZTPCL_DQTXBJXSM, nullptr); return from_default_language(OPTION_VALUE_SZTPCL_DQTXBJXSM, nullptr);
} }
else if (is_save_img_when_double_paper(flag)) else if (is_save_img_when_double_paper(flag))
return lang_load_string(ID_OPTION_VALUE_SZTPCL_SCTXBTZSM, nullptr); return from_default_language(OPTION_VALUE_SZTPCL_SCTXBTZSM, nullptr);
else else
return lang_load_string(ID_OPTION_VALUE_SZTPCL_DQTXBTZSM, nullptr); return from_default_language(OPTION_VALUE_SZTPCL_DQTXBTZSM, nullptr);
} }
bool is_continue_when_double_paper(int flag) bool is_continue_when_double_paper(int flag)
{ {
@ -565,20 +559,3 @@ bool is_save_img_when_double_paper(int flag)
} }
void reload_setting_string_from_pak(int cp, void* param)
{
RELOAD_STRING(g_color_mode);
RELOAD_STRING(g_multi_out);
RELOAD_STRING(g_rid_color);
RELOAD_STRING(g_paper);
RELOAD_STRING(g_page);
RELOAD_STRING(g_sharpen);
RELOAD_STRING(g_fill_bkg);
RELOAD_STRING(g_scan_mode);
RELOAD_STRING(g_text_direction);
RELOAD_STRING(g_permeate_lv);
RELOAD_STRING(g_img_quality);
RELOAD_STRING(g_paper_strenght);
RELOAD_STRING(g_sleep_time);
RELOAD_STRING(g_fold_type);
}

3
hgdriver/hgdev/common_setting.h
View File

@ -311,9 +311,6 @@ enum
int match_best_fold_type(std::string& val, bool* exact); int match_best_fold_type(std::string& val, bool* exact);
std::string is_fold_type(int fold_type); std::string is_fold_type(int fold_type);
// call me when language changed in multi-language - added on 2023-01-19
void reload_setting_string_from_pak(int cp, void* param);
typedef union _img_proc_fixed_param typedef union _img_proc_fixed_param
{ {
unsigned long long value; unsigned long long value;

72
hgdriver/hgdev/hg_scanner.cpp
View File

@ -153,7 +153,7 @@ hg_scanner::hg_scanner(ScannerSerial serial, const char* dev_name, const char* m
, bright_(128), contrast_(4), gamma_(1.0f), threshold_(40), anti_noise_(8), margin_(5) , bright_(128), contrast_(4), gamma_(1.0f), threshold_(40), anti_noise_(8), margin_(5)
, fractate_level_(50), ui_ev_cb_(ui_default_callback), scan_life_(NULL) , fractate_level_(50), ui_ev_cb_(ui_default_callback), scan_life_(NULL)
, notify_setting_result_(false), user_cancel_(false), cb_mem_(true), test_1_paper_(false) , notify_setting_result_(false), user_cancel_(false), cb_mem_(true), test_1_paper_(false)
, img_type_(""), online_(false), is_quality_(-1), is_color_fill(false), is_multiout(false), save_multiout(lang_load_string(ID_OPTION_VALUE_DLSCLX_CS_HD_HB, nullptr)) , img_type_(""), online_(false), is_quality_(-1), is_color_fill(false), is_multiout(false), save_multiout(from_default_language(OPTION_VALUE_DLSCLX_CS_HD_HB, nullptr))
, final_img_index_(0), custom_area_(false), save_sizecheck(false), bw_threshold_(128), custom_gamma_(false) , final_img_index_(0), custom_area_(false), save_sizecheck(false), bw_threshold_(128), custom_gamma_(false)
, double_paper_handle_(0), keep_watermark_(false), save_feedmode_type_(false), feedmode_(1), sleeptime_(-1), split3399_(0) , double_paper_handle_(0), keep_watermark_(false), save_feedmode_type_(false), feedmode_(1), sleeptime_(-1), split3399_(0)
, async_io_(false), is_white_0_(true), isremove_left_hole(false), isremove_right_hole(false), isremove_top_hole(false), isremove_low_hole(false) , async_io_(false), is_white_0_(true), isremove_left_hole(false), isremove_right_hole(false), isremove_top_hole(false), isremove_low_hole(false)
@ -279,8 +279,8 @@ hg_scanner::~hg_scanner()
if(ImagePrc_pHandle_) if(ImagePrc_pHandle_)
hg_imgproc::release(ImagePrc_pHandle_); hg_imgproc::release(ImagePrc_pHandle_);
name_.insert(0, lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_DEVS, nullptr)); name_.insert(0, from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_DEVS, nullptr));
name_ += lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_IS_CLOSE, nullptr); name_ += from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_IS_CLOSE, nullptr);
notify_ui_working_status(name_.c_str(), SANE_EVENT_SCANNER_CLOSED); notify_ui_working_status(name_.c_str(), SANE_EVENT_SCANNER_CLOSED);
utils::to_log(LOG_LEVEL_DEBUG, "%s(%p) destroyed.\n", name_.c_str(), this); utils::to_log(LOG_LEVEL_DEBUG, "%s(%p) destroyed.\n", name_.c_str(), this);
} }
@ -790,7 +790,7 @@ void hg_scanner::working_begin(void*)
stop_fatal_ = SCANNER_ERR_OK; stop_fatal_ = SCANNER_ERR_OK;
final_img_index_ = 0; final_img_index_ = 0;
status_ = SCANNER_ERR_OK; status_ = SCANNER_ERR_OK;
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCAN_WORKING, nullptr), SANE_EVENT_WORKING, SCANNER_ERR_OK); notify_ui_working_status(from_default_language(STATU_DESC_SCAN_WORKING, nullptr), SANE_EVENT_WORKING, SCANNER_ERR_OK);
utils::log_info("scanning ...\n", LOG_LEVEL_DEBUG); utils::log_info("scanning ...\n", LOG_LEVEL_DEBUG);
} }
void hg_scanner::working_done(void*) void hg_scanner::working_done(void*)
@ -805,73 +805,73 @@ void hg_scanner::working_done(void*)
switch (status_) switch (status_)
{ {
case SCANNER_ERR_OK: case SCANNER_ERR_OK:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCAN_STOPPED, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCAN_STOPPED, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_BUSY: case SCANNER_ERR_DEVICE_BUSY:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_PC_BUSY, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_PC_BUSY, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_STOPPED: case SCANNER_ERR_DEVICE_STOPPED:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCAN_STOPPED, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCAN_STOPPED, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_COVER_OPENNED: case SCANNER_ERR_DEVICE_COVER_OPENNED:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_COVER_OPENNED, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_COVER_OPENNED, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_NO_PAPER: case SCANNER_ERR_DEVICE_NO_PAPER:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_FEEDING_PAPER: case SCANNER_ERR_DEVICE_FEEDING_PAPER:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_FEEDING_PAPER, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_FEEDING_PAPER, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_NOT_FOUND: case SCANNER_ERR_DEVICE_NOT_FOUND:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_NOT_FOUND, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_NOT_FOUND, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_SLEEPING: case SCANNER_ERR_DEVICE_SLEEPING:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_COUNT_MODE: case SCANNER_ERR_DEVICE_COUNT_MODE:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_COUNT_MODE, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_COUNT_MODE, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_DOUBLE_FEEDING: case SCANNER_ERR_DEVICE_DOUBLE_FEEDING:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_DOUBLE_FEEDING, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_DOUBLE_FEEDING, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_PAPER_JAMMED: case SCANNER_ERR_DEVICE_PAPER_JAMMED:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_PAPER_JAMMED, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_PAPER_JAMMED, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_STAPLE_ON: case SCANNER_ERR_DEVICE_STAPLE_ON:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_STAPLE_ON, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_STAPLE_ON, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_PAPER_SKEW: case SCANNER_ERR_DEVICE_PAPER_SKEW:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_PAPER_SKEW, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_PAPER_SKEW, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_SIZE_CHECK: case SCANNER_ERR_DEVICE_SIZE_CHECK:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_SIZE_CHECK, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_SIZE_CHECK, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_DOGEAR: case SCANNER_ERR_DEVICE_DOGEAR:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_DOGEAR, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_DOGEAR, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_NO_IMAGE: case SCANNER_ERR_DEVICE_NO_IMAGE:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_NO_IMAGE, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_NO_IMAGE, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_SCANN_ERROR: case SCANNER_ERR_DEVICE_SCANN_ERROR:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_SCANN_ERROR, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_SCANN_ERROR, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_PC_BUSY: case SCANNER_ERR_DEVICE_PC_BUSY:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_PC_BUSY, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_PC_BUSY, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_INSUFFICIENT_MEMORY: case SCANNER_ERR_INSUFFICIENT_MEMORY:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_INSUFFICIENT_MEMORY, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_INSUFFICIENT_MEMORY, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_TIMEOUT: case SCANNER_ERR_TIMEOUT:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_TIMEOUT, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_TIMEOUT, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_ISLOCK: case SCANNER_ERR_DEVICE_ISLOCK:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_ISLOCK, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_ISLOCK, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_AUTO_FAIL_OVER: case SCANNER_ERR_DEVICE_AUTO_FAIL_OVER:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_AUTO_FAIL_OVER, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_AUTO_FAIL_OVER, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_DISTORTION: case SCANNER_ERR_DEVICE_DISTORTION:
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_DISTORTION, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_DISTORTION, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
case SCANNER_ERR_DEVICE_MAYBE_IS_HOLE: case SCANNER_ERR_DEVICE_MAYBE_IS_HOLE:
notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_MAYBE_IS_HOLE, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_MAYBE_IS_HOLE, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
@ -880,7 +880,7 @@ void hg_scanner::working_done(void*)
notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_DEVS_BOOTING, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_DEVS_BOOTING, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
default: default:
notify_ui_working_status(user_cancel_ ? lang_load_string(ID_STATU_DESC_SCAN_CANCELED, nullptr) : lang_load_string(ID_STATU_DESC_SCAN_STOPPED, nullptr), SANE_EVENT_SCAN_FINISHED, status_); notify_ui_working_status(user_cancel_ ? from_default_language(STATU_DESC_SCAN_CANCELED, nullptr) : from_default_language(STATU_DESC_SCAN_STOPPED, nullptr), SANE_EVENT_SCAN_FINISHED, status_);
break; break;
} }
@ -1451,9 +1451,9 @@ int hg_scanner::setting_go_on_when_double_checked(void* data, long* len)
bool ok = true; bool ok = true;
std::string val((char*)data); std::string val((char*)data);
if (!firmware_sup_double_img && val.compare(lang_load_string(ID_OPTION_VALUE_SZTPCL_DQTXBTZSM, nullptr))) if (!firmware_sup_double_img && val.compare(from_default_language(OPTION_VALUE_SZTPCL_DQTXBTZSM, nullptr)))
{ {
::strcpy((char*)data, lang_load_string(ID_OPTION_VALUE_SZTPCL_SCTXBTZSM, nullptr)); ::strcpy((char*)data, from_default_language(OPTION_VALUE_SZTPCL_SCTXBTZSM, nullptr));
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
@ -1529,7 +1529,7 @@ int hg_scanner::setting_scan_count(void* data, long* len)
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
//std::string val(get_setting_item_string(SANE_STD_OPT_NAME_SCAN_MODE, "cur")); //std::string val(get_setting_item_string(SANE_STD_OPT_NAME_SCAN_MODE, "cur"));
//if (val == lang_load_string(ID_OPTION_VALUE_SMZS_LXSM, nullptr)) //if (val == from_default_language(OPTION_VALUE_SMZS_LXSM, nullptr))
//{ //{
// scan_count_ = -1; // scan_count_ = -1;
//} //}
@ -2017,7 +2017,6 @@ int hg_scanner::setting_set_language(void* data, long* len)
err = SCANNER_ERR_CONFIGURATION_CHANGED; err = SCANNER_ERR_CONFIGURATION_CHANGED;
lang_set_code_page(id); lang_set_code_page(id);
on_language_changed();
} }
} }
@ -2394,7 +2393,7 @@ std::shared_ptr<tiny_buffer> hg_scanner::aquire_memory(int size, bool from_usb)
{ {
mem.reset(); mem.reset();
utils::log_info("Can't aquire enough memory, working must be stopped!\n", LOG_LEVEL_FATAL); utils::log_info("Can't aquire enough memory, working must be stopped!\n", LOG_LEVEL_FATAL);
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_INSUFFICIENT_MEMORY, nullptr), SANE_EVENT_ERROR, SCANNER_ERR_INSUFFICIENT_MEMORY); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_INSUFFICIENT_MEMORY, nullptr), SANE_EVENT_ERROR, SCANNER_ERR_INSUFFICIENT_MEMORY);
stop(); stop();
} }
@ -2436,7 +2435,7 @@ bool hg_scanner::waiting_for_memory_enough(unsigned need_bytes)
if (first) if (first)
{ {
utils::to_log(LOG_LEVEL_DEBUG, "Memory is too small for aquiring image(%u bytes), wait for ENOUGH ...\n", need_bytes); utils::to_log(LOG_LEVEL_DEBUG, "Memory is too small for aquiring image(%u bytes), wait for ENOUGH ...\n", need_bytes);
notify_ui_working_status(lang_load_string(ID_STATU_DESC_WAIT_FOR_MEM, nullptr)); notify_ui_working_status(from_default_language(STATU_DESC_WAIT_FOR_MEM, nullptr));
first = false; first = false;
} }
std::this_thread::sleep_for(std::chrono::milliseconds(30)); std::this_thread::sleep_for(std::chrono::milliseconds(30));
@ -2789,11 +2788,6 @@ bool hg_scanner::is_online(void)
{ {
return online_; return online_;
} }
void hg_scanner::on_language_changed(void)
{
// change the 'size' member of string settings ...
//setting_jsn_->update_data(nullptr, nullptr);
}
int hg_scanner::wait_one_image_from_start(bool& handled) int hg_scanner::wait_one_image_from_start(bool& handled)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;

1
hgdriver/hgdev/hg_scanner.h
View File

@ -450,7 +450,6 @@ public:
std::string name(void); std::string name(void);
int status(void); int status(void);
bool is_online(void); bool is_online(void);
void on_language_changed(void);
enum thread_running enum thread_running
{ {

2
hgdriver/hgdev/hg_scanner_200.cpp
View File

@ -298,7 +298,7 @@ int hg_scanner_200::do_start(void)
{ {
status_ = ret = SCANNER_ERR_DEVICE_NO_PAPER; status_ = ret = SCANNER_ERR_DEVICE_NO_PAPER;
//notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_); //notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_);
utils::to_log(LOG_LEVEL_WARNING, "device start status is(%s)\n", lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, nullptr)); utils::to_log(LOG_LEVEL_WARNING, "device start status is(%s)\n", from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, nullptr));
return ret; return ret;
} }

8
hgdriver/hgdev/hg_scanner_239.cpp
View File

@ -1132,7 +1132,7 @@ void hg_scanner_239::thread_correction(void)
{ {
is_auto_falt = false; is_auto_falt = false;
status_ = SCANNER_ERR_DEVICE_AUTO_FAIL_OVER; status_ = SCANNER_ERR_DEVICE_AUTO_FAIL_OVER;
//notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_FAIL_OUTTIME), SANE_EVENT_ERROR, ret); // 通信超时 //notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_FAIL_OUTTIME), SANE_EVENT_ERROR, ret); // 通信超时
utils::to_log(LOG_LEVEL_DEBUG, "设备校正超时 '%s'\n", hg_scanner_err_name(status_, errbuf)); utils::to_log(LOG_LEVEL_DEBUG, "设备校正超时 '%s'\n", hg_scanner_err_name(status_, errbuf));
break; break;
} }
@ -1440,7 +1440,7 @@ void hg_scanner_239::thread_get_dves_image(void)
else else
status_ = ret = SCANNER_ERR_USER_CANCELED; status_ = ret = SCANNER_ERR_USER_CANCELED;
utils::to_log(LOG_LEVEL_DEBUG, "%s\n", lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_GET_USER_CANCEL_SCAN, nullptr)); utils::to_log(LOG_LEVEL_DEBUG, "%s\n", from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_GET_USER_CANCEL_SCAN, nullptr));
auoto_paper_indx = 0; auoto_paper_indx = 0;
break; break;
} }
@ -1463,7 +1463,7 @@ void hg_scanner_239::thread_get_dves_image(void)
{ {
utils::log_info("Really stopped ^_^\n", LOG_LEVEL_DEBUG); utils::log_info("Really stopped ^_^\n", LOG_LEVEL_DEBUG);
string str = lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_ROUND_SACN_OVER, nullptr); string str = from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_ROUND_SACN_OVER, nullptr);
str += ":" + to_string(++auoto_paper_indx); str += ":" + to_string(++auoto_paper_indx);
if (!user_cancel_ && is_auto_paper_scan && svdevs_err_.empty()) if (!user_cancel_ && is_auto_paper_scan && svdevs_err_.empty())
@ -1537,7 +1537,7 @@ int hg_scanner_239::do_start(void)
if (!val && ret == SCANNER_ERR_OK) if (!val && ret == SCANNER_ERR_OK)
{ {
status_ = SCANNER_ERR_DEVICE_SLEEPING; status_ = SCANNER_ERR_DEVICE_SLEEPING;
utils::to_log(LOG_LEVEL_WARNING, "device start status is(%s)\n", lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING, nullptr)); utils::to_log(LOG_LEVEL_WARNING, "device start status is(%s)\n", from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING, nullptr));
set_notify_sleep(); set_notify_sleep();

4
hgdriver/hgdev/hg_scanner_300.cpp
View File

@ -224,7 +224,7 @@ void hg_scanner_300::thread_handle_usb_read(void)
} }
savestatus_.clear(); savestatus_.clear();
utils::log_info("Get Status TimeOut,get image out 30S\n", LOG_LEVEL_WARNING); utils::log_info("Get Status TimeOut,get image out 30S\n", LOG_LEVEL_WARNING);
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_OUTTIME, nullptr), SANE_EVENT_ERROR, status_); // 取图通信超时 notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_OUTTIME, nullptr), SANE_EVENT_ERROR, status_); // 取图通信超时
break; break;
} }
} }
@ -236,7 +236,7 @@ void hg_scanner_300::thread_handle_usb_read(void)
} }
savestatus_.clear(); savestatus_.clear();
utils::log_info("MaxSize TimeOut,Get Image 130s\n", LOG_LEVEL_WARNING); utils::log_info("MaxSize TimeOut,Get Image 130s\n", LOG_LEVEL_WARNING);
notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_OUTTIME, nullptr), SANE_EVENT_ERROR, status_); // 取图通信超时 notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_OUTTIME, nullptr), SANE_EVENT_ERROR, status_); // 取图通信超时
break; break;
} }
if (ret == SCANNER_ERR_OK && usb.u32_Count > 0) if (ret == SCANNER_ERR_OK && usb.u32_Count > 0)

7
hgdriver/hgdev/scanner_manager.cpp
View File

@ -34,7 +34,7 @@ static struct
uint16_t vid; // vendor ID uint16_t vid; // vendor ID
uint16_t pid; // product ID uint16_t pid; // product ID
std::string name; // product name - type std::string name; // product name - type
std::string family; // product model - family std::string family; // product model - family. In the TWAIN protocol, grouping is based on this value
std::string rsc; // USB resource, version-addr. e.g. "USB2.0-1" std::string rsc; // USB resource, version-addr. e.g. "USB2.0-1"
hg_scanner* (* create_scanner)(const char*/*name*/, const char*/*model*/, usb_io*, scanner_handle*); hg_scanner* (* create_scanner)(const char*/*name*/, const char*/*model*/, usb_io*, scanner_handle*);
} }
@ -831,7 +831,6 @@ scanner_err hg_scanner_mgr::hg_scanner_enum(ScannerInfo* scanner_list, long* cou
std::string g_vendor(from_default_language(COMPANY_NAME, nullptr)); std::string g_vendor(from_default_language(COMPANY_NAME, nullptr));
get_online_devices(devusbuf); get_online_devices(devusbuf);
*count = devusbuf.size(); *count = devusbuf.size();
utils::to_log(LOG_LEVEL_ALL, "current language(%d) of '%s' is '%s'\n", lang_get_cur_code_page(), COMPANY_NAME, g_vendor.c_str());
if (*count > size) if (*count > size)
{ {
ret = SCANNER_ERR_INSUFFICIENT_MEMORY; ret = SCANNER_ERR_INSUFFICIENT_MEMORY;
@ -1192,8 +1191,8 @@ void hg_scanner_mgr::on_language_changed(void)
std::lock_guard<std::mutex> lock(mutex_dev_); std::lock_guard<std::mutex> lock(mutex_dev_);
for (auto& v: online_devices_) for (auto& v: online_devices_)
{ {
if (v.scanner) if (v.dev_opts)
v.scanner->on_language_changed(); v.dev_opts->update_data(nullptr, nullptr, false);
} }
} }
const char* hg_scanner_mgr::last_open_message(void) const char* hg_scanner_mgr::last_open_message(void)

1
hgdriver/wrapper/huagaoxxx_warraper_ex.cpp
View File

@ -73,7 +73,6 @@ extern "C"
{ {
static void language_changed(int cp, void* param) static void language_changed(int cp, void* param)
{ {
reload_setting_string_from_pak(cp, nullptr);
hg_scanner_mgr::instance()->on_language_changed(); hg_scanner_mgr::instance()->on_language_changed();
} }