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

调整JSON格式，依赖项从序号关联改为以name关联（JSON解析工具待优化）

This commit is contained in:
gb 2022-11-10 10:02:52 +08:00
parent de840b01e1
commit 4277129106
21 changed files with 717 additions and 794 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

944
hgdriver/hgdev/hg_scanner.cpp
View File

File diff suppressed because it is too large Load Diff

182
hgdriver/hgdev/hg_scanner.h
View File

@ -67,14 +67,16 @@ class hg_scanner
void dump_image_empty(hg_imgproc::HIMGPRC himg, const char* desc); void dump_image_empty(hg_imgproc::HIMGPRC himg, const char* desc);
void dump_image_real(hg_imgproc::HIMGPRC himg, const char* desc); void dump_image_real(hg_imgproc::HIMGPRC himg, const char* desc);
void get_range(int setting_no, std::vector<std::string>& range, std::string& def_val, bool& is_range/*range or list*/); void init_setting_func_map(void);
bool check_range(int setting_no, bool& val); std::string setting_name_from(const char* n_or_id);
bool check_range(int setting_no, int& val); void get_range(const char* name, std::vector<std::string>& range, std::string& def_val, bool& is_range/*range or list*/);
bool check_range(int setting_no, double& val); bool check_range(const char* name, bool& val);
bool check_range(int setting_no, std::string& val); bool check_range(const char* name, int& val);
bool check_range(const char* name, double& val);
bool check_range(const char* name, std::string& val);
bool check_paper_and_resolution(int res, int paper); bool check_paper_and_resolution(int res, int paper);
bool check_resolution_and_quality(int res, const char* quality); bool check_resolution_and_quality(int res, const char* quality);
int restore(int setting_no); int restore(const char* name);
bool get_default_value(void* buf, json* jsn); bool get_default_value(void* buf, json* jsn);
bool is_to_file(void); bool is_to_file(void);
void thread_handle_image_process(void); void thread_handle_image_process(void);
@ -85,13 +87,9 @@ class hg_scanner
void image_process(std::shared_ptr<tiny_buffer>& buff); void image_process(std::shared_ptr<tiny_buffer>& buff);
void reset_custom_area_range(int paper); void reset_custom_area_range(int paper);
float reset_custom_area_jsn_value(const char* name, double& var, float range_l, float range_u, float value_l, float value_u); // return cur value
int set_color_change(void); int set_color_change(void);
/////////////////////////////////////////
// ids ...
int id_scan_mode_ = -1;
int id_scan_count_ = -1;
/////////////////////////////////////////
// 设置接口 // 设置接口
protected: protected:
@ -104,84 +102,83 @@ protected:
// 2022-06-28: 属性处理函数改用map结构存储，只须处理set_setting_map函数即可 // 2022-06-28: 属性处理函数改用map结构存储，只须处理set_setting_map函数即可
// int setting_map_[HG_BASE_SETTING_INDEX_MAX]; // int setting_map_[HG_BASE_SETTING_INDEX_MAX];
//virtual void init_setting_map(int* setting_map, int count); //virtual void init_setting_map(int* setting_map, int count);
map<int, int (hg_scanner::*)(int, void*)> setting_map_; std::map<std::string, int (hg_scanner::*)(void*)> setting_map_;
int invoke_setting_xxx(int(hg_scanner::* func)(int, void*), void* data); int invoke_setting_xxx(int(hg_scanner::* func)(void*), void* data);
void set_setting_map(int sn, const char* name);
int setting_restore(int sn, void* data); int setting_restore(void* data);
int setting_help(int sn, void* data); int setting_help(void* data);
int setting_color_mode(int sn, void* data); int setting_color_mode(void* data);
int setting_multi_out(int sn, void*data); int setting_multi_out(void* data);
int setting_multi_out_type(int sn, void*data); int setting_multi_out_type(void* data);
int setting_rid_color(int sn, void* data); int setting_rid_color(void* data);
int setting_rid_multi_red(int sn, void* data); int setting_rid_multi_red(void* data);
int setting_rid_answer_red(int sn, void* data); int setting_rid_answer_red(void* data);
int setting_erase_background(int sn, void* data); int setting_erase_background(void* data);
int setting_erase_background_range(int sn, void* data); int setting_erase_background_range(void* data);
int setting_noise_optimize(int sn, void* data); int setting_noise_optimize(void* data);
int setting_noise_optimize_range(int sn, void* data); int setting_noise_optimize_range(void* data);
int setting_paper(int sn, void* data); int setting_paper(void* data);
int setting_paper_check(int sn, void* data); int setting_paper_check(void* data);
int setting_page(int sn, void* data); int setting_page(void* data);
int setting_page_omit_empty(int sn, void* data); int setting_page_omit_empty(void* data);
int setting_resolution(int sn, void* data); int setting_resolution(void* data);
int setting_exchagnge(int sn, void* data); int setting_exchagnge(void* data);
int setting_split_image(int sn, void* data); int setting_split_image(void* data);
int setting_automatic_skew(int sn, void* data); int setting_automatic_skew(void* data);
int setting_rid_hole(int sn, void* data); int setting_rid_hole(void* data);
int setting_rid_hoe_range(int sn, void* data); int setting_rid_hoe_range(void* data);
int setting_bright(int sn, void* data); int setting_bright(void* data);
int setting_contrast(int sn, void* data); int setting_contrast(void* data);
int setting_gamma(int sn, void* data); int setting_gamma(void* data);
int setting_sharpen(int sn, void* data); int setting_sharpen(void* data);
int setting_dark_sample(int sn, void* data); int setting_dark_sample(void* data);
int setting_erase_black_frame(int sn, void* data); int setting_erase_black_frame(void* data);
int setting_threshold(int sn, void* data); int setting_threshold(void* data);
int setting_anti_noise(int sn, void* data); int setting_anti_noise(void* data);
int setting_margin(int sn, void* data); int setting_margin(void* data);
int setting_filling_background(int sn, void* data); int setting_filling_background(void* data);
int setting_is_permeate(int sn, void*data); int setting_is_permeate(void* data);
int setting_is_permeate_lv(int sn, void*data); int setting_is_permeate_lv(void* data);
int setting_remove_morr(int sn, void* data); int setting_remove_morr(void* data);
int setting_error_extention(int sn, void* data); int setting_error_extention(void* data);
int setting_remove_texture(int sn, void* data); int setting_remove_texture(void* data);
int setting_ultrasonic_check(int sn, void* data); int setting_ultrasonic_check(void* data);
int setting_go_on_when_double_checked(int sn, void* data); int setting_go_on_when_double_checked(void* data);
int setting_staple_check(int sn, void* data); int setting_staple_check(void* data);
int setting_scan_mode(int sn, void* data); int setting_scan_mode(void* data);
int setting_scan_count(int sn, void* data); int setting_scan_count(void* data);
int setting_text_direction(int sn, void* data); int setting_text_direction(void* data);
int setting_rotate_bkg_180(int sn, void* data); int setting_rotate_bkg_180(void* data);
int setting_fractate_check(int sn, void* data); int setting_fractate_check(void* data);
int setting_fractate_check_level(int sn, void* data); int setting_fractate_check_level(void* data);
int setting_skew_check(int sn, void* data); int setting_skew_check(void* data);
int setting_skew_check_level(int sn, void* data); int setting_skew_check_level(void* data);
int setting_is_custom_gamma(int sn, void* data); int setting_is_custom_gamma(void* data);
int setting_custom_gamma_data(int sn, void* data); int setting_custom_gamma_data(void* data);
int setting_is_custom_area(int sn, void* data); int setting_is_custom_area(void* data);
int setting_custom_area_left(int sn, void* data); int setting_custom_area_left(void* data);
int setting_custom_area_top(int sn, void* data); int setting_custom_area_top(void* data);
int setting_custom_area_right(int sn, void* data); int setting_custom_area_right(void* data);
int setting_custom_area_bottom(int sn, void* data); int setting_custom_area_bottom(void* data);
int setting_img_quality(int sn, void*data); int setting_img_quality(void* data);
int setting_color_fill(int sn, void*data); int setting_color_fill(void* data);
int setting_keep_watermark(int sn, void* data); int setting_keep_watermark(void* data);
int setting_black_white_threshold(int sn, void* data); int setting_black_white_threshold(void* data);
int setting_white_pixel_0(int sn, void* data); int setting_white_pixel_0(void* data);
int setting_setfeedmode(int sn, void* data); int setting_setfeedmode(void* data);
int setting_setsleeptime(int sn, void* data); int setting_setsleeptime(void* data);
int setting_set_auto_pick_paper(int sn, void* data); int setting_set_auto_pick_paper(void* data);
int setting_set_auto_pick_paper_threshold(int sn, void* data); int setting_set_auto_pick_paper_threshold(void* data);
int setting_set_auto_paper_scan(int sn, void* data); int setting_set_auto_paper_scan(void* data);
int setting_set_isremove_left_hole(int sn, void* data); int setting_set_isremove_left_hole(void* data);
int setting_set_isremove_right_hole(int sn, void* data); int setting_set_isremove_right_hole(void* data);
int setting_set_isremove_top_hole(int sn, void* data); int setting_set_isremove_top_hole(void* data);
int setting_set_isremove_low_hole(int sn, void* data); int setting_set_isremove_low_hole(void* data);
int setting_set_isremove_left_hole_threshold(int sn, void* data); int setting_set_isremove_left_hole_threshold(void* data);
int setting_set_isremove_right_hole_threshold(int sn, void* data); int setting_set_isremove_right_hole_threshold(void* data);
int setting_set_isremove_top_hole_threshold(int sn, void* data); int setting_set_isremove_top_hole_threshold(void* data);
int setting_set_isremove_low_hole_threshold(int sn, void* data); int setting_set_isremove_low_hole_threshold(void* data);
int setting_set_fold_type(int sn, void* data); int setting_set_fold_type(void* data);
virtual int on_color_mode_changed(int& color_mode); // COLOR_MODE_xxx virtual int on_color_mode_changed(int& color_mode); // COLOR_MODE_xxx
virtual int on_paper_changed(int& paper); // PAPER_xxx virtual int on_paper_changed(int& paper); // PAPER_xxx
@ -197,9 +194,10 @@ protected:
virtual int on_pick_paper(bool autostrength);//设置搓纸使能 virtual int on_pick_paper(bool autostrength);//设置搓纸使能
virtual int on_pick_paper_threshold(double threshold);//设置搓纸阈值 virtual int on_pick_paper_threshold(double threshold);//设置搓纸阈值
virtual int on_is_auto_paper(bool isautopaper);//待纸扫描 virtual int on_is_auto_paper(bool isautopaper);//待纸扫描
protected: protected:
virtual void on_device_reconnected(void); virtual void on_device_reconnected(void);
virtual int set_setting_value(int setting_no, void* data, int len); virtual int set_setting_value(const char* name, void* data, int len);
virtual int on_scanner_closing(bool force); virtual int on_scanner_closing(bool force);
virtual void thread_handle_usb_read(void) = 0; virtual void thread_handle_usb_read(void) = 0;
@ -223,8 +221,8 @@ protected:
bool async_io_; bool async_io_;
bool cb_mem_; bool cb_mem_;
bool test_1_paper_; // 是否为单张扫描模式 bool test_1_paper_; // 是否为单张扫描模式
std::vector<std::string> jsn_children_;
json setting_jsn_; json setting_jsn_;
int setting_count_;
IMGPRCFIXPARAM image_prc_param_; IMGPRCFIXPARAM image_prc_param_;
int erase_bkg_range_; // 背景移除像素范围 int erase_bkg_range_; // 背景移除像素范围
@ -335,8 +333,8 @@ public:
int get_pid(void); int get_pid(void);
int get_vid(void); int get_vid(void);
int close(bool force); int close(bool force);
int set_setting(int setting_no, void* data, int len); int set_setting(const char* name, void* data, int len);
int get_setting(int setting_no, char* json_txt_buf, int* len); int get_setting(const char* name, char* json_txt_buf, int* len);
int hgpaper_to_devspaper(Paper_Map papermap[], int len, int& paper, bool* exact, TwSS* type); int hgpaper_to_devspaper(Paper_Map papermap[], int len, int& paper, bool* exact, TwSS* type);
int image_configuration(LPSCANCONF ic); int image_configuration(LPSCANCONF ic);
std::string name(void); std::string name(void);

