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

调整语言包设置，暂时支持中文

This commit is contained in:
13038267101 2023-01-18 18:08:47 +08:00
parent ddfe9132e0
commit 9e3248e97d
10 changed files with 319 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

175
hgdriver/hgdev/common_setting.cpp
View File

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

158
hgdriver/hgdev/common_setting.h
View File

@ -6,8 +6,10 @@
//
#include <string>
#include "char_const.h"
#include "sane/sane_ex.h"
#include <vector>
#include <map>
#include "sane/sane_option_definitions.h"
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 硬件配置项定义
//
@ -1163,3 +1165,155 @@ namespace setting3399
{PAPER_MAX_SIZE, TwSS::MaxSize, setting3288dsp::G400_MAXSIZE},
{PAPER_TRIGEMINY, TwSS::MaxSize, setting3288dsp::G400_LONGLETTER},
};
static std::map<std::string, int>json_name =
{
{ SANE_STD_OPT_NAME_RESTORE ,ID_OPTION_TITLE_HFMRSZ },
{ SANE_STD_OPT_NAME_HELP ,ID_OPTION_TITLE_BZ },
{ SANE_STD_OPT_NAME_IS_MULTI_OUT ,ID_OPTION_TITLE_DLSC },
{ SANE_STD_OPT_NAME_MULTI_OUT_TYPE ,ID_OPTION_TITLE_DLSCLX },
{ SANE_STD_OPT_NAME_COLOR_MODE ,ID_OPTION_TITLE_YSMS },
{ SANE_STD_OPT_NAME_BINARY_THRESHOLD ,ID_OPTION_TITLE_HBTXYZ },
{ SANE_STD_OPT_NAME_REVERSE_01 ,ID_OPTION_TITLE_HBTXFSSC },
{ SANE_STD_OPT_NAME_FILTER ,ID_OPTION_TITLE_HDHHBTX_CSYZQ },
{ SANE_STD_OPT_NAME_RID_MULTIOUT_RED ,ID_OPTION_TITLE_24WCSTX_DLSCCH },
{ SANE_STD_OPT_NAME_RID_ANSWER_SHEET_RED ,ID_OPTION_TITLE_24WCSTX_DTKCH },
{ SANE_STD_OPT_NAME_ERASE_BACKGROUND ,ID_OPTION_TITLE_BJYC },
{ SANE_STD_OPT_NAME_BKG_COLOR_RANGE ,ID_OPTION_TITLE_BJSCFDFW },
{ SANE_STD_OPT_NAME_SHARPEN ,ID_OPTION_TITLE_RHYMH },
{ SANE_STD_OPT_NAME_RID_MORR ,ID_OPTION_TITLE_QCMW },
{ SANE_STD_OPT_NAME_RID_GRID ,ID_OPTION_TITLE_CWW },
{ SANE_STD_OPT_NAME_ERROR_EXTENSION ,ID_OPTION_TITLE_CWKS },
{ SANE_STD_OPT_NAME_NOISE_OPTIMIZE ,ID_OPTION_TITLE_HBTXZDYH },
{ SANE_STD_OPT_NAME_NOISE_SIZE ,ID_OPTION_TITLE_ZDYHCC },
{ SANE_STD_OPT_NAME_PAPER ,ID_OPTION_TITLE_ZZCC },
{ SANE_STD_OPT_NAME_CUSTOM_AREA ,ID_OPTION_TITLE_ZDYSMQY },
{ SANE_STD_OPT_NAME_CUSTOM_AREA_LEFT ,ID_OPTION_TITLE_SMQYZCmm },
{ SANE_STD_OPT_NAME_CUSTOM_AREA_RIGHT ,ID_OPTION_TITLE_SMQYYCmm },
{ SANE_STD_OPT_NAME_CUSTOM_AREA_TOP ,ID_OPTION_TITLE_SMQYSCmm },
{ SANE_STD_OPT_NAME_CUSTOM_AREA_BOTTOM ,ID_OPTION_TITLE_SMQYXCmm },
{ SANE_STD_OPT_NAME_SIZE_CHECK ,ID_OPTION_TITLE_CCJC },
{ SANE_STD_OPT_NAME_PAGE ,ID_OPTION_TITLE_SMYM },
{ SANE_STD_OPT_NAME_DISCARD_BLANK_SENS ,ID_OPTION_TITLE_TGKBYLMD },
{ SANE_STD_OPT_NAME_RESOLUTION ,ID_OPTION_TITLE_FBL },
{ SANE_STD_OPT_NAME_TIME_TO_SLEEP ,ID_OPTION_TITLE_XMSJ },
{ SANE_STD_OPT_NAME_IMAGE_QUALITY ,ID_OPTION_TITLE_HZ },
{ SANE_STD_OPT_NAME_EXCHANGE ,ID_OPTION_TITLE_JHZFM },
{ SANE_STD_OPT_NAME_SPLIT ,ID_OPTION_TITLE_TXCF },
{ SANE_STD_OPT_NAME_ANTI_SKEW ,ID_OPTION_TITLE_ZDJP },
{ SANE_STD_OPT_NAME_IS_CUSTOM_GAMMA ,ID_OPTION_TITLE_QYSDQX },
{ SANE_STD_OPT_NAME_GAMMA ,ID_OPTION_TITLE_JMZ },
{ SANE_STD_OPT_NAME_BRIGHTNESS ,ID_OPTION_TITLE_LDZ },
{ SANE_STD_OPT_NAME_CONTRAST ,ID_OPTION_TITLE_DBD },
{ SANE_STD_OPT_NAME_IS_PHOTO_MODE ,ID_OPTION_TITLE_ZPMS },
{ SANE_STD_OPT_NAME_ERASE_BLACK_FRAME ,ID_OPTION_TITLE_XCHK },
{ SANE_STD_OPT_NAME_DARK_SAMPLE ,ID_OPTION_TITLE_SSYZ },
{ SANE_STD_OPT_NAME_THRESHOLD ,ID_OPTION_TITLE_YZ },
{ SANE_STD_OPT_NAME_ANTI_NOISE_LEVEL ,ID_OPTION_TITLE_BJKZDJ },
{ SANE_STD_OPT_NAME_MARGIN ,ID_OPTION_TITLE_BYSJ },
{ SANE_STD_OPT_NAME_FILL_BKG_MODE ,ID_OPTION_TITLE_BJTCFS },
{ SANE_STD_OPT_NAME_IS_ANTI_PERMEATE ,ID_OPTION_TITLE_FZST },
{ SANE_STD_OPT_NAME_ANTI_PERMEATE_LEVEL ,ID_OPTION_TITLE_FZSTDJ },
{ SANE_STD_OPT_NAME_RID_HOLE ,ID_OPTION_TITLE_CKYC },
{ SANE_STD_OPT_NAME_SEARCH_HOLE_RANGE ,ID_OPTION_TITLE_CKSSFWZFMBL },
{ SANE_STD_OPT_NAME_RID_HOLE_L ,ID_OPTION_TITLE_CKYCZC },
{ SANE_STD_OPT_NAME_SEARCH_HOLE_RANGE_L ,ID_OPTION_TITLE_ZCCKSSFWZFMBL },
{ SANE_STD_OPT_NAME_RID_HOLE_R ,ID_OPTION_TITLE_CKYCYC },
{ SANE_STD_OPT_NAME_SEARCH_HOLE_RANGE_R ,ID_OPTION_TITLE_YCCKSSFWZFMBL },
{ SANE_STD_OPT_NAME_RID_HOLE_T ,ID_OPTION_TITLE_CKYCSC },
{ SANE_STD_OPT_NAME_SEARCH_HOLE_RANGE_T ,ID_OPTION_TITLE_SCCKSSFWZFMBL },
{ SANE_STD_OPT_NAME_RID_HOLE_B ,ID_OPTION_TITLE_CKYCXC },
{ SANE_STD_OPT_NAME_SEARCH_HOLE_RANGE_B ,ID_OPTION_TITLE_XCCKSSFWZFMBL },
{ SANE_STD_OPT_NAME_IS_FILL_COLOR ,ID_OPTION_TITLE_SCTC },
{ SANE_STD_OPT_NAME_IS_ULTROSONIC_CHECK ,ID_OPTION_TITLE_CSBJC },
{ SANE_STD_OPT_NAME_DOUBLE_FEED_HANDLE ,ID_OPTION_TITLE_SZTPCL },
{ SANE_STD_OPT_NAME_IS_CHECK_STAPLE ,ID_OPTION_TITLE_ZDJC },
{ SANE_STD_OPT_NAME_SCAN_MODE ,ID_OPTION_TITLE_SMZS },
{ SANE_STD_OPT_NAME_SCAN_COUNT ,ID_OPTION_TITLE_SMSL },
{ SANE_STD_OPT_NAME_TEXT_DIRECTION ,ID_OPTION_TITLE_WGFX },
{ SANE_STD_OPT_NAME_IS_ROTATE_BKG_180 ,ID_OPTION_TITLE_BMXZ180 },
{ SANE_STD_OPT_NAME_IS_CHECK_DOG_EAR ,ID_OPTION_TITLE_ZJJC },
{ SANE_STD_OPT_NAME_DOG_EAR_SIZE ,ID_OPTION_TITLE_ZJDX },
{ SANE_STD_OPT_NAME_IS_CHECK_ASKEW ,ID_OPTION_TITLE_WXJC },
{ SANE_STD_OPT_NAME_ASKEW_RANGE ,ID_OPTION_TITLE_WXRRD },
{ SANE_STD_OPT_NAME_FEED_STRENGTH ,ID_OPTION_TITLE_FZQD },
{ SANE_STD_OPT_NAME_IS_AUTO_FEED_STRENGTH ,ID_OPTION_TITLE_ZDFZQD },
{ SANE_STD_OPT_NAME_FEED_STRENGTH_VALUE ,ID_OPTION_TITLE_JZSBL },
{ SANE_STD_OPT_NAME_WAIT_TO_SCAN ,ID_OPTION_TITLE_DZSM },
{ SANE_STD_OPT_NAME_FOLD_TYPE ,ID_OPTION_TITLE_DZMS },
};
static std::vector<std::string>json_name_
{
SANE_STD_OPT_NAME_RESTORE,
SANE_STD_OPT_NAME_HELP,
SANE_STD_OPT_NAME_IS_MULTI_OUT,
SANE_STD_OPT_NAME_MULTI_OUT_TYPE,
SANE_STD_OPT_NAME_COLOR_MODE,
SANE_STD_OPT_NAME_BINARY_THRESHOLD,
SANE_STD_OPT_NAME_REVERSE_01 ,
SANE_STD_OPT_NAME_FILTER,
SANE_STD_OPT_NAME_RID_MULTIOUT_RED,
SANE_STD_OPT_NAME_RID_ANSWER_SHEET_RED,
SANE_STD_OPT_NAME_ERASE_BACKGROUND,
SANE_STD_OPT_NAME_BKG_COLOR_RANGE,
SANE_STD_OPT_NAME_SHARPEN,
SANE_STD_OPT_NAME_RID_MORR,
SANE_STD_OPT_NAME_RID_GRID,
SANE_STD_OPT_NAME_ERROR_EXTENSION,
SANE_STD_OPT_NAME_NOISE_OPTIMIZE,
SANE_STD_OPT_NAME_NOISE_SIZE,
SANE_STD_OPT_NAME_PAPER,
SANE_STD_OPT_NAME_CUSTOM_AREA,
SANE_STD_OPT_NAME_CUSTOM_AREA_LEFT,
SANE_STD_OPT_NAME_CUSTOM_AREA_RIGHT,
SANE_STD_OPT_NAME_CUSTOM_AREA_TOP,
SANE_STD_OPT_NAME_CUSTOM_AREA_BOTTOM,
SANE_STD_OPT_NAME_SIZE_CHECK,
SANE_STD_OPT_NAME_PAGE,
SANE_STD_OPT_NAME_DISCARD_BLANK_SENS,
SANE_STD_OPT_NAME_RESOLUTION,
SANE_STD_OPT_NAME_TIME_TO_SLEEP,
SANE_STD_OPT_NAME_IMAGE_QUALITY,
SANE_STD_OPT_NAME_EXCHANGE,
SANE_STD_OPT_NAME_SPLIT,
SANE_STD_OPT_NAME_ANTI_SKEW,
SANE_STD_OPT_NAME_IS_CUSTOM_GAMMA,
SANE_STD_OPT_NAME_GAMMA,
SANE_STD_OPT_NAME_BRIGHTNESS,
SANE_STD_OPT_NAME_CONTRAST,
SANE_STD_OPT_NAME_IS_PHOTO_MODE,
SANE_STD_OPT_NAME_ERASE_BLACK_FRAME,
SANE_STD_OPT_NAME_DARK_SAMPLE,
SANE_STD_OPT_NAME_THRESHOLD,
SANE_STD_OPT_NAME_ANTI_NOISE_LEVEL,
SANE_STD_OPT_NAME_MARGIN,
SANE_STD_OPT_NAME_FILL_BKG_MODE,
SANE_STD_OPT_NAME_IS_ANTI_PERMEATE,
SANE_STD_OPT_NAME_ANTI_PERMEATE_LEVEL,
SANE_STD_OPT_NAME_RID_HOLE,
SANE_STD_OPT_NAME_SEARCH_HOLE_RANGE,
SANE_STD_OPT_NAME_RID_HOLE_L,
SANE_STD_OPT_NAME_SEARCH_HOLE_RANGE_L,
SANE_STD_OPT_NAME_RID_HOLE_R,
SANE_STD_OPT_NAME_SEARCH_HOLE_RANGE_R,
SANE_STD_OPT_NAME_RID_HOLE_T,
SANE_STD_OPT_NAME_SEARCH_HOLE_RANGE_T,
SANE_STD_OPT_NAME_RID_HOLE_B,
SANE_STD_OPT_NAME_SEARCH_HOLE_RANGE_B,
SANE_STD_OPT_NAME_IS_FILL_COLOR,
SANE_STD_OPT_NAME_IS_ULTROSONIC_CHECK,
SANE_STD_OPT_NAME_DOUBLE_FEED_HANDLE,
SANE_STD_OPT_NAME_IS_CHECK_STAPLE,
SANE_STD_OPT_NAME_SCAN_MODE,
SANE_STD_OPT_NAME_SCAN_COUNT,
SANE_STD_OPT_NAME_TEXT_DIRECTION,
SANE_STD_OPT_NAME_IS_ROTATE_BKG_180,
SANE_STD_OPT_NAME_IS_CHECK_DOG_EAR,
SANE_STD_OPT_NAME_DOG_EAR_SIZE,
SANE_STD_OPT_NAME_IS_CHECK_ASKEW,
SANE_STD_OPT_NAME_ASKEW_RANGE,
SANE_STD_OPT_NAME_FEED_STRENGTH,
SANE_STD_OPT_NAME_IS_AUTO_FEED_STRENGTH,
SANE_STD_OPT_NAME_FEED_STRENGTH_VALUE,
SANE_STD_OPT_NAME_WAIT_TO_SCAN,
SANE_STD_OPT_NAME_FOLD_TYPE
};