8
hgdriver/hgdev/hg_scanner_200.cpp
View File

File diff suppressed because one or more lines are too long

8
hgdriver/hgdev/hg_scanner_239.cpp
View File

File diff suppressed because one or more lines are too long

8
hgdriver/hgdev/hg_scanner_300.cpp
View File

File diff suppressed because one or more lines are too long

12
hgdriver/hgdev/hg_scanner_302.cpp
View File

File diff suppressed because one or more lines are too long

8
hgdriver/hgdev/hg_scanner_400.cpp
View File

File diff suppressed because one or more lines are too long

16
hgdriver/hgdev/hg_scanner_402.cpp
View File

File diff suppressed because one or more lines are too long

12
hgdriver/hgdev/hg_scanner_439.cpp
View File

File diff suppressed because one or more lines are too long

15
hgdriver/hgdev/json.hpp
View File

@ -8730,12 +8730,12 @@ class parser
@throw parse_error.102 if to_unicode fails or surrogate error @throw parse_error.102 if to_unicode fails or surrogate error
@throw parse_error.103 if to_unicode fails @throw parse_error.103 if to_unicode fails
*/ */
void parse(const bool strict, BasicJsonType& result) void parse(const bool strict, BasicJsonType& result, std::vector<std::string> *children = NULL)
{ {
if (callback) if (callback)
{ {
json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions); json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
sax_parse_internal(&sdp); sax_parse_internal(&sdp, children);
result.assert_invariant(); result.assert_invariant();
// in strict mode, input must be completely read // in strict mode, input must be completely read
@ -8764,7 +8764,7 @@ class parser
else else
{ {
json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions); json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
sax_parse_internal(&sdp); sax_parse_internal(&sdp, children);
result.assert_invariant(); result.assert_invariant();
// in strict mode, input must be completely read // in strict mode, input must be completely read
@ -8819,7 +8819,7 @@ class parser
private: private:
template <typename SAX> template <typename SAX>
JSON_HEDLEY_NON_NULL(2) JSON_HEDLEY_NON_NULL(2)
bool sax_parse_internal(SAX* sax) bool sax_parse_internal(SAX* sax, std::vector<std::string>* children)
{ {
// stack to remember the hierarchy of structured values we are parsing // stack to remember the hierarchy of structured values we are parsing
// true = array; false = object // true = array; false = object
@ -8863,6 +8863,8 @@ class parser
{ {
return false; return false;
} }
if (children && states.empty())
children->push_back(m_lexer.get_string());
// parse separator (:) // parse separator (:)
if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator)) if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
@ -9059,6 +9061,8 @@ class parser
{ {
return false; return false;
} }
if (children && states.size() == 1)
children->push_back(m_lexer.get_string());
// parse separator (:) // parse separator (:)
if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator)) if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
@ -20743,11 +20747,12 @@ class basic_json
*/ */
JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_WARN_UNUSED_RESULT
static basic_json parse(detail::input_adapter&& i, static basic_json parse(detail::input_adapter&& i,
std::vector<std::string>* children = nullptr,
const parser_callback_t cb = nullptr, const parser_callback_t cb = nullptr,
const bool allow_exceptions = true) const bool allow_exceptions = true)
{ {
basic_json result; basic_json result;
parser(i, cb, allow_exceptions).parse(true, result); parser(i, cb, allow_exceptions).parse(true, result, children);
return result; return result;
} }

4
hgdriver/hgdev/jsonconfig.cpp
View File

@ -60,9 +60,9 @@ json jsonconfig::loadjson()
} }
return js; return js;
} }
json jsonconfig::load_json_from_text(const char* json_txt) json jsonconfig::load_json_from_text(const char* json_txt, std::vector<std::string>* children)
{ {
return json::parse(json_txt); return json::parse(json_txt, children);
} }
std::string jsonconfig::getdeviceparam(unsigned param_no) std::string jsonconfig::getdeviceparam(unsigned param_no)

2
hgdriver/hgdev/jsonconfig.h
View File

@ -19,7 +19,7 @@ class jsonconfig
{ {
public: public:
static json loadjson(std::string path); static json loadjson(std::string path);
static json load_json_from_text(const char* json_txt); static json load_json_from_text(const char* json_txt, std::vector<std::string>* children = nullptr);
static bool savejson(std::string path,json js); static bool savejson(std::string path,json js);
static json defaultjson(); static json defaultjson();

8
hgdriver/hgdev/scanner_manager.cpp
View File

@ -670,21 +670,21 @@ scanner_err hg_scanner_mgr::hg_scanner_close(scanner_handle h, bool force)
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
scanner_err hg_scanner_mgr::hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* data, long* len) scanner_err hg_scanner_mgr::hg_scanner_get_parameter(scanner_handle h, const char* name, char* data, long* len)
{ {
if (!len) if (!len)
return SCANNER_ERR_INVALID_PARAMETER; return SCANNER_ERR_INVALID_PARAMETER;
int l = *len, int l = *len,
err = SCAN_PTR(h)->get_setting(param_no, data, &l); err = SCAN_PTR(h)->get_setting(name, data, &l);
*len = l; *len = l;
return (scanner_err)err; return (scanner_err)err;
} }
scanner_err hg_scanner_mgr::hg_scanner_set_parameter(scanner_handle h, unsigned param_no, void* data, long len) scanner_err hg_scanner_mgr::hg_scanner_set_parameter(scanner_handle h, const char* name, void* data, long len)
{ {
return (scanner_err)SCAN_PTR(h)->set_setting(param_no, data, len); return (scanner_err)SCAN_PTR(h)->set_setting(name, data, len);
} }
scanner_err hg_scanner_mgr::hg_scanner_start(scanner_handle h, void* async_event, int num) scanner_err hg_scanner_mgr::hg_scanner_start(scanner_handle h, void* async_event, int num)
{ {

4
hgdriver/hgdev/scanner_manager.h
View File

@ -109,8 +109,8 @@ public:
scanner_err hg_scanner_enum(ScannerInfo* scanner_list, long* count, bool local_only); scanner_err hg_scanner_enum(ScannerInfo* scanner_list, long* count, bool 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); scanner_err hg_scanner_open(scanner_handle* h, const char* name, bool shared, const char* user, const char* pwd, const char* check, char* rsc);
scanner_err hg_scanner_close(scanner_handle h, bool force); scanner_err hg_scanner_close(scanner_handle h, bool force);
scanner_err hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* data, long* len); scanner_err hg_scanner_get_parameter(scanner_handle h, const char* name, char* data, long* len);
scanner_err hg_scanner_set_parameter(scanner_handle h, unsigned param_no, void* data, long len); scanner_err hg_scanner_set_parameter(scanner_handle h, const char* name, void* data, long len);
scanner_err hg_scanner_start(scanner_handle h, void* async_event, int num); scanner_err hg_scanner_start(scanner_handle h, void* async_event, int num);
scanner_err hg_scanner_stop(scanner_handle h); scanner_err hg_scanner_stop(scanner_handle h);
scanner_err hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len); scanner_err hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len);

12
hgdriver/wrapper/huagaoxxx_warraper_ex.cpp
View File

@ -122,14 +122,14 @@ extern "C"
return hg_scanner_mgr::instance()->hg_scanner_close(h, force); return hg_scanner_mgr::instance()->hg_scanner_close(h, force);
} }
scanner_err hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* data, long* len) scanner_err hg_scanner_get_parameter(scanner_handle h, const char* name, char* data, long* len)
{ {
return hg_scanner_mgr::instance()->hg_scanner_get_parameter(h, param_no, data, len); return hg_scanner_mgr::instance()->hg_scanner_get_parameter(h, name, data, len);
} }
scanner_err hg_scanner_set_parameter(scanner_handle h, unsigned param_no, void* data, long len) 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, param_no, data, 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) scanner_err hg_scanner_start(scanner_handle h, void* async_event, int num)
@ -402,7 +402,7 @@ extern "C"
#if defined(WIN32) || defined(_WIN64) #if defined(WIN32) || defined(_WIN64)
long after = 0; long after = 0;
if (as_start && _get_timezone(&after) == 0 && if (as_start && _get_timezone(&after) == 0 &&
after != bias) (after != bias && after != -bias))
{ {
now += bias; now += bias;
l = localtime(&now); l = localtime(&now);
@ -422,7 +422,7 @@ extern "C"
if (t) if (t)
*t = *l; *t = *l;
if (tmbuf) if (tmbuf)
swprintf(tmbuf, L"%04d-%02d-%02d %02d:%02d:%02d", l->tm_year + 1900, l->tm_mon + 1, l->tm_mday, l->tm_hour, l->tm_min, l->tm_sec); swprintf(tmbuf, 40, L"%04d-%02d-%02d %02d:%02d:%02d", l->tm_year + 1900, l->tm_mon + 1, l->tm_mday, l->tm_hour, l->tm_min, l->tm_sec);
} }
} }

7
hgsane/json.cpp
View File