82
hgdriver/hgdev/hg_scanner.cpp
View File

@ -147,7 +147,7 @@ hg_scanner::hg_scanner(ScannerSerial serial, const char* dev_name, usb_io* io,in
, 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)
, 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(OPTION_VALUE_DLSCLX_CS_HD_HB)
, img_type_(""), online_(false),is_quality_(-1),is_color_fill(false),is_multiout(false),save_multiout(hg_log::lang_load(ID_OPTION_VALUE_DLSCLX_CS_HD_HB))
, 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)
, async_io_(false), is_white_0_(true), isremove_left_hole(false), isremove_right_hole(false), isremove_top_hole(false), isremove_low_hole(false)
@ -161,6 +161,7 @@ hg_scanner::hg_scanner(ScannerSerial serial, const char* dev_name, usb_io* io,in
#if !defined(_WIN32) && !defined(_WIN64) &&defined(x86_64)
isx86_Advan_ = false;
#endif
lang_initialize();
init_setting_func_map();
final_path_ = hg_log::ini_get("path", "final_img");
if(final_path_.empty())
@ -249,8 +250,8 @@ hg_scanner::~hg_scanner()
delete custom_gamma_val_;
hg_imgproc::release(ImagePrc_pHandle_);
name_.insert(0, STATU_DESC_SCANNER_ERR_DEVICE_DEVS);
name_ += STATU_DESC_SCANNER_ERR_DEVICE_IS_CLOSE;
name_.insert(0, hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_DEVS));
name_ += hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_IS_CLOSE);
notify_ui_working_status(name_.c_str(), SANE_EVENT_SCANNER_CLOSED);
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "%s(%s) destroyed.\n", name_.c_str(), hg_log::format_ptr(this).c_str());
}
@ -831,7 +832,7 @@ bool hg_scanner::check_paper_and_resolution(int res, int paper)
}
bool hg_scanner::check_resolution_and_quality(int res, const char* quality)
{
if (res == 600 && strcmp(quality, OPTION_VALUE_HZ_SDYX) == 0)
if (res == 600 && strcmp(quality, hg_log::lang_load(ID_OPTION_VALUE_HZ_SDYX)) == 0)
{
VLOG_MINI_2(LOG_LEVEL_WARNING, "resolution '%d' is in-compatible with quality '%s'\n", res, quality);
@ -990,7 +991,7 @@ void hg_scanner::working_begin(void*)
stop_fatal_ = SCANNER_ERR_OK;
final_img_index_ = 0;
status_ = SCANNER_ERR_OK;
notify_ui_working_status(STATU_DESC_SCAN_WORKING, SANE_EVENT_WORKING, SCANNER_ERR_OK);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCAN_WORKING), SANE_EVENT_WORKING, SCANNER_ERR_OK);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "[%s] scanning ...\n", hg_log::current_time().c_str());
}
void hg_scanner::working_done(void*)
@ -1005,76 +1006,76 @@ void hg_scanner::working_done(void*)
switch (status_)
{
case SCANNER_ERR_OK:
notify_ui_working_status(STATU_DESC_SCAN_STOPPED, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCAN_STOPPED), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_BUSY:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_PC_BUSY, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_PC_BUSY), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_STOPPED:
notify_ui_working_status(STATU_DESC_SCAN_STOPPED, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCAN_STOPPED), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_COVER_OPENNED:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_COVER_OPENNED, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_COVER_OPENNED), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_NO_PAPER:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_FEEDING_PAPER:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_FEEDING_PAPER, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_FEEDING_PAPER), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_NOT_FOUND:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NOT_FOUND, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_NOT_FOUND), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_SLEEPING:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_COUNT_MODE:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_COUNT_MODE, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_COUNT_MODE), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_DOUBLE_FEEDING:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_DOUBLE_FEEDING, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_DOUBLE_FEEDING), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_PAPER_JAMMED:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_PAPER_JAMMED, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_PAPER_JAMMED), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_STAPLE_ON:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_STAPLE_ON, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_STAPLE_ON), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_PAPER_SKEW:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_PAPER_SKEW, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_PAPER_SKEW), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_SIZE_CHECK:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_SIZE_CHECK, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_SIZE_CHECK), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_DOGEAR:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_DOGEAR, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_DOGEAR), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_NO_IMAGE:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_IMAGE, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_NO_IMAGE), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_SCANN_ERROR:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_SCANN_ERROR, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_SCANN_ERROR), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_PC_BUSY:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_PC_BUSY, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_PC_BUSY), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_INSUFFICIENT_MEMORY:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_INSUFFICIENT_MEMORY, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_INSUFFICIENT_MEMORY), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_TIMEOUT:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_TIMEOUT, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_TIMEOUT), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_ISLOCK:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_ISLOCK, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_ISLOCK), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_AUTO_FAIL_OVER:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_AUTO_FAIL_OVER, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_AUTO_FAIL_OVER), SANE_EVENT_SCAN_FINISHED, status_);
break;
case SCANNER_ERR_DEVICE_DISTORTION:
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_DISTORTION, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_DISTORTION), SANE_EVENT_SCAN_FINISHED, status_);
break;
default:
notify_ui_working_status(user_cancel_ ? STATU_DESC_SCAN_CANCELED : STATU_DESC_SCAN_STOPPED, SANE_EVENT_SCAN_FINISHED, status_);
notify_ui_working_status(user_cancel_ ? hg_log::lang_load(ID_STATU_DESC_SCAN_CANCELED) : hg_log::lang_load(ID_STATU_DESC_SCAN_STOPPED), SANE_EVENT_SCAN_FINISHED, status_);
break;
}
@ -1858,7 +1859,7 @@ int hg_scanner::setting_scan_mode(void* data)
bool exact = check_range(SANE_STD_OPT_NAME_SCAN_MODE, str);
int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT;
if (strcmp(str.c_str(), OPTION_VALUE_SMZS_LXSM) == 0)
if (strcmp(str.c_str(), hg_log::lang_load(ID_OPTION_VALUE_SMZS_LXSM)) == 0)
{
scan_count_ = -1;
}
@ -1877,7 +1878,7 @@ int hg_scanner::setting_scan_count(void* data)
std::string val("");
setting_jsn_.at(SANE_STD_OPT_NAME_SCAN_MODE).at("cur").get_to(val);
if (val == OPTION_VALUE_SMZS_LXSM)
if (val == hg_log::lang_load(ID_OPTION_VALUE_SMZS_LXSM))
{
scan_count_ = -1;
}
@ -2140,7 +2141,7 @@ int hg_scanner::setting_auto_paper_scan(void* data)
if (!is_kernelsnap_220430_ && is_auto_paper_scan)
{
is_auto_paper_scan = *(bool*)data = false;
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NOT_SUPPORTED, SANE_EVENT_ERROR, status_);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_NOT_SUPPORTED), SANE_EVENT_ERROR, status_);
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
@ -2497,7 +2498,7 @@ std::shared_ptr<tiny_buffer> hg_scanner::aquire_memory(int size, bool from_usb)
{
mem.reset();
LOG_INFO(LOG_LEVEL_FATAL, "Can't aquire enough memory, working must be stopped!\n");
notify_ui_working_status(STATU_DESC_SCANNER_ERR_INSUFFICIENT_MEMORY, SANE_EVENT_ERROR, SCANNER_ERR_INSUFFICIENT_MEMORY);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_INSUFFICIENT_MEMORY), SANE_EVENT_ERROR, SCANNER_ERR_INSUFFICIENT_MEMORY);
stop();
}
@ -2539,7 +2540,7 @@ bool hg_scanner::waiting_for_memory_enough(unsigned need_bytes)
if (first)
{
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Memory is too small for aquiring image(%u bytes), wait for ENOUGH ...\n", need_bytes);
notify_ui_working_status(STATU_DESC_WAIT_FOR_MEM);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_WAIT_FOR_MEM));
first = false;
}
std::this_thread::sleep_for(std::chrono::milliseconds(30));
@ -2926,6 +2927,19 @@ int hg_scanner::get_setting(const char* name, char* json_txt_buf, int* len, int*
}
else
{
//json_name.find(real_n)
auto it = json_name.find(real_n);
if (it != json_name.end())
{
int i = it->second;
const char* load = hg_log::lang_load(i);
if (load)
{
setting_jsn_.at(real_n).at("title") = load;
}
}
std::string text(setting_jsn_.at(real_n).dump());
text.insert(0, "\"" + real_n + "\":");

2
hgdriver/hgdev/hg_scanner_200.cpp
View File

@ -277,7 +277,7 @@ int hg_scanner_200::start(void)
{
status_ = ret = SCANNER_ERR_DEVICE_NO_PAPER;
//notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_);
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER);
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER));
return ret;
}

14
hgdriver/hgdev/hg_scanner_239.cpp
View File

@ -949,7 +949,7 @@ void hg_scanner_239::thread_correction(void)
if (sw.elapsed_s() == 60)
{
status_ = ret;
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_FAIL_OUTTIME, SANE_EVENT_ERROR, ret); // 通信超时
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_FAIL_OUTTIME), SANE_EVENT_ERROR, ret); // 通信超时
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "设备校正超时 '%s'\n", hg_scanner_err_name(status_));
break;
}
@ -1011,13 +1011,13 @@ void hg_scanner_239::thread_get_dves_image(void)
if (img_conf_.resolution_dst == 600.0 && ++to_cnt > 50 && !is_auto_paper_scan)
{
status_ = ret;
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_OUTTIME, SANE_EVENT_ERROR, ret); // 取图通信超时
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_OUTTIME), SANE_EVENT_ERROR, ret); // 取图通信超时
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, " > 600DPI:%s\n", hg_scanner_err_name(status_));
break;
}
else if (img_conf_.resolution_dst < 600.0 && ++to_cnt > 20 && !is_auto_paper_scan)
{
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_OUTTIME, SANE_EVENT_ERROR, ret); // 取图通信超时
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_OUTTIME), SANE_EVENT_ERROR, ret); // 取图通信超时
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "< 600DPI:%s\n", hg_scanner_err_name(status_));
break;
}
@ -1143,7 +1143,7 @@ void hg_scanner_239::thread_get_dves_image(void)
ret = status_;
else
status_ = ret = SCANNER_ERR_USER_CANCELED;
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "%s:%s\n", STATU_DESC_SCANNER_ERR_DEVICE_GET_USER_CANCEL_SCAN, hg_scanner_err_name(status_));
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "%s:%s\n", hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_GET_USER_CANCEL_SCAN), hg_scanner_err_name(status_));
auoto_paper_indx = 0;
break;
}
@ -1168,7 +1168,7 @@ void hg_scanner_239::thread_get_dves_image(void)
//string str = "当前批次扫描完成(第"+to_string(++auoto_paper_indx)+"批)";
//string str = "\345\275\223\345\211\215\346\211\271\346\254\241\346\211\253\346\217\217\345\256\214\346\210\220(\347\254\254" + to_string(++auoto_paper_indx) + "\346\211\271)";
string str = STATU_DESC_SCANNER_ERR_DEVICE_ROUND_SACN_OVER;
string str = hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_ROUND_SACN_OVER);
str += ":" + to_string(++auoto_paper_indx);
if (is_auto_paper_scan)
notify_ui_working_status(str.c_str(), SANE_EVENT_STATUS, status_);
@ -1242,7 +1242,7 @@ int hg_scanner_239::start(void)
cb_mem_ = true;
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "scanner status: 0x%x\n", get_status());
notify_ui_working_status(STATU_DESC_PREPARE_START);
notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_PREPARE_START));
reset();
//ret = get_roller_num(val);
@ -1252,7 +1252,7 @@ int hg_scanner_239::start(void)
if (!val)
{
status_ = SCANNER_ERR_DEVICE_SLEEPING;
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING);
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING));
if(is_kernelsnap_220830_)
ret = set_notify_sleep();
//notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NOTIFY_SLEEP, SANE_EVENT_ERROR, status_);