@ -139,6 +139,13 @@ std::string json::to_string(void)
return ""; return "";
} }
std::string json::key(void)
{
if (obj_ && obj_->string)
return obj_->string;
else
return "";
}
bool json::get_value(const char* key, bool& val) bool json::get_value(const char* key, bool& val)
{ {
cJSON* obj = find(key); cJSON* obj = find(key);

1
hgsane/json.h
View File

@ -30,6 +30,7 @@ public:
std::string to_string(void); std::string to_string(void);
// can be path: child/value ... // can be path: child/value ...
std::string key(void);
bool get_value(const char* key, bool& val); bool get_value(const char* key, bool& val);
bool get_value(const char* key, int& val); bool get_value(const char* key, int& val);
bool get_value(const char* key, double& val); bool get_value(const char* key, double& val);

186
hgsane/sane_hg_mdw.cpp
View File

@ -288,7 +288,7 @@ namespace local_utility
SANE_Handle h = hg_sane_middleware::scanner_handle_to_sane(dev); SANE_Handle h = hg_sane_middleware::scanner_handle_to_sane(dev);
VLOG_MINI_1(LOG_LEVEL_ALL, "sane callback invoked of event %s\n", sane_event((SANE_Event)code).c_str()); // VLOG_MINI_1(LOG_LEVEL_ALL, "sane callback invoked of event %s\n", sane_event((SANE_Event)code).c_str());
if (cb_ui_) if (cb_ui_)
{ {
@ -782,14 +782,13 @@ SANE_Status hg_sane_middleware::open(SANE_String_Const devicename, SANE_Handle*
else else
return (SANE_Status)err; // SANE_STATUS_UNSUPPORTED; return (SANE_Status)err; // SANE_STATUS_UNSUPPORTED;
} }
SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, json* jsn, int opt_no) SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, const std::string& name, json* jsn, int opt_no)
{ {
std::string name(""), title(""), desc(""), val(""); std::string title(""), desc(""), val("");
std::vector<std::string> constraints; std::vector<std::string> constraints;
double lower = .0f, upper = .0f; double lower = .0f, upper = .0f;
bool db_val = false; bool db_val = false;
jsn->get_value("name", name);
jsn->get_value("title", title); jsn->get_value("title", title);
jsn->get_value("desc", desc); jsn->get_value("desc", desc);
@ -917,9 +916,8 @@ SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, json* js
ret->cap |= SANE_CAP_ADVANCED; ret->cap |= SANE_CAP_ADVANCED;
} }
if (strcmp(ret->title, "\345\210\206\350\276\250\347\216\207") == 0) if (strcmp(ret->name, SANE_STD_OPT_NAME_RESOLUTION) == 0)
{ {
LOG_INFO(LOG_LEVEL_DEBUG_INFO, "set \345\210\206\350\276\250\347\216\207 unit to DPI\n");
ret->unit = SANE_UNIT_DPI; ret->unit = SANE_UNIT_DPI;
} }
else if (strcmp(ret->name, SANE_STD_OPT_NAME_CUSTOM_AREA_LEFT) == 0 || else if (strcmp(ret->name, SANE_STD_OPT_NAME_CUSTOM_AREA_LEFT) == 0 ||
@ -948,12 +946,12 @@ SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, json* js
if (parse_depends(depend, so)) if (parse_depends(depend, so))
{ {
so.enable_now = (ret->cap & SANE_CAP_INACTIVE) != SANE_CAP_INACTIVE; so.enable_now = (ret->cap & SANE_CAP_INACTIVE) != SANE_CAP_INACTIVE;
so.option_no = opt_no; so.name = name;
// initializing status ... // initializing status ...
if (so.master.size()) if (so.master.size())
{ {
std::string master(get_option_json(h, so.master[0].option_no)); std::string master(get_option_json(h, (unsigned long)so.master[0].name.c_str()));
json* m = new json(); json* m = new json();
if (m->attach_text(&master[0])) if (m->attach_text(&master[0]))
{ {
@ -995,38 +993,69 @@ scanner_handle hg_sane_middleware::find_openning_device(SANE_Handle h, bool rmv,
return handle; return handle;
} }
std::string hg_sane_middleware::get_option_json(scanner_handle handle, int opt_no) std::string hg_sane_middleware::get_option_json(scanner_handle handle, unsigned long opt, std::string* key)
{ {
char* json_txt = NULL; char* json_txt = NULL;
long length = 0; long length = 0;
scanner_err err = hg_scanner_get_parameter(handle, opt_no, json_txt, &length); scanner_err err = hg_scanner_get_parameter(handle, (const char*)opt, json_txt, &length);
std::string ret(""); std::string ret("");
if (err == SCANNER_ERR_INSUFFICIENT_MEMORY) if (err == SCANNER_ERR_INSUFFICIENT_MEMORY)
{ {
json_txt = (char*)local_utility::acquire_memory(ALIGN_INT(length + 4), "hg_sane_middleware::get_option_json"); json_txt = (char*)local_utility::acquire_memory(ALIGN_INT(length + 4), "hg_sane_middleware::get_option_json");
bzero(json_txt, length + 4); bzero(json_txt, length + 4);
err = hg_scanner_get_parameter(handle, opt_no, json_txt, &length); err = hg_scanner_get_parameter(handle, (const char*)opt, json_txt, &length);
if (err == SCANNER_ERR_OK) if (err == SCANNER_ERR_OK)
{ {
ret = json_txt; const char* head = json_txt;
local_utility::skip_space(head);
if (*head == '\"')
{
head++;
while (*head != '\"' && *head)
ret.append(1, *head++);
if (*head)
{
head++;
local_utility::skip_space(head);
if (*head == ':')
{
head++;
local_utility::skip_space(head);
}
}
}
if (key)
*key = ret;
ret = head;
} }
free(json_txt); free(json_txt);
} }
return ret; return ret;
} }
SANE_Option_Descriptor* hg_sane_middleware::find_stored_descriptor(const char* name, int option) SANE_Option_Descriptor* hg_sane_middleware::find_stored_descriptor(const char* name, unsigned long option)
{ {
for (size_t i = 0; i < opts_.size(); ++i) if (IS_PTR_NUMBER(option))
{ {
if (opts_[i].dev_name == name && opts_[i].option_no == option) for (const auto& v : opts_)
return opts_[i].desc; {
if (v.dev_name == name && v.option_no == option)
return v.desc;
}
}
else
{
for (const auto& v : opts_)
{
if (v.dev_name == name && v.opt_name == (const char*)option)
return v.desc;
}
} }
return NULL; return NULL;
} }
SANE_Option_Descriptor* hg_sane_middleware::find_stored_descriptor(SANE_Handle handle, int option) SANE_Option_Descriptor* hg_sane_middleware::find_stored_descriptor(SANE_Handle handle, unsigned long option)
{ {
OPENDEV dev; OPENDEV dev;
scanner_handle h = find_openning_device(handle, false, &dev); scanner_handle h = find_openning_device(handle, false, &dev);
@ -1037,7 +1066,7 @@ SANE_Option_Descriptor* hg_sane_middleware::find_stored_descriptor(SANE_Handle h
return find_stored_descriptor(dev.dev_name.c_str(), option); return find_stored_descriptor(dev.dev_name.c_str(), option);
} }
void hg_sane_middleware::reload_current_value(scanner_handle handle, std::vector<int>* changed) void hg_sane_middleware::reload_current_value(scanner_handle handle, std::vector<std::string>* changed)
{ {
long count = 0; long count = 0;
@ -1046,20 +1075,22 @@ void hg_sane_middleware::reload_current_value(scanner_handle handle, std::vector
hg_scanner_get_parameter(handle, 0, NULL, &count); hg_scanner_get_parameter(handle, 0, NULL, &count);
for (int i = 1; i < count; ++i) for (int i = 1; i < count; ++i)
{ {
std::string val(get_option_json(handle, i)); std::string key(""),
val(get_option_json(handle, i, &key));
json* jsn = new json(); json* jsn = new json();
if (jsn->attach_text(&val[0]) && if (jsn->attach_text(&val[0]) &&
jsn->get_value("type", val)) jsn->get_value("type", val))
{ {
if (refresh_current_value(i, jsn)) if (refresh_current_value(key.c_str(), jsn))
changed->push_back(i); changed->push_back(key);
} }
delete jsn; delete jsn;
} }
} }
bool hg_sane_middleware::get_current_value(scanner_handle handle, int option, void* value, SANE_Value_Type* type) bool hg_sane_middleware::get_current_value(scanner_handle handle, int option, void* value, SANE_Value_Type* type)
{ {
std::string val(get_option_json(handle, option)); std::string name(""),
val(get_option_json(handle, option, &name));
json* jsn = new json(); json* jsn = new json();
int estimate = 20; int estimate = 20;
bool ret = false; bool ret = false;
@ -1068,9 +1099,7 @@ bool hg_sane_middleware::get_current_value(scanner_handle handle, int option, vo
jsn->get_value("type", val)) jsn->get_value("type", val))
{ {
SANE_Value_Type t = SANE_TYPE_STRING; SANE_Value_Type t = SANE_TYPE_STRING;
std::string name("");
jsn->get_value("name", name);
ret = true; ret = true;
if (val == "int") if (val == "int")
{ {
@ -1103,7 +1132,7 @@ bool hg_sane_middleware::get_current_value(scanner_handle handle, int option, vo
if (type) if (type)
*type = t; *type = t;
refresh_current_value(option, jsn); refresh_current_value(name.c_str(), jsn);
jsn->get_value("title", val); jsn->get_value("title", val);
@ -1123,6 +1152,8 @@ void* hg_sane_middleware::get_default_value(scanner_handle handle, int option, i
if (jsn->attach_text(&val[0]) && if (jsn->attach_text(&val[0]) &&
jsn->get_value("type", val)) jsn->get_value("type", val))
{ {
std::string title("");
jsn->get_value("title", title);
if (val == "bool") if (val == "bool")
{ {
bool v = false; bool v = false;
@ -1132,7 +1163,7 @@ void* hg_sane_middleware::get_default_value(scanner_handle handle, int option, i
memcpy(data, &v, sizeof(v)); memcpy(data, &v, sizeof(v));
if (bytes) if (bytes)
*bytes = sizeof(SANE_Bool); *bytes = sizeof(SANE_Bool);
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "option %d default value is: %s\n", option, v ? "true" : "false"); VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "option %d(%s) default value is: %s\n", option, title.c_str(), v ? "true" : "false");
} }
else if (val == "int") else if (val == "int")
{ {
@ -1143,7 +1174,7 @@ void* hg_sane_middleware::get_default_value(scanner_handle handle, int option, i
memcpy(data, &v, sizeof(v)); memcpy(data, &v, sizeof(v));
if (bytes) if (bytes)
*bytes = sizeof(v); *bytes = sizeof(v);
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "option %d default value is: %d\n", option, v); VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "option %d(%s) default value is: %d\n", option, title.c_str(), v);
} }
else if (val == "float") else if (val == "float")
{ {
@ -1156,7 +1187,7 @@ void* hg_sane_middleware::get_default_value(scanner_handle handle, int option, i
*bytes = sizeof(sd); *bytes = sizeof(sd);
memcpy(data, &sd, sizeof(sd)); memcpy(data, &sd, sizeof(sd));
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "option %d default value is: %f\n", option, v); VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "option %d(%s) default value is: %f\n", option, title.c_str(), v);
} }
else if (val == "string") else if (val == "string")
{ {
@ -1172,11 +1203,11 @@ void* hg_sane_middleware::get_default_value(scanner_handle handle, int option, i
strcpy((char*)data, val.c_str()); strcpy((char*)data, val.c_str());
if (bytes) if (bytes)
*bytes = val.length(); *bytes = val.length();
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "option %d default value is: %s\n", option, (char*)data); VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "option %d(%s) default value is: %s\n", option, title.c_str(), (char*)data);
} }
else else
{ {
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "option %d type is '%s' and cannot be set value.\n", option, val.c_str()); VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "option %d(%s) is '%s' and no value action.\n", option, title.c_str(), val.c_str());
} }
} }
delete jsn; delete jsn;
@ -1333,14 +1364,15 @@ SANE_Option_Descriptor* hg_sane_middleware::get_option_descriptor(SANE_Handle h,
ret = find_stored_descriptor(dev.dev_name.c_str(), option); ret = find_stored_descriptor(dev.dev_name.c_str(), option);
if (!ret) if (!ret)
{ {
std::string json_txt(get_option_json(handle, option)); std::string key(""),
json_txt(get_option_json(handle, option, &key));
if (json_txt.length()) if (json_txt.length())
{ {
json* jsn = new json(); json* jsn = new json();
if (jsn->attach_text(&json_txt[0])) if (jsn->attach_text(&json_txt[0]))
{ {
ret = from_json(handle, jsn, option); ret = from_json(handle, key, jsn, option);
if (ret) if (ret)
{ {
@ -1348,9 +1380,10 @@ SANE_Option_Descriptor* hg_sane_middleware::get_option_descriptor(SANE_Handle h,
devopt.dev_name = dev.dev_name; devopt.dev_name = dev.dev_name;
devopt.option_no = option; devopt.option_no = option;
devopt.desc = ret; devopt.desc = ret;
devopt.opt_name = key;
opts_.push_back(devopt); opts_.push_back(devopt);
refresh_current_value(option, jsn); refresh_current_value(devopt.opt_name.c_str(), jsn);
} }
} }
delete jsn; delete jsn;
@ -1385,7 +1418,7 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, SANE_Int option, SANE_
if (option == 0) if (option == 0)
{ {
long count = 0; long count = 0;
hg_scanner_get_parameter(handle, option, NULL, &count); hg_scanner_get_parameter(handle, (const char*)option, NULL, &count);
*((SANE_Int*)value) = count; *((SANE_Int*)value) = count;
ret = SANE_STATUS_GOOD; ret = SANE_STATUS_GOOD;
VLOG_MINI_1(LOG_LEVEL_WARNING, "get option count = %d.\n", count); VLOG_MINI_1(LOG_LEVEL_WARNING, "get option count = %d.\n", count);
@ -1414,7 +1447,9 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, SANE_Int option, SANE_
if (std_opt_ && std_opt_->is_known_option(option, &desc)) if (std_opt_ && std_opt_->is_known_option(option, &desc))
{ {
SANE_Option_Descriptor* known = std_opt_->get_option(option); SANE_Option_Descriptor* known = std_opt_->get_option(option);
unsigned char* cont = (unsigned char*)value;
prev = hg_sane_middleware::option_value_2_string(known->type, value); prev = hg_sane_middleware::option_value_2_string(known->type, value);
VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "$First 4-bytes of origin value for option %d is: %02X%02X%02X%02X\n", option, cont[0], cont[1], cont[2], cont[3]);
err = std_opt_->set_value(handle, option, value); err = std_opt_->set_value(handle, option, value);
v = hg_sane_middleware::option_value_2_string(known->type, value); v = hg_sane_middleware::option_value_2_string(known->type, value);
} }
@ -1463,7 +1498,7 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, SANE_Int option, SANE_
size = sizeof(dv); size = sizeof(dv);
} }
err = hg_scanner_set_parameter(handle, option, pass, size); err = hg_scanner_set_parameter(handle, (const char*)option, pass, size);
if (desc->type == SANE_TYPE_BOOL) if (desc->type == SANE_TYPE_BOOL)
{ {
@ -1487,11 +1522,11 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, SANE_Int option, SANE_
if (err == SCANNER_ERR_OK) if (err == SCANNER_ERR_OK)
{ {
err = (scanner_err)something_after_do(handle, dev.dev_name.c_str(), option, v.c_str()); err = (scanner_err)something_after_do(handle, dev.dev_name.c_str(), desc->name, v.c_str());
} }
else if (err == SCANNER_ERR_NOT_EXACT) else if (err == SCANNER_ERR_NOT_EXACT)
{ {
err = (scanner_err)(something_after_do(handle, dev.dev_name.c_str(), option, v.c_str()) | SANE_INFO_INEXACT); err = (scanner_err)(something_after_do(handle, dev.dev_name.c_str(), desc->name, v.c_str()) | SANE_INFO_INEXACT);
} }
else if (err == SCANNER_ERR_CONFIGURATION_CHANGED) else if (err == SCANNER_ERR_CONFIGURATION_CHANGED)
{ {
@ -1599,10 +1634,10 @@ bool hg_sane_middleware::is_enable_and(const std::vector<MASTEROP>& master, std:
for (size_t i = 0; enabled && i < master.size(); ++i) for (size_t i = 0; enabled && i < master.size(); ++i)
{ {
std::vector<CURVAL>::iterator it = std::find(curvals.begin(), curvals.end(), master[i].option_no); std::vector<CURVAL>::iterator it = std::find(curvals.begin(), curvals.end(), master[i].name);
if (it == curvals.end()) if (it == curvals.end())
{ {
VLOG_MINI_1(LOG_LEVEL_WARNING, "option %d's current value is not found, other options depend it maybe in wrong status.\n", master[i].option_no); VLOG_MINI_1(LOG_LEVEL_WARNING, "option %s's current value is not found, other options depend it maybe in wrong status.\n", master[i].name.c_str());
continue; continue;
} }
enabled &= master[i].compare_val(it->val.c_str(), master[i].limit_l.c_str(), master[i].limit_r.c_str()); enabled &= master[i].compare_val(it->val.c_str(), master[i].limit_l.c_str(), master[i].limit_r.c_str());
@ -1616,10 +1651,10 @@ bool hg_sane_middleware::is_enable_or(const std::vector<MASTEROP>& master, std::
for (size_t i = 0; !enabled && i < master.size(); ++i) for (size_t i = 0; !enabled && i < master.size(); ++i)
{ {
std::vector<CURVAL>::iterator it = std::find(curvals.begin(), curvals.end(), master[i].option_no); std::vector<CURVAL>::iterator it = std::find(curvals.begin(), curvals.end(), master[i].name);
if (it == curvals.end()) if (it == curvals.end())
{ {
VLOG_MINI_1(LOG_LEVEL_WARNING, "option %d's current value is not found, other options depend it maybe in wrong status.\n", master[i].option_no); VLOG_MINI_1(LOG_LEVEL_WARNING, "option %s's current value is not found, other options depend it maybe in wrong status.\n", master[i].name.c_str());
continue; continue;
} }
@ -1633,16 +1668,19 @@ bool hg_sane_middleware::parse_master_option(const char* depend_str, MASTEROP& m
{ {
bool ret = true; bool ret = true;
double num = .0f; double num = .0f;
std::string v("");
mo.option_no = 0;
mo.compare_val = &hg_sane_middleware::compare_val_equal; mo.compare_val = &hg_sane_middleware::compare_val_equal;
mo.limit_l = mo.limit_r = ""; mo.limit_l = mo.limit_r = "";
local_utility::skip_space(depend_str); local_utility::skip_space(depend_str);
ret = local_utility::get_number(depend_str, num); while ((*depend_str >= 'a' && *depend_str <= 'z') || *depend_str == '-')
v.push_back(*depend_str++);
if (!v.empty())
mo.name = v;
if (ret) if (ret)
{ {
mo.option_no = (int)num;
local_utility::skip_space(depend_str); local_utility::skip_space(depend_str);
if (*depend_str == '=') if (*depend_str == '=')
{ {
@ -1726,7 +1764,7 @@ bool hg_sane_middleware::parse_master_option(const char* depend_str, MASTEROP& m
} }
bool hg_sane_middleware::parse_depends(json* jsn, SLAVEOP& so) bool hg_sane_middleware::parse_depends(json* jsn, SLAVEOP& so)
{ {
std::string val(""); std::string val(""), mn("");
bool ret = jsn->first_child(val); bool ret = jsn->first_child(val);
while(ret) while(ret)
@ -1737,10 +1775,14 @@ bool hg_sane_middleware::parse_depends(json* jsn, SLAVEOP& so)
if (!ret) if (!ret)
break; break;
if (mo.name.empty())
mo.name = mn;
else
mn = mo.name;
so.master.push_back(mo); so.master.push_back(mo);
if (std::find(master_options_.begin(), master_options_.end(), mo.option_no) == master_options_.end()) if (std::find(master_options_.begin(), master_options_.end(), mo.name) == master_options_.end())
{ {
master_options_.push_back(mo.option_no); master_options_.push_back(mo.name);
std::sort(master_options_.begin(), master_options_.end()); std::sort(master_options_.begin(), master_options_.end());
} }
ret = jsn->next_child(val); ret = jsn->next_child(val);
@ -1749,13 +1791,13 @@ bool hg_sane_middleware::parse_depends(json* jsn, SLAVEOP& so)
return so.master.size() > 0; return so.master.size() > 0;
} }
bool hg_sane_middleware::is_associatived(const SLAVEOP& slave, int master_opt) bool hg_sane_middleware::is_associatived(const SLAVEOP& slave, const char* master_name)
{ {
bool result = false; bool result = false;
for (size_t i = 0; i < slave.master.size(); ++i) for (const auto& v: slave.master)
{ {
if (slave.master[i].option_no == master_opt) if (v.name == master_name)
{ {
result = true; result = true;
break; break;
@ -1764,7 +1806,7 @@ bool hg_sane_middleware::is_associatived(const SLAVEOP& slave, int master_opt)
return result; return result;
} }
bool hg_sane_middleware::set_stored_option_enabled(const char* dev_name, int option, bool enable, int* size) bool hg_sane_middleware::set_stored_option_enabled(const char* dev_name, unsigned long option, bool enable, int* size)
{ {
SANE_Option_Descriptor* opt = find_stored_descriptor(dev_name, option); SANE_Option_Descriptor* opt = find_stored_descriptor(dev_name, option);
bool ret = false; bool ret = false;
@ -1782,27 +1824,27 @@ bool hg_sane_middleware::set_stored_option_enabled(const char* dev_name, int opt
return ret; return ret;
} }
int hg_sane_middleware::something_after_do(scanner_handle h, const char* dev_name, int option_no, const char* cur_val) int hg_sane_middleware::something_after_do(scanner_handle h, const char* dev_name, const char* master_name, const char* cur_val)
{ {
int after = 0; int after = 0;
OPTENABLE oe; OPTENABLE oe;
std::vector<OPTENABLE> changed_options; std::vector<OPTENABLE> changed_options;
refresh_current_value(option_no, cur_val); refresh_current_value(master_name, cur_val);
if (std::find(master_options_.begin(), master_options_.end(), option_no) == master_options_.end()) if (std::find(master_options_.begin(), master_options_.end(), master_name) == master_options_.end())
{ {
return after; return after;
} }
oe.opt_no = option_no; oe.name = master_name;
oe.enable = true; oe.enable = true;
changed_options.push_back(oe); changed_options.push_back(oe);
for (size_t i = 0; i < changed_options.size(); ++i) for (size_t i = 0; i < changed_options.size(); ++i)
{ {
for (size_t slave = 0; slave < slave_options_.size(); ++slave) for (size_t slave = 0; slave < slave_options_.size(); ++slave)
{ {
if (slave_options_[slave].option_no == changed_options[i].opt_no || if (slave_options_[slave].name == changed_options[i].name ||
!is_associatived(slave_options_[slave], changed_options[i].opt_no)) !is_associatived(slave_options_[slave], changed_options[i].name.c_str()))
continue; continue;
bool enable = changed_options[i].enable; bool enable = changed_options[i].enable;
@ -1813,17 +1855,17 @@ int hg_sane_middleware::something_after_do(scanner_handle h, const char* dev_nam
continue; continue;
slave_options_[slave].enable_now = enable; slave_options_[slave].enable_now = enable;
if (!set_stored_option_enabled(dev_name, slave_options_[slave].option_no, enable, &bytes)) if (!set_stored_option_enabled(dev_name, (unsigned long)slave_options_[slave].name.c_str(), enable, &bytes))
continue; continue;
OPTEN* op = get_control_enalbe_data(slave_options_[slave]); OPTEN* op = get_control_enalbe_data(slave_options_[slave]);
hg_scanner_control(h, HG_CONTROL_CODE_OPTION_ENABLE, op, NULL); hg_scanner_control(h, HG_CONTROL_CODE_OPTION_ENABLE, op, NULL);
free_control_enable_data(op); free_control_enable_data(op);
if (std::find(changed_options.begin(), changed_options.end(), slave_options_[slave].option_no) != changed_options.end()) if (std::find(changed_options.begin(), changed_options.end(), slave_options_[slave].name) != changed_options.end())
continue; continue;
oe.opt_no = slave_options_[slave].option_no; oe.name = slave_options_[slave].name;
oe.enable = slave_options_[slave].enable_now; oe.enable = slave_options_[slave].enable_now;
changed_options.push_back(oe); changed_options.push_back(oe);
} }
@ -1834,14 +1876,14 @@ int hg_sane_middleware::something_after_do(scanner_handle h, const char* dev_nam
return after; return after;
} }
bool hg_sane_middleware::refresh_current_value(int opt, json* jsn) bool hg_sane_middleware::refresh_current_value(const char* name, json* jsn)
{ {
std::vector<CURVAL>::iterator it = std::find(cur_vals_.begin(), cur_vals_.end(), opt); std::vector<CURVAL>::iterator it = std::find(cur_vals_.begin(), cur_vals_.end(), name);
if (it == cur_vals_.end()) if (it == cur_vals_.end())
{ {
CURVAL cv; CURVAL cv;
jsn->get_value("type", cv.type); jsn->get_value("type", cv.type);
cv.opt_no = opt; cv.name = name;
jsn->get_value_as_string("cur", cv.val, cv.type == "int"); jsn->get_value_as_string("cur", cv.val, cv.type == "int");
cur_vals_.push_back(cv); cur_vals_.push_back(cv);
@ -1855,9 +1897,9 @@ bool hg_sane_middleware::refresh_current_value(int opt, json* jsn)
return old != it->val; return old != it->val;
} }
} }
bool hg_sane_middleware::refresh_current_value(int opt, const char* val) bool hg_sane_middleware::refresh_current_value(const char* name, const char* val)
{ {
std::vector<CURVAL>::iterator it = std::find(cur_vals_.begin(), cur_vals_.end(), opt); std::vector<CURVAL>::iterator it = std::find(cur_vals_.begin(), cur_vals_.end(), name);
if (it != cur_vals_.end()) if (it != cur_vals_.end())
{ {
bool ret = strcmp(it->val.c_str(), val) == 0; bool ret = strcmp(it->val.c_str(), val) == 0;
@ -1871,21 +1913,21 @@ bool hg_sane_middleware::refresh_current_value(int opt, const char* val)
} }
OPTEN* hg_sane_middleware::get_control_enalbe_data(const SLAVEOP& slave) OPTEN* hg_sane_middleware::get_control_enalbe_data(const SLAVEOP& slave)
{ {
std::vector<int> master; std::vector<std::string> master;
OPTEN* opt = NULL; OPTEN* opt = NULL;
size_t size = sizeof(OPTEN); size_t size = sizeof(OPTEN);
for (size_t i = 0; i < slave.master.size(); ++i) for (size_t i = 0; i < slave.master.size(); ++i)
{ {
if (std::find(master.begin(), master.end(), slave.master[i].option_no) == master.end()) if (std::find(master.begin(), master.end(), slave.master[i].name) == master.end())
master.push_back(slave.master[i].option_no); master.push_back(slave.master[i].name);
} }
size += master.size() * sizeof(OPTVAL); size += master.size() * sizeof(OPTVAL);
opt = (OPTEN*)malloc(size); opt = (OPTEN*)malloc(size);
bzero(opt, size); bzero(opt, size);
opt->enabled = slave.enable_now; opt->enabled = slave.enable_now;
opt->opt_num = slave.option_no; opt->name = slave.name;
opt->master_count = 0; opt->master_count = 0;
for (size_t i = 0; i < master.size(); ++i) for (size_t i = 0; i < master.size(); ++i)
{ {
@ -1893,7 +1935,7 @@ OPTEN* hg_sane_middleware::get_control_enalbe_data(const SLAVEOP& slave)
if (m == cur_vals_.end()) if (m == cur_vals_.end())
continue; continue;
opt->master[opt->master_count].opt_num = master[i]; opt->master[opt->master_count].name = master[i];
if (m->type == "string") if (m->type == "string")
{ {
opt->master[opt->master_count].data = malloc(m->val.length() + 4); opt->master[opt->master_count].data = malloc(m->val.length() + 4);
@ -1929,7 +1971,7 @@ void hg_sane_middleware::free_control_enable_data(OPTEN* opt)
} }
void hg_sane_middleware::on_SCANNER_ERR_CONFIGURATION_CHANGED(scanner_handle handle, const char* dev_name) void hg_sane_middleware::on_SCANNER_ERR_CONFIGURATION_CHANGED(scanner_handle handle, const char* dev_name)
{ {
std::vector<int> changed; std::vector<std::string> changed;
reload_current_value(handle, &changed); reload_current_value(handle, &changed);
if (changed.size()) if (changed.size())
{ {
@ -1937,7 +1979,7 @@ void hg_sane_middleware::on_SCANNER_ERR_CONFIGURATION_CHANGED(scanner_handle han
{ {
std::vector<CURVAL>::iterator it = std::find(cur_vals_.begin(), cur_vals_.end(), changed[i]); std::vector<CURVAL>::iterator it = std::find(cur_vals_.begin(), cur_vals_.end(), changed[i]);
if (it != cur_vals_.end()) if (it != cur_vals_.end())
something_after_do(handle, dev_name, it->opt_no, it->val.c_str()); something_after_do(handle, dev_name, it->name.c_str(), it->val.c_str());
} }
} }
} }

43
hgsane/sane_hg_mdw.h
View File

@ -32,6 +32,7 @@ class hg_sane_middleware
{ {
std::string dev_name; std::string dev_name;
int option_no; int option_no;
std::string opt_name;
SANE_Option_Descriptor* desc; SANE_Option_Descriptor* desc;
}DEVOPT; }DEVOPT;
std::vector<DEVOPT> opts_; std::vector<DEVOPT> opts_;
@ -74,13 +75,13 @@ class hg_sane_middleware
void on_device_closed(scanner_handle h); void on_device_closed(scanner_handle h);
SANE_Status open(SANE_String_Const devicename, SANE_Handle* handle, const char* name, const char* pwd, const char* method, char* rsc); SANE_Status open(SANE_String_Const devicename, SANE_Handle* handle, const char* name, const char* pwd, const char* method, char* rsc);
SANE_Option_Descriptor* from_json(scanner_handle h, json* jsn, int opt_no); SANE_Option_Descriptor* from_json(scanner_handle h, const std::string& name, json* jsn, int opt_no);
scanner_handle find_openning_device(SANE_Handle h, bool rmv = false, OPENDEV* dev = NULL); scanner_handle find_openning_device(SANE_Handle h, bool rmv = false, OPENDEV* dev = NULL);
std::string get_option_json(scanner_handle handle, int opt_no); std::string get_option_json(scanner_handle handle, unsigned long opt, std::string* key = nullptr);
SANE_Option_Descriptor* find_stored_descriptor(const char* name, int option); SANE_Option_Descriptor* find_stored_descriptor(const char* name, unsigned long option);
SANE_Option_Descriptor* find_stored_descriptor(SANE_Handle handle, int option); SANE_Option_Descriptor* find_stored_descriptor(SANE_Handle handle, unsigned long option);
void reload_current_value(scanner_handle handle, std::vector<int>* changed = NULL); void reload_current_value(scanner_handle handle, std::vector<std::string>* changed = NULL);
bool get_current_value(scanner_handle handle, int option, void* value, SANE_Value_Type* type = NULL); bool get_current_value(scanner_handle handle, int option, void* value, SANE_Value_Type* type = NULL);
void* get_default_value(scanner_handle handle, int option, int* bytes = nullptr); // caller should call local_utility::free_memory to free the returned value void* get_default_value(scanner_handle handle, int option, int* bytes = nullptr); // caller should call local_utility::free_memory to free the returned value
@ -90,18 +91,18 @@ class hg_sane_middleware
// 添加对多依赖项的支持 - 2022-03-10 // 添加对多依赖项的支持 - 2022-03-10
typedef struct _cur_val typedef struct _cur_val
{ {
int opt_no; std::string name;
std::string type; std::string type;
std::string val; /*参数全部字符串化*/ std::string val; /*参数全部字符串化*/
bool operator==(int sn) bool operator==(const std::string& n)
{ {
return opt_no == sn; return name == n;
} }
}CURVAL; }CURVAL;
std::vector<CURVAL> cur_vals_; std::vector<CURVAL> cur_vals_;
bool refresh_current_value(int opt, json* jsn); // return whether changed old value bool refresh_current_value(const char* name, json* jsn); // return whether changed old value
bool refresh_current_value(int opt, const char* val); bool refresh_current_value(const char* name, const char* val);
static bool compare_val_equal(const char* cur_val, const char* limit_l, const char* limit_r); static bool compare_val_equal(const char* cur_val, const char* limit_l, const char* limit_r);
static bool compare_val_not_equal(const char* cur_val, const char* limit_l, const char* limit_r); static bool compare_val_not_equal(const char* cur_val, const char* limit_l, const char* limit_r);
@ -113,7 +114,7 @@ class hg_sane_middleware
static bool compare_val_not_between(const char* cur_val, const char* limit_l, const char* limit_r); static bool compare_val_not_between(const char* cur_val, const char* limit_l, const char* limit_r);
typedef struct _master_option typedef struct _master_option
{ {
int option_no; std::string name;
SANE_Value_Type type; SANE_Value_Type type;
std::string limit_l; std::string limit_l;
std::string limit_r; std::string limit_r;
@ -124,14 +125,14 @@ class hg_sane_middleware
static bool is_enable_or(const std::vector<MASTEROP>& master, std::vector<CURVAL>& curvals); static bool is_enable_or(const std::vector<MASTEROP>& master, std::vector<CURVAL>& curvals);
typedef struct _slave_option typedef struct _slave_option
{ {
int option_no; std::string name;
bool enable_now; bool enable_now;
std::vector<MASTEROP> master; std::vector<MASTEROP> master;
bool (*is_enable)(const std::vector<MASTEROP>& master bool (*is_enable)(const std::vector<MASTEROP>& master
, std::vector<CURVAL>& curvals/*参数全部字符串化*/); // logic 'and', 'or' opertions , std::vector<CURVAL>& curvals/*参数全部字符串化*/); // logic 'and', 'or' opertions
}SLAVEOP; }SLAVEOP;
std::vector<SLAVEOP> slave_options_; std::vector<SLAVEOP> slave_options_;
std::vector<int> master_options_; std::vector<std::string> master_options_;
bool parse_master_option(const char* depend_str, MASTEROP& mo); bool parse_master_option(const char* depend_str, MASTEROP& mo);
@ -139,17 +140,17 @@ class hg_sane_middleware
typedef struct _opt_enabled typedef struct _opt_enabled
{ {
int opt_no; std::string name;
bool enable; bool enable;
bool operator==(const int& opt) bool operator==(const std::string& opt)
{ {
return opt_no == opt; return name == opt;
} }
}OPTENABLE; }OPTENABLE;
bool is_associatived(const SLAVEOP& slave, int master_opt); bool is_associatived(const SLAVEOP& slave, const char* master_name);
bool set_stored_option_enabled(const char* dev_name, int option, bool enable, int* size = NULL); bool set_stored_option_enabled(const char* dev_name, unsigned long option, bool enable, int* size = NULL);
int something_after_do(scanner_handle h, const char* dev_name, int option_no, const char* cur_val); int something_after_do(scanner_handle h, const char* dev_name, const char* master_name, const char* cur_val);
OPTEN* get_control_enalbe_data(const SLAVEOP& slave); OPTEN* get_control_enalbe_data(const SLAVEOP& slave);
void free_control_enable_data(OPTEN* opt); void free_control_enable_data(OPTEN* opt);
void on_SCANNER_ERR_CONFIGURATION_CHANGED(scanner_handle handle, const char* dev_name); void on_SCANNER_ERR_CONFIGURATION_CHANGED(scanner_handle handle, const char* dev_name);

6
hgsane/sane_option.cpp
View File

@ -176,11 +176,11 @@ json* sane_std_opts::get_opt_json(scanner_handle h, int opt)
long len = 0; long len = 0;
json* jsn = nullptr; json* jsn = nullptr;
if (hg_scanner_get_parameter(h, opt, buf, &len) == SCANNER_ERR_INSUFFICIENT_MEMORY) if (hg_scanner_get_parameter(h, (const char*)opt, buf, &len) == SCANNER_ERR_INSUFFICIENT_MEMORY)
{ {
buf = new char[len + 8]; buf = new char[len + 8];
memset(buf, 0, len + 8); memset(buf, 0, len + 8);
if (hg_scanner_get_parameter(h, opt, buf, &len) == SCANNER_ERR_OK) if (hg_scanner_get_parameter(h, (const char*)opt, buf, &len) == SCANNER_ERR_OK)
{ {
jsn = new json(); jsn = new json();
if (!jsn->attach_text(buf)) if (!jsn->attach_text(buf))
@ -387,7 +387,7 @@ scanner_err sane_std_opts::set_value(scanner_handle h, int opt, void* buf)
VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "%d->%d: %s\n", opt, op->user.opt, (char*)data); VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "%d->%d: %s\n", opt, op->user.opt, (char*)data);
statu = hg_scanner_set_parameter(h, op->user.opt, data, len); statu = hg_scanner_set_parameter(h, (const char*)op->user.opt, data, len);
if (statu == SCANNER_ERR_NOT_EXACT) if (statu == SCANNER_ERR_NOT_EXACT)
to_known_opt_value(op, data, buf); to_known_opt_value(op, data, buf);
if (data) if (data)

23
sdk/hginclude/huagaoxxx_warraper_ex.h
View File

@ -26,6 +26,7 @@
//////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////
#include "huagao/hgscanner_error.h" #include "huagao/hgscanner_error.h"
#include "sane/sane_ex.h" #include "sane/sane_ex.h"
#include <string>
#if defined(WIN32) || defined(_WIN64) #if defined(WIN32) || defined(_WIN64)
#include "../../../sdk/include/huagao/brand.h" #include "../../../sdk/include/huagao/brand.h"
@ -177,15 +178,15 @@ enum hg_control_code
}; };
typedef struct _opt_val typedef struct _opt_val
{ {
int opt_num; // 配置项序号 std::string name; // 配置项名称
void* data; // 配置项数据 void* data; // 配置项数据
}OPTVAL; }OPTVAL;
typedef struct _opt_enabled // 配置项使能状态改变 typedef struct _opt_enabled // 配置项使能状态改变
{ {
int opt_num; // 配置项序号 std::string name; // 配置项名称
int enabled; // 0 - 禁止；1 - 可用 int enabled; // 0 - 禁止；1 - 可用
int master_count; // 该配置项的依赖项数目 int master_count; // 该配置项的依赖项数目
OPTVAL master[1]; // 该配置项的依赖项当前值 OPTVAL master[1]; // 该配置项的依赖项当前值
}OPTEN; }OPTEN;
// //
@ -318,8 +319,7 @@ extern "C"{
// //
// Parameter: h - hg_open_scanner打开的设备句柄 // Parameter: h - hg_open_scanner打开的设备句柄
// //
// param_no - 参数序号，从1开始增长。如果为0，则在参数'len'中返回可配置的最大参数号 // name - 参数名称，如果为“null”，在len中返回参数总数量
// 超过可支持的最大参数号的时候，返回 E_OUTOFRANGE 的错误
// //
// json_data - JSON格式的参数数据（参考可变参数数据）, // json_data - JSON格式的参数数据（参考可变参数数据）,
// //
@ -331,14 +331,13 @@ extern "C"{
// Return: 错误代码，E_OK or E_INSUFFICIENTMEM or E_PARAMETERINVAL or E_DEVICENOTFOUND or E_OUTOFRANGE // Return: 错误代码，E_OK or E_INSUFFICIENTMEM or E_PARAMETERINVAL or E_DEVICENOTFOUND or E_OUTOFRANGE
// //
// NOTE: 'data'空间由用户分配，如果空间太小(包含传入NULL)，会在len中返回所需要的最小空间字节数，并返回 EINSUFFICIENTMEM // NOTE: 'data'空间由用户分配，如果空间太小(包含传入NULL)，会在len中返回所需要的最小空间字节数，并返回 EINSUFFICIENTMEM
scanner_err hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* json_data, long* len); scanner_err hg_scanner_get_parameter(scanner_handle h, const char* name, char* json_data, long* len);
// Function: 设置设备的配置参数 // Function: 设置设备的配置参数
// //
// Parameter: h - hg_open_scanner打开的设备句柄 // Parameter: h - hg_open_scanner打开的设备句柄
// //
// param_no - 参数序号，从1开始增长。超过可支持的最大参数号的时候，返回 E_OUTOFRANGE 的错误 // name - 参数名称，如果为“null”，忽略后面两个参数，将全部设置项恢复为默认设置
// 如果为“0”，忽略后面两个参数，将全部设置项恢复为默认设置
// //
// data - 参数数据，如果为“NULL”，执行恢复到默认值动作。所有类型的参数按照该功能号的实际类型指针处理 // data - 参数数据，如果为“NULL”，执行恢复到默认值动作。所有类型的参数按照该功能号的实际类型指针处理
// bool: (bool*)data // bool: (bool*)data
@ -352,7 +351,7 @@ extern "C"{
// //
// NOTE: 如果传入的参数不精确，则由驱动选择合适的参数设置并写入到data中，返回 E_NOTEXACT 的错误码。用户需要根据该参数更新UI // NOTE: 如果传入的参数不精确，则由驱动选择合适的参数设置并写入到data中，返回 E_NOTEXACT 的错误码。用户需要根据该参数更新UI
// 以共享方式打开的设备，没有设置权限，会返回 E_ACCESSDENIED 错误。 // 以共享方式打开的设备，没有设置权限，会返回 E_ACCESSDENIED 错误。
scanner_err hg_scanner_set_parameter(scanner_handle h, unsigned param_no, void* data, long len); scanner_err hg_scanner_set_parameter(scanner_handle h, const char* name, void* data, long len);
// Function: 启动设备工作 // Function: 启动设备工作
// //