2
hgdriver/hgdev/hg_scanner_300.cpp
View File

@ -265,7 +265,7 @@ int hg_scanner_300::start(void)
status_ = SCANNER_ERR_DEVICE_SLEEPING;
//notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING, SANE_EVENT_ERROR, status_);
//notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NOTIFY_SLEEP, SANE_EVENT_ERROR, status_);
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING);
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING));
return status_;
}
//ret = get_scanner_paperon(val);

4
hgdriver/hgdev/hg_scanner_400.cpp
View File

@ -240,7 +240,7 @@ int hg_scanner_400::start(void)
status_ = SCANNER_ERR_DEVICE_SLEEPING;
//notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING, SANE_EVENT_ERROR, status_);
//notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NOTIFY_SLEEP, SANE_EVENT_ERROR, status_);
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING);
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING));
return status_;
}
ret = get_scanner_paperon(val);
@ -248,7 +248,7 @@ int hg_scanner_400::start(void)
{
status_ = SCANNER_ERR_DEVICE_NO_PAPER;
//notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_);
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER);
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER));
return status_;
}

13
hgdriver/wrapper/hg_log.cpp
View File

@ -764,6 +764,19 @@ extern "C"
{
return GetMemoryUsage(getpid());
}
const char* lang_load(uint32_t id)
{
int err = 0;
const char *lang = lang_load_string(id, &err);
if (err != 0)
{
return NULL;
}
return lang;
}
}
#ifdef EXPORT_AS_C
}

3
hgdriver/wrapper/hg_log.h
View File

@ -7,7 +7,7 @@
#include <string>
#include "../../sdk/hginclude/huagaoxxx_warraper_ex.h"
#include "../../code_lang/app_language.h"
#if defined(WIN32) || defined(_WIN64)
#define bzero(a, l) memset(a, 0, l)
#define PATH_SEPARATOR "\\"
@ -58,6 +58,7 @@ extern "C"
std::string get_scanimage_ver();
float GetMemoryUsage(int pid);
float GetAppMemoryUsage();
const char* lang_load(uint32_t id);
unsigned int get_page_size(unsigned int* map_unit = nullptr);
unsigned long long available_memory(void);
void str_tolower(std::string& str);

2
hgdriver/wrapper/huagaoxxx_warraper_ex.cpp
View File

@ -297,7 +297,7 @@ extern "C"
// NOTE: multi-thread unsafe here
static char g_unk_err[80] = { 0 };
strcpy(g_unk_err, STATU_DESC_SCANNER_ERR_DEVICE_UNKNOWN_ERROR);
strcpy(g_unk_err, hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_UNKNOWN_ERROR));
sprintf(g_unk_err + strlen(g_unk_err), ":0x%x", err);
return g_unk_err;