diff --git a/sane/DlgIndicator.cpp b/sane/DlgIndicator.cpp index 560305a..273f0d8 100644 --- a/sane/DlgIndicator.cpp +++ b/sane/DlgIndicator.cpp @@ -13,7 +13,7 @@ dlg_indicator::dlg_indicator(HWND parent) : dlg_base(parent, IDD_INDICATOR) - , papers_(0), images_(0), err_(false) + , papers_(0), images_(0), err_(false), finish_(false) { create(); SetWindowLongW(GetDlgItem(hwnd_, IDC_STATIC_ERR), GWL_STYLE, GetWindowLong(GetDlgItem(hwnd_, IDC_STATIC_ERR), GWL_STYLE) | SS_OWNERDRAW); @@ -111,6 +111,7 @@ BOOL dlg_indicator::handle_message(UINT msg, WPARAM wp, LPARAM lp) notify_ui_event(SANE_EVENT_WORKING); break; case WM_SCAN_FINISHED: + finish_ = true; if (lp) { std::string* str = (std::string*)wp; @@ -156,7 +157,7 @@ void dlg_indicator::handle_command(WORD code, WORD id, HANDLE ctrl) { if (id == IDCANCEL) { - notify_over(true); + notify_over(!finish_); } } void dlg_indicator::notify_over(bool cancel) diff --git a/sane/DlgIndicator.h b/sane/DlgIndicator.h index 6c64d00..8329e44 100644 --- a/sane/DlgIndicator.h +++ b/sane/DlgIndicator.h @@ -13,6 +13,7 @@ class dlg_indicator : public dlg_base unsigned int papers_; unsigned int images_; bool err_; + bool finish_; BOOL handle_message(UINT msg, WPARAM wp, LPARAM lp) override; void handle_command(WORD code, WORD id, HANDLE ctrl); diff --git a/sane/s2t_api.h b/sane/s2t_api.h index d24fd78..6c81904 100644 --- a/sane/s2t_api.h +++ b/sane/s2t_api.h @@ -162,7 +162,7 @@ struct __declspec(novtable) ISaneInvoker : public IRef // Function: 获取配置项信息 // - // Parameter: sn - 配置项索引 + // Parameter: sn - 配置项索引 - sane_option_id // // type - 配置项数据类型 // @@ -172,6 +172,7 @@ struct __declspec(novtable) ISaneInvoker : public IRef COM_API_DECLARE(bool, get_option_info(int sn, value_type* type, value_limit* limit, int *bytes)); COM_API_DECLARE(bool, get_value(int sn, set_opt_value, void* param)); + COM_API_DECLARE(bool, get_value(int sn, void* data, int* len)); // get operation with in-parameter COM_API_DECLARE(int, set_value(int sn, void* val)); COM_API_DECLARE(int, convert_image(SANE_ImageFormatConvert* conv)); COM_API_DECLARE(void, free_buffer(void* buf, int len)); @@ -395,25 +396,24 @@ namespace sane_opts #define GET_SANE_OPT(type, object, id_name, limit, vct) \ { \ - int ind = object->sane_opt_id_##id_name##(); \ sane_opts::get_opts op(limit, vct); \ - if(ind > 0) \ - object->get_value(ind, sane_opts::set_opt_value, &op);\ - else \ - return capUnsupported(); \ + object->get_value(SANE_OPT_ID_##id_name, sane_opts::set_opt_value, &op); \ + op.re_order(); \ + } +#define GET_SANE_OPT_EX(type, object, id_name, limit, vct) \ + { \ + sane_opts::get_opts op(limit, vct); \ + object->get_value(object->sane_opt_id_##id_name##(), sane_opts::set_opt_value, &op); \ op.re_order(); \ } #define SET_SANE_OPT(ret, object, id_name, val) \ { \ - int ind = object->sane_opt_id_##id_name##(); \ - if(ind > 0) \ - ret = object->set_value(ind, val); \ - else \ - { \ - ret = SCANNER_ERR_INVALID_PARAMETER; \ - load_sane_util::log_info((std::wstring(L"Fatal: property '") + L###id_name + L"' not found !!!\r\n").c_str(), 0); \ - } \ + ret = object->set_value(SANE_OPT_ID_##id_name, val); \ + } +#define SET_SANE_OPT_EX(ret, object, id_name, val) \ + { \ + ret = object->set_value(object->sane_opt_id_##id_name##(), val);\ } typedef unsigned int SCANNERID; diff --git a/sane/scanner.cpp b/sane/scanner.cpp index 162d7b3..5291742 100644 --- a/sane/scanner.cpp +++ b/sane/scanner.cpp @@ -1,4 +1,4 @@ - + #include "scanner.h" @@ -16,17 +16,18 @@ #include "../../sdk/include/lang/app_language.h" #include #include "DlgIndicator.h" -#include "twain_user/twainui.h" +#include #pragma comment(lib, "Shlwapi.lib") static IMPLEMENT_OPTION_STRING_COMPARE(compare_sane_opt); -#define SET_SANE_OPT_ID(id, id_name, name, val, extension) \ - if(strcmp(SANE_STD_OPT_NAME_##name, val) == 0) \ - { \ - id_name##_id_ = id; \ - extension(id); \ +#define SET_SANE_OPT_ID(id, id_name, name, val, extension) \ + if(strcmp(SANE_STD_OPT_NAME_##name, val) == 0) \ + { \ + id_name##_id_ = id; \ + sane_ids_[(sane_option_id)SANE_OPT_ID_##name] = id; \ + extension(id); \ } @@ -342,7 +343,7 @@ namespace callback // SANE_EVENT_USB_DATA_RECEIVED- void* unused, be NULL, flag - unused, be 0 // SANE_EVENT_IMAGE_OK - void* unused, be NULL, flag - unused, be 0 int (*choose_scanner)(const std::vector& devs) = NULL; // blocked. return selected DEVQUE::id or -1 if user cancelled - int (*apply_current_config)(const char* dev_name, SANE_Handle device, LPSANEAPI api) = NULL; // 应用设备的当前配置 + int (*apply_current_config)(const char* dev_name, SANE_Handle device, LPSANEAPI api) = NULL; // 应用设备的当前配�? int (*show_setting_ui)(SANE_Handle device, HWND parent, LPSANEAPI api, const char* devname, bool with_scan, std::function callback) = NULL; int (*show_progress_ui)(HWND parent, std::function callback, std::function* notify) = NULL; int (*show_messagebox_ui)(HWND parent, int event, void* msg, int flag) = NULL; @@ -614,6 +615,18 @@ COM_API_IMPLEMENT(scanner, long, release(void)) return refer::release(); } +int scanner::transfer_id(int id) +{ + if (id > SANE_OPT_ID_BASE) + { + if (sane_ids_.count((sane_option_id)id) == 0) + id = -1; + else + id = sane_ids_[(sane_option_id)id]; + } + + return id; +} void scanner::transport_config_file(void) { size_t pos = scanner_name_.find(L" - "); @@ -880,6 +893,28 @@ int scanner::init_options_id(void) #define SET_OPT_ID(var, predef, func) \ SET_SANE_OPT_ID(op_id, var, predef, desc->name, func) +#define INIT_FIXED_IDS(id) \ + sane_ids_[id] = id; + + INIT_FIXED_IDS(SANE_OPT_ID_HISTORY_COUNT); + INIT_FIXED_IDS(SANE_OPT_ID_DRIVER_VERSION); + INIT_FIXED_IDS(SANE_OPT_ID_MANUFACTURER); + INIT_FIXED_IDS(SANE_OPT_ID_COPYRIGHT); + INIT_FIXED_IDS(SANE_OPT_ID_CO_URL); + INIT_FIXED_IDS(SANE_OPT_ID_CO_TEL); + INIT_FIXED_IDS(SANE_OPT_ID_CO_ADDR); + INIT_FIXED_IDS(SANE_OPT_ID_CO_GPS); + INIT_FIXED_IDS(SANE_OPT_ID_HELP); + INIT_FIXED_IDS(SANE_OPT_ID_VID); + INIT_FIXED_IDS(SANE_OPT_ID_PID); + INIT_FIXED_IDS(SANE_OPT_ID_DEV_NAME); + INIT_FIXED_IDS(SANE_OPT_ID_DEV_FAMILY); + INIT_FIXED_IDS(SANE_OPT_ID_LOGIN); + INIT_FIXED_IDS(SANE_OPT_ID_LOGOUT); + INIT_FIXED_IDS(SANE_OPT_ID_ROLLER_COUNT); + INIT_FIXED_IDS(SANE_OPT_ID_DRIVER_LOG); + INIT_FIXED_IDS(SANE_OPT_ID_DEVICE_LOG); + while ((desc = hg_sane_middleware::instance()->get_option_descriptor(handle_, (const void*)op_id))) { void* val = hg_sane_middleware::instance()->get_def_value(handle_, (void*)op_id, NULL, true); @@ -987,7 +1022,6 @@ int scanner::init_options_id(void) else SET_OPT_ID(is_erase_hole_b, RID_HOLE_B, extension_none) else SET_OPT_ID(search_hole_range_b, SEARCH_HOLE_RANGE_B, extension_none) else SET_OPT_ID(fold_direction, FOLD_TYPE, extension_none) - else SET_OPT_ID(fold_type, FOLD_TYPE, extension_none) else SET_OPT_ID(color_correction, COLOR_CORRECTION, extension_none) op_id++; } @@ -2536,6 +2570,56 @@ COM_API_IMPLEMENT(scanner, int, last_error(void)) COM_API_IMPLEMENT(scanner, bool, get_option_info(int sn, value_type* type, value_limit* limit, int* bytes)) { +#define SIMPLE_STR_INFO(id) \ + if (sn == id) \ + { \ + if (type) \ + *type = VAL_TYPE_STR; \ + if (limit) \ + *limit = VAL_LIMIT_NONE; \ + if (bytes) \ + *bytes = 255; \ + \ + return true; \ + } +#define SIMPLE_INT_INFO(id) \ + if (sn == id) \ + { \ + if (type) \ + *type = VAL_TYPE_INT; \ + if (limit) \ + *limit = VAL_LIMIT_NONE; \ + if (bytes) \ + *bytes = sizeof(int); \ + \ + return true; \ + } + + + SIMPLE_STR_INFO(SANE_OPT_ID_DRIVER_VERSION); + SIMPLE_STR_INFO(SANE_OPT_ID_MANUFACTURER); + SIMPLE_STR_INFO(SANE_OPT_ID_COPYRIGHT); + SIMPLE_STR_INFO(SANE_OPT_ID_CO_URL); + SIMPLE_STR_INFO(SANE_OPT_ID_CO_TEL); + SIMPLE_STR_INFO(SANE_OPT_ID_CO_ADDR); + SIMPLE_STR_INFO(SANE_OPT_ID_CO_GPS); + SIMPLE_STR_INFO(SANE_OPT_ID_DEV_NAME); + SIMPLE_STR_INFO(SANE_OPT_ID_DEV_FAMILY); + SIMPLE_STR_INFO(SANE_OPT_ID_LOGIN); + SIMPLE_STR_INFO(SANE_OPT_ID_LOGOUT); + SIMPLE_STR_INFO(SANE_OPT_ID_DRIVER_LOG); + SIMPLE_STR_INFO(SANE_OPT_ID_DEVICE_LOG); + + SIMPLE_INT_INFO(SANE_OPT_ID_HELP); + SIMPLE_INT_INFO(SANE_OPT_ID_HISTORY_COUNT); + SIMPLE_INT_INFO(SANE_OPT_ID_ROLLER_COUNT); + SIMPLE_INT_INFO(SANE_OPT_ID_VID); + SIMPLE_INT_INFO(SANE_OPT_ID_PID); + + sn = transfer_id(sn); + if (sn == -1) + return false; + EXAPIPOS ex = find_ex_api(sn); SANE_Option_Descriptor* desc = hg_sane_middleware::instance()->get_option_descriptor(handle_, ex == ex_opts_.end() ? (void*)sn : (void*)ex->base_ind); bool ret = false; @@ -2556,6 +2640,34 @@ COM_API_IMPLEMENT(scanner, bool, get_option_info(int sn, value_type* type, value } COM_API_IMPLEMENT(scanner, bool, get_value(int sn, set_opt_value setval, void* param)) { + if (sane_ids_.count((sane_option_id)sn) && + sane_ids_[(sane_option_id)sn] == sn) + { + char buf[256] = { 0 }; + value_type type = VAL_TYPE_NONE; + int ret = hg_sane_middleware::instance()->set_option(handle_, (void*)sn, SANE_ACTION_GET_VALUE, buf, NULL); + + if (ret == SANE_STATUS_GOOD) + { + get_option_info(sn, &type, NULL, NULL); + if (type == VAL_TYPE_STR) + { + std::string str(buf); + setval(&str, VAL_ROLE_CURRENT, VAL_LIMIT_NONE, param); + } + else + setval(buf, VAL_ROLE_CURRENT, VAL_LIMIT_NONE, param); + + return true; + } + + return false; + } + + sn = transfer_id(sn); + if (sn == -1) + return false; + EXAPIPOS ex = find_ex_api(sn); int ret = SANE_STATUS_INVAL; SANE_Int after = 0; @@ -2704,8 +2816,27 @@ COM_API_IMPLEMENT(scanner, bool, get_value(int sn, set_opt_value setval, void* p return ret == SANE_STATUS_GOOD; } +COM_API_IMPLEMENT(scanner, bool, get_value(int sn, void* data, int* len)) +{ + if (sn != SANE_OPT_ID_DRIVER_LOG && sn != SANE_OPT_ID_DEVICE_LOG) + return false; + + return hg_sane_middleware::instance()->set_option(handle_, (const void*)sn, SANE_ACTION_GET_VALUE, data, NULL) == SANE_STATUS_GOOD; +} COM_API_IMPLEMENT(scanner, int, set_value(int sn, void* val)) { + if (sane_ids_.count((sane_option_id)sn) && + sane_ids_[(sane_option_id)sn] == sn) + { + int ret = hg_sane_middleware::instance()->set_option(handle_, (void*)sn, SANE_ACTION_SET_VALUE, val, NULL); + + return ret == SANE_STATUS_GOOD; + } + + sn = transfer_id(sn); + if (sn == -1) + return SANE_STATUS_UNSUPPORTED; + EXAPIPOS ex = find_ex_api(sn); int ret = SANE_STATUS_INVAL; SANE_Int after = 0; diff --git a/sane/scanner.h b/sane/scanner.h index a0df8ad..ca4d7fc 100644 --- a/sane/scanner.h +++ b/sane/scanner.h @@ -5,6 +5,7 @@ #include #include #include +#include #define SANE_OPTION_ID(name) \ SANE_OPTION_ID_OVERRIDE(name); \ @@ -32,6 +33,13 @@ namespace gb class scanner : public ISaneInvoker, virtual public refer { + typedef struct _simple_opt + { + value_type type; + value_limit limit; + int bytes; + }SIMPLEOPT; + SANE_Handle handle_; SCANNERID id_; int err_; @@ -59,11 +67,14 @@ class scanner : public ISaneInvoker, virtual public refer gb::scanner_cfg* cfg_; bool twain_set_; SANEAPI sane_api_; + std::map sane_ids_; std::function ui_notify; int(__stdcall* scanner_ev_handler_)(int, void*); void* evh_param_; HWND app_wnd_; // for MessageBox bool is_show_ui_; + + int transfer_id(int id); // transfer fixed SANE option ID to real id, -1 is none void transport_config_file(void); void update_config(void); void load_config(const wchar_t* file); @@ -207,6 +218,7 @@ public: COM_API_OVERRIDE(int, last_error(void)); COM_API_OVERRIDE(bool, get_option_info(int sn, value_type* type, value_limit* limit, int* bytes)); COM_API_OVERRIDE(bool, get_value(int sn, set_opt_value, void* param)); + COM_API_OVERRIDE(bool, get_value(int sn, void* data, int* len)); // get operation with in-parameter COM_API_OVERRIDE(int, set_value(int sn, void* val)); COM_API_OVERRIDE(int, convert_image(SANE_ImageFormatConvert* conv)); COM_API_OVERRIDE(void, free_buffer(void* buf, int len)); @@ -329,4 +341,4 @@ public: // methods: public: int handle_device_event(int ev_code, void* data, unsigned int* len); -}; \ No newline at end of file +}; diff --git a/sln/sdk/lib/Debug/base_util.lib b/sln/sdk/lib/Debug/base_util.lib index e23d99d..8e5c14a 100644 Binary files a/sln/sdk/lib/Debug/base_util.lib and b/sln/sdk/lib/Debug/base_util.lib differ diff --git a/sln/sdk/lib/Release/base_util.lib b/sln/sdk/lib/Release/base_util.lib index 485e366..ddc0d58 100644 Binary files a/sln/sdk/lib/Release/base_util.lib and b/sln/sdk/lib/Release/base_util.lib differ diff --git a/twain/twain/huagaods.cpp b/twain/twain/huagaods.cpp index ceb4c97..8d1bd21 100644 --- a/twain/twain/huagaods.cpp +++ b/twain/twain/huagaods.cpp @@ -68,84 +68,6 @@ enum CapTypeEx : unsigned short { CAP_TYPE_EX_MULTI_OUT_TYPE = 0x8113, CAP_TYPE_EX_SCAN_WITH_HOLE = 0x8114, CAP_TYPE_EX_IP = 0x8200, - - // SANE设备层原始设置项透传属性 - CAP_EX_SANE = (int)CapType::CustomBase + 0x800, - CAP_EX_SANE_is_multiout, - CAP_EX_SANE_multiout_type, - CAP_EX_SANE_color_mode, - CAP_EX_SANE_erase_color, - CAP_EX_SANE_erase_multiout_red, - CAP_EX_SANE_erase_paper_red, - CAP_EX_SANE_is_erase_background, - CAP_EX_SANE_background_color_range, - CAP_EX_SANE_sharpen, - CAP_EX_SANE_erase_morr, - CAP_EX_SANE_erase_grids, - CAP_EX_SANE_error_extend, - CAP_EX_SANE_is_noise_modify, - CAP_EX_SANE_noise_threshold, - CAP_EX_SANE_paper, - CAP_EX_SANE_is_custom_area, - CAP_EX_SANE_curstom_area_l, - CAP_EX_SANE_curstom_area_r, - CAP_EX_SANE_curstom_area_t, - CAP_EX_SANE_curstom_area_b, - CAP_EX_SANE_is_size_check, - CAP_EX_SANE_page, - CAP_EX_SANE_blank_page_threshold, - CAP_EX_SANE_resolution, - CAP_EX_SANE_image_quality, - CAP_EX_SANE_is_swap, - CAP_EX_SANE_is_split, - CAP_EX_SANE_is_auto_deskew, - CAP_EX_SANE_is_custom_gamma, - CAP_EX_SANE_bright, - CAP_EX_SANE_contrast, - CAP_EX_SANE_gamma, - CAP_EX_SANE_is_erase_black_frame, - CAP_EX_SANE_deep_sample, - CAP_EX_SANE_threshold, - CAP_EX_SANE_anti_noise, - CAP_EX_SANE_margin, - CAP_EX_SANE_fill_background, - CAP_EX_SANE_is_anti_permeate, - CAP_EX_SANE_anti_permeate_level, - CAP_EX_SANE_is_erase_hole, - CAP_EX_SANE_search_hole_range, - CAP_EX_SANE_is_filling_color, - CAP_EX_SANE_is_ultrasonic_check, - CAP_EX_SANE_is_check_staple, - CAP_EX_SANE_scan_mode, - CAP_EX_SANE_scan_count, - CAP_EX_SANE_text_direction, - CAP_EX_SANE_is_rotate_bkg180, - CAP_EX_SANE_is_check_dogear, - CAP_EX_SANE_dogear_size, - CAP_EX_SANE_is_check_skew, - CAP_EX_SANE_skew_range, - CAP_EX_SANE_black_white_threshold, - CAP_EX_SANE_is_photo_mode, - CAP_EX_SANE_double_feed_handle, - CAP_EX_SANE_scan_when_paper_on, - CAP_EX_SANE_feed_strength, - CAP_EX_SANE_power_scheme, - CAP_EX_SANE_is_auto_strength, - CAP_EX_SANE_feed_strength_value, - CAP_EX_SANE_is_reverse_bw, - CAP_EX_SANE_is_erase_hole_l, - CAP_EX_SANE_search_hole_range_l, - CAP_EX_SANE_is_erase_hole_r, - CAP_EX_SANE_search_hole_range_r, - CAP_EX_SANE_is_erase_hole_t, - CAP_EX_SANE_search_hole_range_t, - CAP_EX_SANE_is_erase_hole_b, - CAP_EX_SANE_search_hole_range_b, - CAP_EX_SANE_fold_direction, - //CAP_EX_SANE_fold_type, - CAP_EX_SANE_color_correction, // 2023-02-24 15:31:19 色偏校正 // 2023-02-24 15:28:46 对折模式 - // END for SANE设备层原始设置项透传属性 - ///////////////////////////////////////////////////////////////////////// }; enum // .twain/first.cfg: [twain-app] flow=0 { @@ -913,19 +835,19 @@ Twpp::ConditionCode huagao_ds::condition_code_from_hg_error(int hgerr) return Twpp::ConditionCode::Success; if (hgerr == SCANNER_ERR_DEVICE_NOT_FOUND) return Twpp::ConditionCode::CheckDeviceOnline; - if (hgerr == SCANNER_ERR_IO) + if (hgerr == SCANNER_ERR_IO || hgerr == SANE_STATUS_IO_ERROR) return Twpp::ConditionCode::OperationError; if(hgerr == SCANNER_ERR_OUT_OF_RANGE) return Twpp::ConditionCode::BadCap; - if(hgerr == SCANNER_ERR_DEVICE_NOT_SUPPORT) + if(hgerr == SCANNER_ERR_DEVICE_NOT_SUPPORT || hgerr == SANE_STATUS_UNSUPPORTED) return Twpp::ConditionCode::BadProtocol; - if(hgerr == SCANNER_ERR_INVALID_PARAMETER) + if(hgerr == SCANNER_ERR_INVALID_PARAMETER || hgerr == SANE_STATUS_INVAL) return Twpp::ConditionCode::BadValue; - if(hgerr == SCANNER_ERR_ACCESS_DENIED) + if(hgerr == SCANNER_ERR_ACCESS_DENIED || hgerr == SANE_STATUS_ACCESS_DENIED) return Twpp::ConditionCode::Denied; if(hgerr == SCANNER_ERR_OPEN_FILE_FAILED) return Twpp::ConditionCode::FileNotFound; - if (hgerr == SCANNER_ERR_DEVICE_PAPER_JAMMED) + if (hgerr == SCANNER_ERR_DEVICE_PAPER_JAMMED || hgerr == SANE_STATUS_JAMMED) return Twpp::ConditionCode::PaperJam; if (hgerr == SCANNER_ERR_DEVICE_DOUBLE_FEEDING) return Twpp::ConditionCode::PaperDoubleFeed; @@ -933,11 +855,11 @@ Twpp::ConditionCode huagao_ds::condition_code_from_hg_error(int hgerr) return Twpp::ConditionCode::FileWriteError; if (hgerr == SCANNER_ERR_DEVICE_DOGEAR) return Twpp::ConditionCode::DamagedCorner; - if (hgerr == SCANNER_ERR_DEVICE_NO_PAPER) + if (hgerr == SCANNER_ERR_DEVICE_NO_PAPER || hgerr == SANE_STATUS_NO_DOCS) return Twpp::ConditionCode::NoMedia; if (hgerr == SCANNER_ERR_OPENED_BY_OTHER_PROCESS) return Twpp::ConditionCode::MaxConnections; - if(hgerr == SCANNER_ERR_INSUFFICIENT_MEMORY) + if(hgerr == SCANNER_ERR_INSUFFICIENT_MEMORY || hgerr == SANE_STATUS_NO_MEM) return Twpp::ConditionCode::LowMemory; if(hgerr == SCANNER_ERR_DEVICE_NOT_FOUND) return Twpp::ConditionCode::NoDs; @@ -1763,24 +1685,24 @@ void huagao_ds::init_support_caps(void) BYTE dup = 1; std::vector all; - GET_SANE_OPT(bool, scanner_, ex_duplex, NULL, &all); + GET_SANE_OPT_EX(bool, scanner_, ex_duplex, NULL, &all); dup = all[sane_opts::RANGE_POS_CURRENT]; if (dup && count >= 2) { count /= 2; } - SET_SANE_OPT(ret, scanner_, scan_count, &count); + SET_SANE_OPT_EX(ret, scanner_, scan_count, &count); return ret == SCANNER_ERR_OK ? success() : badValue(); } std::vector count; Int16 tmp_count = 0; - GET_SANE_OPT(int, scanner_, scan_count, NULL, &count); + GET_SANE_OPT_EX(int, scanner_, scan_count, NULL, &count); tmp_count = count[sane_opts::RANGE_POS_CURRENT]; BYTE dup = 1; std::vector all; - GET_SANE_OPT(bool, scanner_, ex_duplex, NULL, &all); + GET_SANE_OPT_EX(bool, scanner_, ex_duplex, NULL, &all); dup = all[sane_opts::RANGE_POS_CURRENT]; if (dup && tmp_count > 0 && tmp_count < 65535) { @@ -1869,7 +1791,7 @@ void huagao_ds::init_support_caps(void) log_attr_access((int)CapType::IBitDepth, (int)msg); std::vector all; int val = 0; - GET_SANE_OPT(int, scanner_, ex_color_mode, NULL, &all); + GET_SANE_OPT_EX(int, scanner_, ex_color_mode, NULL, &all); if (Msg::Set == msg || Msg::Reset == msg) { int ret = SCANNER_ERR_INVALID_PARAMETER; val = all[sane_opts::RANGE_POS_DEFAULT]; @@ -1890,7 +1812,7 @@ void huagao_ds::init_support_caps(void) swprintf_s(info, _countof(info) - 1, L"set CapType::IBitDepth = %d\r\n", val); load_sane_util::log_info(info, 0); } - SET_SANE_OPT(ret, scanner_, ex_color_mode, &val); + SET_SANE_OPT_EX(ret, scanner_, ex_color_mode, &val); if (Msg::Reset == msg) { UINT16 v = val; @@ -1921,7 +1843,7 @@ void huagao_ds::init_support_caps(void) std::vector values; value_limit limit = VAL_LIMIT_RANGE; int init = 0, now = 0; - GET_SANE_OPT(int, scanner_, resolution, NULL, &values); + GET_SANE_OPT_EX(int, scanner_, resolution, NULL, &values); init = values[sane_opts::RANGE_POS_DEFAULT]; now = values[sane_opts::RANGE_POS_CURRENT]; switch (msg) { @@ -1967,7 +1889,7 @@ void huagao_ds::init_support_caps(void) int ret = SCANNER_ERR_OK; float resl = (float)mech; int resli = (int)resl; - SET_SANE_OPT(ret, scanner_, resolution, &resli); + SET_SANE_OPT_EX(ret, scanner_, resolution, &resli); return ret == SCANNER_ERR_OK ? success() : badValue(); } default: @@ -1998,7 +1920,7 @@ void huagao_ds::init_support_caps(void) int now = 0, init = 0; std::vector all; - GET_SANE_OPT(int, scanner_, ex_paper, NULL, &all); + GET_SANE_OPT_EX(int, scanner_, ex_paper, NULL, &all); now = all[sane_opts::RANGE_POS_CURRENT]; init = all[sane_opts::RANGE_POS_DEFAULT]; if (msg == Msg::Set || msg == Msg::Reset) @@ -2008,7 +1930,7 @@ void huagao_ds::init_support_caps(void) else data = Capability::createOneValue((Twpp::PaperSize)init); - SET_SANE_OPT(now, scanner_, ex_paper, &init); + SET_SANE_OPT_EX(now, scanner_, ex_paper, &init); return now == SCANNER_ERR_OK ? success() : badValue(); } @@ -2098,7 +2020,7 @@ void huagao_ds::init_support_caps(void) std::vector values; int init = 0, now = 0; - GET_SANE_OPT(int, scanner_, ex_color_mode, NULL, &values); + GET_SANE_OPT_EX(int, scanner_, ex_color_mode, NULL, &values); now = values[sane_opts::RANGE_POS_CURRENT]; init = values[sane_opts::RANGE_POS_DEFAULT]; if (Msg::Reset == msg || Msg::Set == msg) @@ -2114,7 +2036,7 @@ void huagao_ds::init_support_caps(void) load_sane_util::log_info(info, 0); } int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, ex_color_mode, &init); + SET_SANE_OPT_EX(ret, scanner_, ex_color_mode, &init); data = Capability::createOneValue((Twpp::PixelType)init); return ret == SCANNER_ERR_OK ? success() : badValue(); } @@ -2145,12 +2067,12 @@ void huagao_ds::init_support_caps(void) if (Msg::Set == msg) { auto mech = data.currentItem(); int ret = SCANNER_ERR_OK, val = mech ? COLOR_AUTO_MATCH : COLOR_RGB; - SET_SANE_OPT(ret, scanner_, ex_auto_color_type, &val); + SET_SANE_OPT_EX(ret, scanner_, ex_auto_color_type, &val); return success(); } std::vector all; - GET_SANE_OPT(int, scanner_, ex_auto_color_type, NULL, &all); + GET_SANE_OPT_EX(int, scanner_, ex_auto_color_type, NULL, &all); int twpt = all[sane_opts::RANGE_POS_CURRENT] == COLOR_AUTO_MATCH ? 1 : 0; return CapSupGetAllReset(msg, data, { FALSE,TRUE }, twpt, false, twpt ? 1 : 0, 0); }; @@ -2164,7 +2086,7 @@ void huagao_ds::init_support_caps(void) if ((UInt16)mech == 0 || (UInt16)mech == 1) { int ret = SCANNER_ERR_OK, val = mech; - SET_SANE_OPT(ret, scanner_, ex_auto_color_type, &val); + SET_SANE_OPT_EX(ret, scanner_, ex_auto_color_type, &val); if (ret == SCANNER_ERR_OK) { automaticcolortype_ = (UInt16)mech; @@ -2191,12 +2113,12 @@ void huagao_ds::init_support_caps(void) return success(); //int ret = SCANNER_ERR_OK; //fif.detail = (void*)mech; - //SET_SANE_OPT(ret, scanner_, ex_final_format, &fif); + //SET_SANE_OPT_EX(ret, scanner_, ex_final_format, &fif); //return ret == SCANNER_ERR_OK ? success() : badValue(); } //unsigned short q = 80; //fif.detail = (void*)q; - //GET_SANE_OPT(SANE_FinalImgFormat, scanner_, ex_final_format, &fif, NULL, NULL, NULL); + //GET_SANE_OPT_EX(SANE_FinalImgFormat, scanner_, ex_final_format, &fif, NULL, NULL, NULL); //if(fif.img_format == SANE_IMAGE_TYPE_JPG) // q = (unsigned short)fif.detail; //return CapSupGetAllResetEx(msg, data, q, 80); @@ -2212,11 +2134,11 @@ void huagao_ds::init_support_caps(void) auto mech = data.currentItem(); bool lateral = mech == Orientation::Landscape; int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, ex_paper_lateral, &lateral); + SET_SANE_OPT_EX(ret, scanner_, ex_paper_lateral, &lateral); return ret == SCANNER_ERR_OK ? success() : badValue(); } std::vector values; - GET_SANE_OPT(bool, scanner_, ex_paper_lateral, NULL, &values); + GET_SANE_OPT_EX(bool, scanner_, ex_paper_lateral, NULL, &values); int lateral = values[sane_opts::RANGE_POS_CURRENT] ? (int)Orientation::Landscape : (int)Orientation::Portrait; return CapSupGetAllReset(msg, data, { Orientation::Portrait, Orientation::Landscape }, lateral, Orientation::Portrait, lateral == 0 ? 0 : 1, 0); }; @@ -2228,12 +2150,12 @@ void huagao_ds::init_support_caps(void) auto res = data.currentItem(); float angle = res.toFloat(); int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, ex_text_direction, &angle); + SET_SANE_OPT_EX(ret, scanner_, ex_text_direction, &angle); return ret == SCANNER_ERR_OK ? success() : badValue(); } std::vector values; - GET_SANE_OPT(float, scanner_, ex_text_direction, NULL, &values); + GET_SANE_OPT_EX(float, scanner_, ex_text_direction, NULL, &values); Fix32 Init = Fix32(values[sane_opts::RANGE_POS_DEFAULT]), Now = Fix32(values[sane_opts::RANGE_POS_CURRENT]); std::list vls; @@ -2273,22 +2195,22 @@ void huagao_ds::init_support_caps(void) bool mech = data.currentItem(); int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, ex_duplex, &mech); + SET_SANE_OPT_EX(ret, scanner_, ex_duplex, &mech); load_sane_util::log_info(mech ? L"Set1 Duplex is: true\r\n" : L"Set1 Duplex is: false\r\n", 0); int count = count_; if (mech && count_ >= 2) { count /= 2; - SET_SANE_OPT(ret, scanner_, scan_count, &count); + SET_SANE_OPT_EX(ret, scanner_, scan_count, &count); } else if (!mech && count_ >= 2) - SET_SANE_OPT(ret, scanner_, scan_count, &count); + SET_SANE_OPT_EX(ret, scanner_, scan_count, &count); return ret == SCANNER_ERR_OK ? success() : badValue(); } BYTE dup = 1; std::vector all; - GET_SANE_OPT(bool, scanner_, ex_duplex, NULL, &all); + GET_SANE_OPT_EX(bool, scanner_, ex_duplex, NULL, &all); dup = all[sane_opts::RANGE_POS_CURRENT]; load_sane_util::log_info(dup ? L"Get Duplex is: true\r\n" : L"Get Duplex is: false\r\n", 0); @@ -2298,10 +2220,10 @@ void huagao_ds::init_support_caps(void) if (dup && count_ >= 2) { count /= 2; - SET_SANE_OPT(ret, scanner_, scan_count, &count); + SET_SANE_OPT_EX(ret, scanner_, scan_count, &count); } else if (!dup && count_ >= 2) - SET_SANE_OPT(ret, scanner_, scan_count, &count) + SET_SANE_OPT_EX(ret, scanner_, scan_count, &count) return CapSupGetAllReset(msg, data, dup, Bool(true)); }; @@ -2322,7 +2244,7 @@ void huagao_ds::init_support_caps(void) log_attr_access((int)CapType::IImageFileFormat, (int)msg); SANE_FinalImgFormat now, init; std::vector all; - GET_SANE_OPT(SANE_FinalImgFormat, scanner_, ex_final_format, NULL, &all); + GET_SANE_OPT_EX(SANE_FinalImgFormat, scanner_, ex_final_format, NULL, &all); init = all[sane_opts::RANGE_POS_DEFAULT]; now = all[sane_opts::RANGE_POS_CURRENT]; if (Msg::Set == msg || Msg::Reset == msg) { @@ -2351,7 +2273,7 @@ void huagao_ds::init_support_caps(void) //if(Msg::Set == msg) // init.img_format = (SANE_ImageType)(int)data.currentItem(); //int ret = SCANNER_ERR_OK; - //SET_SANE_OPT(ret, scanner_, ex_final_format, &init); + //SET_SANE_OPT_EX(ret, scanner_, ex_final_format, &init); //return ret == SCANNER_ERR_OK ? success() : badValue(); } // ImageFileFormat Now = (ImageFileFormat)(int)now.img_format, Init = (ImageFileFormat)(int)init.img_format; @@ -2377,12 +2299,12 @@ void huagao_ds::init_support_caps(void) if (Msg::Set == msg) { auto atuodsw = data.currentItem(); int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, is_auto_deskew, (bool*)&atuodsw); + SET_SANE_OPT_EX(ret, scanner_, is_auto_deskew, (bool*)&atuodsw); return ret == SCANNER_ERR_OK ? success() : seqError(); } BYTE ato = 1; std::vector all; - GET_SANE_OPT(bool, scanner_, is_auto_deskew, NULL, &all); + GET_SANE_OPT_EX(bool, scanner_, is_auto_deskew, NULL, &all); ato = all[sane_opts::RANGE_POS_CURRENT]; return CapSupGetAllReset(msg, data, ato, true); }; @@ -2394,13 +2316,13 @@ void huagao_ds::init_support_caps(void) auto mech = data.currentItem(); float direction = mech ? AUTO_MATIC_ROTATE : .0f; int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, ex_text_direction, &direction); + SET_SANE_OPT_EX(ret, scanner_, ex_text_direction, &direction); return ret == SCANNER_ERR_OK ? success() : badValue(); } float direction = .0f; BYTE am = 0; std::vector all; - GET_SANE_OPT(float, scanner_, ex_text_direction, NULL, &all); + GET_SANE_OPT_EX(float, scanner_, ex_text_direction, NULL, &all); direction = all[sane_opts::RANGE_POS_CURRENT]; am = IS_DOUBLE_EQUAL(direction, AUTO_MATIC_ROTATE); return CapSupGetAllReset(msg, data, am, false); @@ -2411,7 +2333,7 @@ void huagao_ds::init_support_caps(void) log_attr_access((int)CapType::SerialNumber, (int)msg); Str255 str; std::vector all; - GET_SANE_OPT(std::string, scanner_, ex_serial, NULL, &all); + GET_SANE_OPT_EX(std::string, scanner_, ex_serial, NULL, &all); strcpy(str.data(), all[sane_opts::RANGE_POS_CURRENT].c_str()); return CapSupGetAll(msg, data, str, str); }; @@ -2427,11 +2349,11 @@ void huagao_ds::init_support_caps(void) val = (bool)data.currentItem(); int ret = SANE_STATUS_GOOD; m_autoscan = val; - SET_SANE_OPT(ret, scanner_, ex_to_be_scan, &val); + SET_SANE_OPT_EX(ret, scanner_, ex_to_be_scan, &val); return ret == SANE_STATUS_GOOD ? success() : badValue(); } std::vector all; - GET_SANE_OPT(bool, scanner_, ex_to_be_scan, NULL, &all); + GET_SANE_OPT_EX(bool, scanner_, ex_to_be_scan, NULL, &all); m_autoscan = (bool)all[sane_opts::RANGE_POS_CURRENT]; //return oneValGetSet(msg, data, (Bool)all[sane_opts::RANGE_POS_CURRENT], 0); //data = Capability::createOneValue(CapType::AutoScan, (BYTE)all[sane_opts::RANGE_POS_CURRENT]); @@ -2448,11 +2370,11 @@ void huagao_ds::init_support_caps(void) auto autosize = data.currentItem(); bool match = autosize == AutoSize::Auto; int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, ex_auto_paper_size, &match); + SET_SANE_OPT_EX(ret, scanner_, ex_auto_paper_size, &match); return ret == SCANNER_ERR_OK ? success() : badValue(); } std::vector all; - GET_SANE_OPT(bool, scanner_, ex_auto_paper_size, NULL, &all); + GET_SANE_OPT_EX(bool, scanner_, ex_auto_paper_size, NULL, &all); UInt16 size = all[sane_opts::RANGE_POS_CURRENT] ? (UInt16)AutoSize::Auto : (UInt16)AutoSize::None; return CapSupGetAllReset(msg, data, { AutoSize::None, AutoSize::Auto }, size, AutoSize::None, (size == (UInt16)AutoSize::Auto) ? 1 : 0, 0); }; @@ -2463,13 +2385,13 @@ void huagao_ds::init_support_caps(void) if (Msg::Set == msg) { auto autodetectborder = data.currentItem(); int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, is_size_check, (bool*)&autodetectborder); + SET_SANE_OPT_EX(ret, scanner_, is_size_check, (bool*)&autodetectborder); return ret == SCANNER_ERR_OK ? success() : badValue(); } Bool init = false, erase = false; std::vector all; - GET_SANE_OPT(bool, scanner_, is_size_check, NULL, &all); + GET_SANE_OPT_EX(bool, scanner_, is_size_check, NULL, &all); init = (bool)all[sane_opts::RANGE_POS_DEFAULT]; erase = (bool)all[sane_opts::RANGE_POS_CURRENT]; return CapSupGetAllReset(msg, data, { false,true }, erase, init, erase ? 1 : 0, 0); @@ -2482,11 +2404,11 @@ void huagao_ds::init_support_caps(void) auto mech = data.currentItem(); bool discard = mech == DiscardBlankPages::Auto; int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, ex_discard_blank_page, &discard); + SET_SANE_OPT_EX(ret, scanner_, ex_discard_blank_page, &discard); return ret == SCANNER_ERR_OK ? success() : badValue(); } std::vector all; - GET_SANE_OPT(bool, scanner_, ex_discard_blank_page, NULL, &all); + GET_SANE_OPT_EX(bool, scanner_, ex_discard_blank_page, NULL, &all); DiscardBlankPages autodiscradblank = all[sane_opts::RANGE_POS_CURRENT] ? DiscardBlankPages::Auto : DiscardBlankPages::Disabled; return CapSupGetAllReset(msg, data, autodiscradblank, DiscardBlankPages::Disabled); }; @@ -2498,11 +2420,11 @@ void huagao_ds::init_support_caps(void) auto mech = data.currentItem(); bool discard = mech == DiscardBlankPages::Auto; int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, ex_discard_blank_receipt, &discard); + SET_SANE_OPT_EX(ret, scanner_, ex_discard_blank_receipt, &discard); return ret == SCANNER_ERR_OK ? success() : badValue(); } std::vector all; - GET_SANE_OPT(bool, scanner_, ex_discard_blank_receipt, NULL, &all); + GET_SANE_OPT_EX(bool, scanner_, ex_discard_blank_receipt, NULL, &all); DiscardBlankPages autodiscradblank = all[sane_opts::RANGE_POS_CURRENT] ? DiscardBlankPages::Auto : DiscardBlankPages::Disabled; return CapSupGetAllResetEx(msg, data, autodiscradblank, DiscardBlankPages::Disabled); // return success(); @@ -2514,12 +2436,12 @@ void huagao_ds::init_support_caps(void) if (Msg::Set == msg) { auto mech = data.currentItem(); int ret = SCANNER_ERR_OK, val = to_sane_filter((Filter)mech); - SET_SANE_OPT(ret, scanner_, ex_color_filter, &val); + SET_SANE_OPT_EX(ret, scanner_, ex_color_filter, &val); return ret == SCANNER_ERR_OK ? success() : badValue(); } int cur = FILTER_NONE, def = FILTER_NONE; std::vector vals; - GET_SANE_OPT(int, scanner_, ex_color_filter, NULL, &vals); + GET_SANE_OPT_EX(int, scanner_, ex_color_filter, NULL, &vals); std::list vs; Filter now = from_sane_filter(vals[sane_opts::RANGE_POS_CURRENT]), @@ -2541,7 +2463,7 @@ void huagao_ds::init_support_caps(void) int init = 128, l = 1, u = 255, step = 1, now = 128; int ret = SCANNER_ERR_OK; std::vector all; - GET_SANE_OPT(int, scanner_, bright, NULL, &all); + GET_SANE_OPT_EX(int, scanner_, bright, NULL, &all); init = all[sane_opts::RANGE_POS_DEFAULT]; now = all[sane_opts::RANGE_POS_CURRENT]; l = all[sane_opts::RANGE_POS_LOWER]; @@ -2569,7 +2491,7 @@ void huagao_ds::init_support_caps(void) } case Msg::Reset: now = (int)(trans_range(initf, -1000.0f, 1000.0f, (float)l, (float)u) + .5f); - SET_SANE_OPT(ret, scanner_, bright, &now); + SET_SANE_OPT_EX(ret, scanner_, bright, &now); if (Msg::Reset == msg) { initf = trans_range((float)now, (float)l, (float)u, -1000.0f, 1000.0f, true); @@ -2587,7 +2509,7 @@ void huagao_ds::init_support_caps(void) int init = 4, l = 1, u = 7, step = 1, now = 4; int ret = SCANNER_ERR_OK; std::vector all; - GET_SANE_OPT(int, scanner_, contrast, NULL, &all); + GET_SANE_OPT_EX(int, scanner_, contrast, NULL, &all); init = all[sane_opts::RANGE_POS_DEFAULT]; now = all[sane_opts::RANGE_POS_CURRENT]; l = all[sane_opts::RANGE_POS_LOWER]; @@ -2615,7 +2537,7 @@ void huagao_ds::init_support_caps(void) } case Msg::Reset: now = (int)(trans_range(initf, -1000.0f, 1000.0f, (float)l, (float)u) + .5f); - SET_SANE_OPT(ret, scanner_, contrast, &now); + SET_SANE_OPT_EX(ret, scanner_, contrast, &now); if (Msg::Reset == msg) { initf = trans_range((float)now, (float)l, (float)u, -1000.0f, 1000.0f, true); @@ -2633,7 +2555,7 @@ void huagao_ds::init_support_caps(void) float init = .0f, l = .0f, u = .0f, step = .0f, now = .0f; std::vector all; int ret = SCANNER_ERR_OK; - GET_SANE_OPT(float, scanner_, search_hole_range, NULL, &all); + GET_SANE_OPT_EX(float, scanner_, search_hole_range, NULL, &all); init = all[sane_opts::RANGE_POS_DEFAULT] * 100.0f; now = all[sane_opts::RANGE_POS_CURRENT] * 100.0f; l = all[sane_opts::RANGE_POS_LOWER] * 100.0f; @@ -2657,7 +2579,7 @@ void huagao_ds::init_support_caps(void) } case Msg::Reset: init /= 100.0f; - SET_SANE_OPT(ret, scanner_, search_hole_range, &init); + SET_SANE_OPT_EX(ret, scanner_, search_hole_range, &init); return ret == SCANNER_ERR_OK ? success() : badValue(); default: return capBadOperation(); @@ -2670,7 +2592,7 @@ void huagao_ds::init_support_caps(void) float init = .0f, l = .0f, u = .0f, step = .0f, now = .0f; std::vector all; int ret = SCANNER_ERR_OK; - GET_SANE_OPT(float, scanner_, gamma, NULL, &all); + GET_SANE_OPT_EX(float, scanner_, gamma, NULL, &all); init = all[sane_opts::RANGE_POS_DEFAULT]; now = all[sane_opts::RANGE_POS_CURRENT]; l = all[sane_opts::RANGE_POS_LOWER]; @@ -2693,7 +2615,7 @@ void huagao_ds::init_support_caps(void) init = mech.toFloat(); } case Msg::Reset: - SET_SANE_OPT(ret, scanner_, gamma, &init); + SET_SANE_OPT_EX(ret, scanner_, gamma, &init); return ret == SCANNER_ERR_OK ? success() : badValue(); default: return capBadOperation(); @@ -2713,12 +2635,12 @@ void huagao_ds::init_support_caps(void) auto atuodsw = data.currentItem(); int ret = SCANNER_ERR_OK; bool enable = atuodsw == DoubleFeedDetection::Ultrasonic; - SET_SANE_OPT(ret, scanner_, is_ultrasonic_check, &enable); + SET_SANE_OPT_EX(ret, scanner_, is_ultrasonic_check, &enable); return ret == SCANNER_ERR_OK ? success() : seqError(); } DoubleFeedDetection init = DoubleFeedDetection::Ultrasonic; std::vector all; - GET_SANE_OPT(bool, scanner_, is_ultrasonic_check, NULL, &all); + GET_SANE_OPT_EX(bool, scanner_, is_ultrasonic_check, NULL, &all); BYTE ato = !all[sane_opts::RANGE_POS_CURRENT]; init = all[sane_opts::RANGE_POS_DEFAULT] ? DoubleFeedDetection::Ultrasonic : DoubleFeedDetection::ByLength; return CapSupGetAllReset(msg, data, ato, init); @@ -2728,7 +2650,7 @@ void huagao_ds::init_support_caps(void) m_caps[CapType::IAutomaticCropUsesFrame] = [this](Msg msg, Capability& data)->Result { log_attr_access((int)CapType::IAutomaticCropUsesFrame, (int)msg); std::vector all; - GET_SANE_OPT(bool, scanner_, ex_is_paper_auto_crop, NULL, &all); + GET_SANE_OPT_EX(bool, scanner_, ex_is_paper_auto_crop, NULL, &all); BYTE crop = all[sane_opts::RANGE_POS_CURRENT]; return CapSupGetAll(msg, data, crop, false); }; @@ -2750,11 +2672,11 @@ void huagao_ds::init_support_caps(void) if (msg == Msg::Set) fold = (bool)data.currentItem();; int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, ex_is_page_fold, &fold); + SET_SANE_OPT_EX(ret, scanner_, ex_is_page_fold, &fold); return ret == SCANNER_ERR_OK ? success() : badValue(); } std::vector all; - GET_SANE_OPT(bool, scanner_, ex_is_page_fold, NULL, &all); + GET_SANE_OPT_EX(bool, scanner_, ex_is_page_fold, NULL, &all); BYTE fold = all[sane_opts::RANGE_POS_CURRENT]; return CapSupGetAllResetEx(msg, data, fold, 0); }; @@ -2767,7 +2689,7 @@ void huagao_ds::init_support_caps(void) log_attr_access((int)CapTypeEx::CAP_TYPE_EX_DOGEAR_DIST, (int)msg); int now = 10, init = 10, l = 0, u = 100, s = 10; std::vector all; - GET_SANE_OPT(int, scanner_, dogear_size, NULL, &all); + GET_SANE_OPT_EX(int, scanner_, dogear_size, NULL, &all); init = all[sane_opts::RANGE_POS_DEFAULT]; now = all[sane_opts::RANGE_POS_CURRENT]; l = all[sane_opts::RANGE_POS_LOWER]; @@ -2782,7 +2704,7 @@ void huagao_ds::init_support_caps(void) init = (int)(trans_range((float)mech, 10.0f, 300.0f, (float)l, (float)u) + .5f); } int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, dogear_size, &init); + SET_SANE_OPT_EX(ret, scanner_, dogear_size, &init); return ret == SCANNER_ERR_OK ? success() : badValue(); } UInt32 Now = UInt32(trans_range((float)now, (float)l, (float)u, 10.0f, 300.0f) + .5f), @@ -2798,14 +2720,14 @@ void huagao_ds::init_support_caps(void) m_caps[(CapType)(CapTypeEx::CAP_TYPE_EX_CROP_MODEL)] = [this](Msg msg, Capability& data)->Result { log_attr_access((int)CapTypeEx::CAP_TYPE_EX_CROP_MODEL, (int)msg); std::vector all; - GET_SANE_OPT(bool, scanner_, ex_is_paper_auto_crop, NULL, &all); + GET_SANE_OPT_EX(bool, scanner_, ex_is_paper_auto_crop, NULL, &all); if (Msg::Set == msg || Msg::Reset == msg) { bool def = all[sane_opts::RANGE_POS_DEFAULT]; if (Msg::Set == msg) def = data.currentItem() == 1; int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, ex_is_paper_auto_crop, &def); + SET_SANE_OPT_EX(ret, scanner_, ex_is_paper_auto_crop, &def); return ret == SCANNER_ERR_OK ? success() : badValue(); } BYTE crop = all[sane_opts::RANGE_POS_CURRENT]; @@ -2820,7 +2742,7 @@ void huagao_ds::init_support_caps(void) log_attr_access((int)CapTypeEx::CAP_TYPE_EX_MULTI_OUT_TYPE, (int)msg); int cur = MULTI_OUT_NONE, def = MULTI_OUT_NONE; std::vector all; - GET_SANE_OPT(int, scanner_, ex_multiout_type, NULL, &all); + GET_SANE_OPT_EX(int, scanner_, ex_multiout_type, NULL, &all); cur = all[sane_opts::RANGE_POS_CURRENT]; def = all[sane_opts::RANGE_POS_DEFAULT]; if (Msg::Set == msg || Msg::Reset == msg) { @@ -2828,7 +2750,7 @@ void huagao_ds::init_support_caps(void) if (msg == Msg::Set) mech = data.currentItem(); int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, ex_multiout_type, &mech); + SET_SANE_OPT_EX(ret, scanner_, ex_multiout_type, &mech); return ret == SCANNER_ERR_OK ? success() : badValue(); } Int32 now = cur, init = def, ind = 0, @@ -2851,11 +2773,11 @@ void huagao_ds::init_support_caps(void) if (msg == Msg::Set) tobe = data.currentItem(); int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, ex_to_be_scan, &tobe); + SET_SANE_OPT_EX(ret, scanner_, ex_to_be_scan, &tobe); return ret == SCANNER_ERR_OK ? success() : seqError(); } std::vector all; - GET_SANE_OPT(bool, scanner_, ex_to_be_scan, NULL, &all); + GET_SANE_OPT_EX(bool, scanner_, ex_to_be_scan, NULL, &all); BYTE tobe = all[sane_opts::RANGE_POS_CURRENT]; return CapSupGetAllResetEx(msg, data, tobe, 0); }; @@ -2871,11 +2793,11 @@ void huagao_ds::init_support_caps(void) if (msg == Msg::Set) tobe = data.currentItem(); int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, ex_scan_with_hole, &tobe); + SET_SANE_OPT_EX(ret, scanner_, ex_scan_with_hole, &tobe); return ret == SCANNER_ERR_OK ? success() : seqError(); } std::vector all; - GET_SANE_OPT(bool, scanner_, ex_scan_with_hole, NULL, &all); + GET_SANE_OPT_EX(bool, scanner_, ex_scan_with_hole, NULL, &all); BYTE tobe = all[sane_opts::RANGE_POS_CURRENT];; return CapSupGetAllResetEx(msg, data, tobe, 0); }; @@ -2887,7 +2809,7 @@ void huagao_ds::init_support_caps(void) m_caps[(CapType)(CapTypeEx::CAP_TYPE_EX_ENCODE)] = [this](Msg msg, Capability& data)->Result { log_attr_access((int)CapTypeEx::CAP_TYPE_EX_ENCODE, (int)msg); std::vector all; - GET_SANE_OPT(std::string, scanner_, ex_device_code, NULL, &all); + GET_SANE_OPT_EX(std::string, scanner_, ex_device_code, NULL, &all); Str255 str; str.setData(all[sane_opts::RANGE_POS_CURRENT].c_str(), 32); data = Capability::createOneValue((CapType)CapTypeEx::CAP_TYPE_EX_ENCODE, str); @@ -2902,7 +2824,7 @@ void huagao_ds::init_support_caps(void) log_attr_access((int)CapTypeEx::CAP_TYPE_EX_POWER_LEVEL, (int)msg); int cur = SANE_POWER_MINUTES_30, def = SANE_POWER_MINUTES_30; std::vector all; - GET_SANE_OPT(int, scanner_, ex_power, NULL, &all); + GET_SANE_OPT_EX(int, scanner_, ex_power, NULL, &all); cur = all[sane_opts::RANGE_POS_CURRENT]; def = all[sane_opts::RANGE_POS_DEFAULT]; if (Msg::Set == msg || Msg::Reset == msg) { @@ -2910,7 +2832,7 @@ void huagao_ds::init_support_caps(void) def = data.currentItem(); int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, ex_power, &def); + SET_SANE_OPT_EX(ret, scanner_, ex_power, &def); return ret == SCANNER_ERR_OK ? success() : badValue(); } UInt32 now = cur, init = def, ind = 0, @@ -2933,14 +2855,14 @@ void huagao_ds::init_support_caps(void) if (Msg::Set == msg) { auto convex = data.currentItem(); int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, ex_fill_background, (bool*)&convex); + SET_SANE_OPT_EX(ret, scanner_, ex_fill_background, (bool*)&convex); return ret == SCANNER_ERR_OK ? success() : badValue(); } bool val = false, cur = false; Bool init = false, erase = false; std::vector all; - GET_SANE_OPT(bool, scanner_, ex_fill_background, NULL, &all); + GET_SANE_OPT_EX(bool, scanner_, ex_fill_background, NULL, &all); init = (bool)all[sane_opts::RANGE_POS_DEFAULT]; erase = (bool)all[sane_opts::RANGE_POS_CURRENT]; return CapSupGetAllResetEx(msg, data, { false,true }, erase, init, erase ? 1 : 0, 0); @@ -2954,7 +2876,7 @@ void huagao_ds::init_support_caps(void) log_attr_access((int)CapTypeEx::CAP_TYPE_EX_SHARPEN, (int)msg); int cur = MULTI_OUT_NONE, def = MULTI_OUT_NONE; std::vector all; - GET_SANE_OPT(int, scanner_, ex_sharpen, NULL, &all); + GET_SANE_OPT_EX(int, scanner_, ex_sharpen, NULL, &all); cur = all[sane_opts::RANGE_POS_CURRENT]; def = all[sane_opts::RANGE_POS_DEFAULT]; if (Msg::Set == msg || Msg::Reset == msg) { @@ -2962,7 +2884,7 @@ void huagao_ds::init_support_caps(void) if (msg == Msg::Set) mech = data.currentItem(); int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, ex_sharpen, &mech); + SET_SANE_OPT_EX(ret, scanner_, ex_sharpen, &mech); return ret == SCANNER_ERR_OK ? success() : badValue(); } Int32 now = cur, init = def, @@ -2982,14 +2904,14 @@ void huagao_ds::init_support_caps(void) log_attr_access((int)CapTypeEx::CAP_TYPE_EX_ENHANCE_COLOR, (int)msg); int cur = FILTER_NONE, def = FILTER_NONE; std::vector vals; - GET_SANE_OPT(int, scanner_, ex_color_enhance, NULL, &vals); + GET_SANE_OPT_EX(int, scanner_, ex_color_enhance, NULL, &vals); cur = vals[sane_opts::RANGE_POS_CURRENT]; def = vals[sane_opts::RANGE_POS_DEFAULT]; if (Msg::Set == msg || Msg::Reset == msg) { if (Msg::Set == msg) def = data.currentItem(); int ret = SCANNER_ERR_OK; - SET_SANE_OPT(ret, scanner_, ex_color_filter, &def); + SET_SANE_OPT_EX(ret, scanner_, ex_color_filter, &def); return ret == SCANNER_ERR_OK ? success() : badValue(); } @@ -3010,7 +2932,7 @@ void huagao_ds::init_support_caps(void) m_caps[(CapType)CapTypeEx::CAP_TYPE_EX_HARDWARE_VERSION] = [this](Msg msg, Capability& data)->Result { log_attr_access((int)CapTypeEx::CAP_TYPE_EX_HARDWARE_VERSION, (int)msg); std::vector all; - GET_SANE_OPT(std::string, scanner_, ex_hardware_version, NULL, &all); + GET_SANE_OPT_EX(std::string, scanner_, ex_hardware_version, NULL, &all); Str255 str; strcpy(str.data(), all[sane_opts::RANGE_POS_CURRENT].c_str()); data = Capability::createOneValue((CapType)CapTypeEx::CAP_TYPE_EX_HARDWARE_VERSION, str); @@ -3021,7 +2943,7 @@ void huagao_ds::init_support_caps(void) m_caps[(CapType)CapTypeEx::CAP_TYPE_EX_IP] = [this](Msg msg, Capability& data)->Result { log_attr_access((int)CapTypeEx::CAP_TYPE_EX_IP, (int)msg); std::vector all; - GET_SANE_OPT(std::string, scanner_, ex_ip, NULL, &all); + GET_SANE_OPT_EX(std::string, scanner_, ex_ip, NULL, &all); Str255 str; strcpy(str.data(), all[sane_opts::RANGE_POS_CURRENT].c_str()); data = Capability::createOneValue((CapType)CapTypeEx::CAP_TYPE_EX_IP, str); @@ -3029,40 +2951,40 @@ void huagao_ds::init_support_caps(void) }; #define SET_EXISTING_EXTENSION(name, cap) \ - if(m_query.count((CapType)CAP_EX_SANE_##name)) \ + if(m_query.count((CapType)SANE_OPT_ID_##name)) \ { \ - m_query[(CapType)cap] = m_query[(CapType)CAP_EX_SANE_##name]; \ - m_caps[(CapType)cap] = m_caps[CapType((int)CAP_EX_SANE_##name)]; \ + m_query[(CapType)cap] = m_query[(CapType)SANE_OPT_ID_##name]; \ + m_caps[(CapType)cap] = m_caps[CapType((int)SANE_OPT_ID_##name)]; \ } - SET_EXISTING_EXTENSION(is_swap, CapTypeEx::CAP_TYPE_EX_FLIP); - SET_EXISTING_EXTENSION(is_rotate_bkg180, CapTypeEx::CAP_TYPE_EX_ROTATE_BKG_180); - SET_EXISTING_EXTENSION(is_filling_color, CapTypeEx::CAP_TYPE_EX_FILL_BLACK_BKG); - SET_EXISTING_EXTENSION(margin, CapTypeEx::CAP_TYPE_EX_EDGE_IDENT); - SET_EXISTING_EXTENSION(anti_noise, CapTypeEx::CAP_TYPE_EX_ANTI_NOISE); - SET_EXISTING_EXTENSION(threshold, CapTypeEx::CAP_TYPE_EX_THRESHOLD); - SET_EXISTING_EXTENSION(is_erase_hole, CapTypeEx::CAP_TYPE_EX_FILL_HOLE); - SET_EXISTING_EXTENSION(is_noise_modify, CapTypeEx::CAP_TYPE_EX_DETACH_NOISE); - SET_EXISTING_EXTENSION(noise_threshold, CapTypeEx::CAP_TYPE_EX_DETACH_NOISE_THRESHOLD); - SET_EXISTING_EXTENSION(erase_multiout_red, CapTypeEx::CAP_TYPE_EX_RID_RED); - SET_EXISTING_EXTENSION(erase_paper_red, CapTypeEx::CAP_TYPE_EX_RID_RED_HSV); - SET_EXISTING_EXTENSION(is_check_skew, CapTypeEx::CAP_TYPE_EX_SCREW_DETECT); - SET_EXISTING_EXTENSION(skew_range, CapTypeEx::CAP_TYPE_EX_SCREW_DETECT_LEVEL); - SET_EXISTING_EXTENSION(is_check_staple, CapTypeEx::CAP_TYPE_EX_STAPLE_DETECT); - SET_EXISTING_EXTENSION(is_check_dogear, CapTypeEx::CAP_TYPE_EX_DOGEAR_DETECT); - SET_EXISTING_EXTENSION(deep_sample, CapTypeEx::CAP_TYPE_EX_DARK_SAMPLE); - SET_EXISTING_EXTENSION(is_split, CapTypeEx::CAP_TYPE_EX_IMAGE_SPLIT); - SET_EXISTING_EXTENSION(is_erase_background, CapTypeEx::CAP_TYPE_EX_FADE_BKG); - SET_EXISTING_EXTENSION(background_color_range, CapTypeEx::CAP_TYPE_EX_FADE_BKG_VALUE); - SET_EXISTING_EXTENSION(is_size_check, CapTypeEx::CAP_TYPE_EX_SIZE_DETECT); - SET_EXISTING_EXTENSION(is_multiout, CapTypeEx::CAP_TYPE_EX_MULTI_OUT); + SET_EXISTING_EXTENSION(EXCHANGE, CapTypeEx::CAP_TYPE_EX_FLIP); + SET_EXISTING_EXTENSION(IS_ROTATE_BKG_180, CapTypeEx::CAP_TYPE_EX_ROTATE_BKG_180); + SET_EXISTING_EXTENSION(IS_FILL_COLOR, CapTypeEx::CAP_TYPE_EX_FILL_BLACK_BKG); + SET_EXISTING_EXTENSION(MARGIN, CapTypeEx::CAP_TYPE_EX_EDGE_IDENT); + SET_EXISTING_EXTENSION(ANTI_NOISE_LEVEL, CapTypeEx::CAP_TYPE_EX_ANTI_NOISE); + SET_EXISTING_EXTENSION(THRESHOLD, CapTypeEx::CAP_TYPE_EX_THRESHOLD); + SET_EXISTING_EXTENSION(RID_HOLE, CapTypeEx::CAP_TYPE_EX_FILL_HOLE); + SET_EXISTING_EXTENSION(NOISE_OPTIMIZE, CapTypeEx::CAP_TYPE_EX_DETACH_NOISE); + SET_EXISTING_EXTENSION(NOISE_SIZE, CapTypeEx::CAP_TYPE_EX_DETACH_NOISE_THRESHOLD); + SET_EXISTING_EXTENSION(RID_MULTIOUT_RED, CapTypeEx::CAP_TYPE_EX_RID_RED); + SET_EXISTING_EXTENSION(RID_ANSWER_SHEET_RED, CapTypeEx::CAP_TYPE_EX_RID_RED_HSV); + SET_EXISTING_EXTENSION(IS_CHECK_ASKEW, CapTypeEx::CAP_TYPE_EX_SCREW_DETECT); + SET_EXISTING_EXTENSION(ASKEW_RANGE, CapTypeEx::CAP_TYPE_EX_SCREW_DETECT_LEVEL); + SET_EXISTING_EXTENSION(IS_CHECK_STAPLE, CapTypeEx::CAP_TYPE_EX_STAPLE_DETECT); + SET_EXISTING_EXTENSION(IS_CHECK_DOG_EAR, CapTypeEx::CAP_TYPE_EX_DOGEAR_DETECT); + SET_EXISTING_EXTENSION(DARK_SAMPLE, CapTypeEx::CAP_TYPE_EX_DARK_SAMPLE); + SET_EXISTING_EXTENSION(SPLIT, CapTypeEx::CAP_TYPE_EX_IMAGE_SPLIT); + SET_EXISTING_EXTENSION(ERASE_BACKGROUND, CapTypeEx::CAP_TYPE_EX_FADE_BKG); + SET_EXISTING_EXTENSION(BKG_COLOR_RANGE, CapTypeEx::CAP_TYPE_EX_FADE_BKG_VALUE); + SET_EXISTING_EXTENSION(SIZE_CHECK, CapTypeEx::CAP_TYPE_EX_SIZE_DETECT); + SET_EXISTING_EXTENSION(IS_MULTI_OUT, CapTypeEx::CAP_TYPE_EX_MULTI_OUT); } void huagao_ds::init_support_caps_ex(void) { -#define SET_SANE_CAP_ENUM(ctype, ttype, name) \ - m_query[(CapType)CAP_EX_SANE_##name] = msgSupportGetAllSetReset; \ - m_caps[(CapType)CAP_EX_SANE_##name] = [this](Msg msg, Capability& data) -> Result { \ - log_attr_access((int)CAP_EX_SANE_##name, (int)msg); \ +#define SET_SANE_CAP_ENUM(ctype, ttype, name, oper) \ + m_query[(CapType)SANE_OPT_ID_##name] = oper; \ + m_caps[(CapType)SANE_OPT_ID_##name] = [this](Msg msg, Capability& data) -> Result { \ + log_attr_access((int)SANE_OPT_ID_##name, (int)msg); \ ctype now, init; \ std::vector all; \ GET_SANE_OPT(ctype, scanner_, name, NULL, &all); \ @@ -3081,7 +3003,7 @@ void huagao_ds::init_support_caps_ex(void) { \ ttype v; \ copy_type(v, init); \ - data = Capability::createOneValue((CapType)CAP_EX_SANE_##name, v); \ + data = Capability::createOneValue((CapType)SANE_OPT_ID_##name, v); \ } \ return ret == SCANNER_ERR_OK ? success() : badValue(); \ } \ @@ -3092,7 +3014,7 @@ void huagao_ds::init_support_caps_ex(void) copy_type(t, now); \ else \ copy_type(t, init); \ - data = Capability::createOneValue((CapType)CAP_EX_SANE_##name, t); \ + data = Capability::createOneValue((CapType)SANE_OPT_ID_##name, t); \ return { ReturnCode::Success, ConditionCode::Success }; \ } \ else \ @@ -3105,15 +3027,15 @@ void huagao_ds::init_support_caps_ex(void) copy_type(t, all[i]); \ vals.push_back(t); \ } \ - data = Capability::createEnumeration((CapType)CAP_EX_SANE_##name, vals, ni, ii); \ + data = Capability::createEnumeration((CapType)SANE_OPT_ID_##name, vals, ni, ii); \ return { ReturnCode::Success, ConditionCode::Success }; \ } \ }; \ -#define SET_SANE_CAP_RANGE(ctype, ttype, name) \ - m_query[(CapType)CAP_EX_SANE_##name] = msgSupportGetAllSetReset; \ - m_caps[(CapType)CAP_EX_SANE_##name] = [this](Msg msg, Capability& data) -> Result { \ - log_attr_access((int)CAP_EX_SANE_##name, (int)msg); \ +#define SET_SANE_CAP_RANGE(ctype, ttype, name, oper) \ + m_query[(CapType)SANE_OPT_ID_##name] = oper; \ + m_caps[(CapType)SANE_OPT_ID_##name] = [this](Msg msg, Capability& data) -> Result { \ + log_attr_access((int)SANE_OPT_ID_##name, (int)msg); \ ctype now, init, lower, upper, step; \ std::vector all; \ GET_SANE_OPT(ctype, scanner_, name, NULL, &all); \ @@ -3135,7 +3057,7 @@ void huagao_ds::init_support_caps_ex(void) { \ ttype v; \ copy_type(v, init); \ - data = Capability::createOneValue((CapType)CAP_EX_SANE_##name, v); \ + data = Capability::createOneValue((CapType)SANE_OPT_ID_##name, v); \ } \ return ret == SCANNER_ERR_OK ? success() : badValue(); \ } \ @@ -3146,7 +3068,7 @@ void huagao_ds::init_support_caps_ex(void) copy_type(t, now); \ else \ copy_type(t, init); \ - data = Capability::createOneValue((CapType)CAP_EX_SANE_##name, t); \ + data = Capability::createOneValue((CapType)SANE_OPT_ID_##name, t); \ return { ReturnCode::Success, ConditionCode::Success }; \ } \ else \ @@ -3157,15 +3079,15 @@ void huagao_ds::init_support_caps_ex(void) copy_type(Lower, lower); \ copy_type(Upper, upper); \ copy_type(Step, step); \ - data = Capability::createRange((CapType)CAP_EX_SANE_##name, Lower, Upper, Step, Now, Init);\ + data = Capability::createRange((CapType)SANE_OPT_ID_##name, Lower, Upper, Step, Now, Init);\ return { ReturnCode::Success, ConditionCode::Success }; \ } \ }; \ -#define SET_SANE_CAP(ctype, ttype, name) \ - m_query[(CapType)CAP_EX_SANE_##name] = msgSupportGetAllSetReset; \ - m_caps[(CapType)CAP_EX_SANE_##name] = [this](Msg msg, Capability& data) -> Result { \ - log_attr_access((int)CAP_EX_SANE_##name, (int)msg); \ +#define SET_SANE_CAP(ctype, ttype, name, oper) \ + m_query[(CapType)SANE_OPT_ID_##name] = oper; \ + m_caps[(CapType)SANE_OPT_ID_##name] = [this](Msg msg, Capability& data) -> Result { \ + log_attr_access((int)SANE_OPT_ID_##name, (int)msg); \ ctype now, init; \ std::vector all; \ GET_SANE_OPT(ctype, scanner_, name, NULL, &all); \ @@ -3184,7 +3106,7 @@ void huagao_ds::init_support_caps_ex(void) { \ ttype v; \ copy_type(v, init); \ - data = Capability::createOneValue((CapType)CAP_EX_SANE_##name, v); \ + data = Capability::createOneValue((CapType)SANE_OPT_ID_##name, v); \ } \ return ret == SCANNER_ERR_OK ? success() : badValue(); \ } \ @@ -3195,59 +3117,58 @@ void huagao_ds::init_support_caps_ex(void) copy_type(t, now); \ else \ copy_type(t, init); \ - data = Capability::createOneValue((CapType)CAP_EX_SANE_##name, t); \ + data = Capability::createOneValue((CapType)SANE_OPT_ID_##name, t); \ return { ReturnCode::Success, ConditionCode::Success }; \ } \ else \ { \ ttype Now; \ copy_type(Now, now); \ - data = Capability::createOneValue((CapType)CAP_EX_SANE_##name, Now); \ + data = Capability::createOneValue((CapType)SANE_OPT_ID_##name, Now); \ return { ReturnCode::Success, ConditionCode::Success }; \ } \ }; \ -#define ADD_SANE_CAP(name) \ +#define ADD_SANE_CAP_WITH_OPER(name, oper) \ do \ { \ - int sn = scanner_->sane_opt_id_##name(); \ - if(sn == -1) break; \ value_type type; \ value_limit limit; \ - if(!scanner_->get_option_info(sn, &type, &limit, NULL)) break; \ + if(!scanner_->get_option_info(SANE_OPT_ID_##name, &type, &limit, NULL)) \ + break; \ if(limit == VAL_LIMIT_ENUM) \ { \ if(type == VAL_TYPE_INT) \ { \ - SET_SANE_CAP_ENUM(int, Int32, name) \ + SET_SANE_CAP_ENUM(int, Int32, name, oper) \ } \ else if(type == VAL_TYPE_FLOAT) \ { \ - SET_SANE_CAP_ENUM(float, Fix32, name) \ + SET_SANE_CAP_ENUM(float, Fix32, name, oper) \ } \ else \ { \ - SET_SANE_CAP_ENUM(std::string, Str255, name) \ + SET_SANE_CAP_ENUM(std::string, Str255, name, oper) \ } \ } \ else if(limit == VAL_LIMIT_RANGE) \ { \ if(type == VAL_TYPE_INT) \ { \ - SET_SANE_CAP_RANGE(int, Int32, name) \ + SET_SANE_CAP_RANGE(int, Int32, name, oper) \ } \ else if(type == VAL_TYPE_FLOAT) \ { \ - SET_SANE_CAP_RANGE(float, Fix32, name) \ + SET_SANE_CAP_RANGE(float, Fix32, name, oper) \ } \ } \ else \ { \ if(type == VAL_TYPE_BOOL) \ { \ - m_query[(CapType)CAP_EX_SANE_##name] = msgSupportGetAllSetReset; \ - m_caps[(CapType)CAP_EX_SANE_##name] = [this](Msg msg, Capability& data) -> Result { \ - log_attr_access((int)CAP_EX_SANE_##name, (int)msg); \ + m_query[(CapType)SANE_OPT_ID_##name] = oper; \ + m_caps[(CapType)SANE_OPT_ID_##name] = [this](Msg msg, Capability& data) -> Result { \ + log_attr_access((int)SANE_OPT_ID_##name, (int)msg); \ std::vector all; \ bool now = false, init = false; \ GET_SANE_OPT(bool, scanner_, name, NULL, &all); \ @@ -3268,106 +3189,256 @@ void huagao_ds::init_support_caps_ex(void) t = now; \ else \ t = init; \ - data = Capability::createOneValue((CapType)CAP_EX_SANE_##name, t); \ + data = Capability::createOneValue((CapType)SANE_OPT_ID_##name, t); \ return { ReturnCode::Success, ConditionCode::Success }; \ } \ else \ { \ UInt32 ni = now ? 1 : 0, ii = init ? 1 : 0; \ - data = Capability::createEnumeration((CapType)CAP_EX_SANE_##name, { FALSE, TRUE }, ni, ii); \ + data = Capability::createEnumeration((CapType)SANE_OPT_ID_##name, { FALSE, TRUE }, ni, ii); \ return { ReturnCode::Success, ConditionCode::Success }; \ } \ }; \ } \ else if(type == VAL_TYPE_INT) \ { \ - SET_SANE_CAP(int, Int32, name) \ + SET_SANE_CAP(int, Int32, name, oper) \ } \ else if(type == VAL_TYPE_FLOAT) \ { \ - SET_SANE_CAP(float, Fix32, name) \ + SET_SANE_CAP(float, Fix32, name, oper) \ } \ else \ { \ - SET_SANE_CAP(std::string, Str255, name) \ + SET_SANE_CAP(std::string, Str255, name, oper) \ } \ } \ }while (0); +#define ADD_SANE_CAP(name) \ + ADD_SANE_CAP_WITH_OPER(name, msgSupportGetAllSetReset) + // setting items ... - ADD_SANE_CAP(is_multiout); - ADD_SANE_CAP(multiout_type); - ADD_SANE_CAP(color_mode); - ADD_SANE_CAP(erase_color); - ADD_SANE_CAP(erase_multiout_red); - ADD_SANE_CAP(erase_paper_red); - ADD_SANE_CAP(is_erase_background); - ADD_SANE_CAP(background_color_range); - ADD_SANE_CAP(sharpen); - ADD_SANE_CAP(erase_morr); - ADD_SANE_CAP(erase_grids); - ADD_SANE_CAP(error_extend); - ADD_SANE_CAP(is_noise_modify); - ADD_SANE_CAP(noise_threshold); - ADD_SANE_CAP(paper); - ADD_SANE_CAP(is_custom_area); - ADD_SANE_CAP(curstom_area_l); - ADD_SANE_CAP(curstom_area_r); - ADD_SANE_CAP(curstom_area_t); - ADD_SANE_CAP(curstom_area_b); - ADD_SANE_CAP(is_size_check); - ADD_SANE_CAP(page); - ADD_SANE_CAP(blank_page_threshold); - ADD_SANE_CAP(resolution); - ADD_SANE_CAP(image_quality); - ADD_SANE_CAP(is_swap); - ADD_SANE_CAP(is_split); - ADD_SANE_CAP(is_auto_deskew); - ADD_SANE_CAP(is_custom_gamma); - ADD_SANE_CAP(bright); - ADD_SANE_CAP(contrast); - ADD_SANE_CAP(gamma); - ADD_SANE_CAP(is_erase_black_frame); - ADD_SANE_CAP(deep_sample); - ADD_SANE_CAP(threshold); - ADD_SANE_CAP(anti_noise); - ADD_SANE_CAP(margin); - ADD_SANE_CAP(fill_background); - ADD_SANE_CAP(is_anti_permeate); - ADD_SANE_CAP(anti_permeate_level); - ADD_SANE_CAP(is_erase_hole); - ADD_SANE_CAP(search_hole_range); - ADD_SANE_CAP(is_filling_color); - ADD_SANE_CAP(is_ultrasonic_check); - ADD_SANE_CAP(is_check_staple); - ADD_SANE_CAP(scan_mode); - ADD_SANE_CAP(scan_count); - ADD_SANE_CAP(text_direction); - ADD_SANE_CAP(is_rotate_bkg180); - ADD_SANE_CAP(is_check_dogear); - ADD_SANE_CAP(dogear_size); - ADD_SANE_CAP(is_check_skew); - ADD_SANE_CAP(skew_range); - ADD_SANE_CAP(black_white_threshold); - ADD_SANE_CAP(is_photo_mode); - ADD_SANE_CAP(double_feed_handle); - ADD_SANE_CAP(scan_when_paper_on); - ADD_SANE_CAP(feed_strength); - ADD_SANE_CAP(power_scheme); - ADD_SANE_CAP(is_auto_strength); - ADD_SANE_CAP(feed_strength_value); - ADD_SANE_CAP(is_reverse_bw); - ADD_SANE_CAP(is_erase_hole_l); // 穿孔移除 - 左 - ADD_SANE_CAP(search_hole_range_l); // 穿孔搜索范围 - 左 - ADD_SANE_CAP(is_erase_hole_r); // 穿孔移除 - 右 - ADD_SANE_CAP(search_hole_range_r); // 穿孔搜索范围 - 右 - ADD_SANE_CAP(is_erase_hole_t); // 穿孔移除 - 上 - ADD_SANE_CAP(search_hole_range_t); // 穿孔搜索范围 - 上 - ADD_SANE_CAP(is_erase_hole_b); // 穿孔移除 - 下 - ADD_SANE_CAP(search_hole_range_b); // 穿孔搜索范围 - 下 - ADD_SANE_CAP(fold_direction); // 对折方向 - //ADD_SANE_CAP(fold_type); - ADD_SANE_CAP(color_correction); + ADD_SANE_CAP(IS_MULTI_OUT); + ADD_SANE_CAP(MULTI_OUT_TYPE); + ADD_SANE_CAP(COLOR_MODE); + ADD_SANE_CAP(FILTER); + ADD_SANE_CAP(RID_MULTIOUT_RED); + ADD_SANE_CAP(RID_ANSWER_SHEET_RED); + ADD_SANE_CAP(ERASE_BACKGROUND); + ADD_SANE_CAP(BKG_COLOR_RANGE); + ADD_SANE_CAP(SHARPEN); + ADD_SANE_CAP(RID_MORR); + ADD_SANE_CAP(RID_GRID); + ADD_SANE_CAP(ERROR_EXTENSION); + ADD_SANE_CAP(NOISE_OPTIMIZE); + ADD_SANE_CAP(NOISE_SIZE); + ADD_SANE_CAP(PAPER); + ADD_SANE_CAP(CUSTOM_AREA); + ADD_SANE_CAP(CUSTOM_AREA_LEFT); + ADD_SANE_CAP(CUSTOM_AREA_RIGHT); + ADD_SANE_CAP(CUSTOM_AREA_TOP); + ADD_SANE_CAP(CUSTOM_AREA_BOTTOM); + ADD_SANE_CAP(SIZE_CHECK); + ADD_SANE_CAP(PAGE); + ADD_SANE_CAP(DISCARD_BLANK_SENS); + ADD_SANE_CAP(RESOLUTION); + ADD_SANE_CAP(IMAGE_QUALITY); + ADD_SANE_CAP(EXCHANGE); + ADD_SANE_CAP(SPLIT); + ADD_SANE_CAP(ANTI_SKEW); + ADD_SANE_CAP(IS_CUSTOM_GAMMA); + ADD_SANE_CAP(BRIGHTNESS); + ADD_SANE_CAP(CONTRAST); + ADD_SANE_CAP(GAMMA); + ADD_SANE_CAP(ERASE_BLACK_FRAME); + ADD_SANE_CAP(DARK_SAMPLE); + ADD_SANE_CAP(THRESHOLD); + ADD_SANE_CAP(ANTI_NOISE_LEVEL); + ADD_SANE_CAP(MARGIN); + ADD_SANE_CAP(FILL_BKG_MODE); + ADD_SANE_CAP(IS_ANTI_PERMEATE); + ADD_SANE_CAP(ANTI_PERMEATE_LEVEL); + ADD_SANE_CAP(RID_HOLE); + ADD_SANE_CAP(SEARCH_HOLE_RANGE); + ADD_SANE_CAP(IS_FILL_COLOR); + ADD_SANE_CAP(IS_ULTROSONIC_CHECK); + ADD_SANE_CAP(IS_CHECK_STAPLE); + ADD_SANE_CAP(SCAN_MODE); + ADD_SANE_CAP(SCAN_COUNT); + ADD_SANE_CAP(TEXT_DIRECTION); + ADD_SANE_CAP(IS_ROTATE_BKG_180); + ADD_SANE_CAP(IS_CHECK_DOG_EAR); + ADD_SANE_CAP(DOG_EAR_SIZE); + ADD_SANE_CAP(IS_CHECK_ASKEW); + ADD_SANE_CAP(ASKEW_RANGE); + ADD_SANE_CAP(BINARY_THRESHOLD); + ADD_SANE_CAP(IS_PHOTO_MODE); + ADD_SANE_CAP(DOUBLE_FEED_HANDLE); + ADD_SANE_CAP(WAIT_TO_SCAN); + ADD_SANE_CAP(FEED_STRENGTH); + ADD_SANE_CAP(TIME_TO_SLEEP); + ADD_SANE_CAP(IS_AUTO_FEED_STRENGTH); + ADD_SANE_CAP(FEED_STRENGTH_VALUE); + ADD_SANE_CAP(REVERSE_01); + ADD_SANE_CAP(RID_HOLE_L); + ADD_SANE_CAP(SEARCH_HOLE_RANGE_L); + ADD_SANE_CAP(RID_HOLE_R); + ADD_SANE_CAP(SEARCH_HOLE_RANGE_R); + ADD_SANE_CAP(RID_HOLE_T); + ADD_SANE_CAP(SEARCH_HOLE_RANGE_T); + ADD_SANE_CAP(RID_HOLE_B); + ADD_SANE_CAP(SEARCH_HOLE_RANGE_B); + ADD_SANE_CAP(FOLD_TYPE); + ADD_SANE_CAP(COLOR_CORRECTION); + +#define GET_ONLY_CAP(name, ctype, ttype) \ + m_query[(CapType)SANE_OPT_ID_##name] = MsgSupport::GetCurrent; \ + m_caps[(CapType)SANE_OPT_ID_##name] = [this](Msg msg, Capability& data) -> Result { \ + if(msg != Msg::GetCurrent && msg != Msg::Get) \ + return {ReturnCode::Failure, ConditionCode::CapUnsupported}; \ + std::vector all; \ + ttype str; \ + GET_SANE_OPT(ctype, scanner_, name, NULL, &all); \ + copy_type(str, all[sane_opts::RANGE_POS_CURRENT]); \ + data = Capability::createOneValue((CapType)SANE_OPT_ID_##name, str); \ + return { ReturnCode::Success, ConditionCode::Success }; \ + } + + GET_ONLY_CAP(HISTORY_COUNT, int, Int32); + GET_ONLY_CAP(DRIVER_VERSION, std::string, Str255); + GET_ONLY_CAP(MANUFACTURER, std::string, Str255); + GET_ONLY_CAP(COPYRIGHT, std::string, Str255); + GET_ONLY_CAP(CO_URL, std::string, Str255); + GET_ONLY_CAP(CO_TEL, std::string, Str255); + GET_ONLY_CAP(CO_ADDR, std::string, Str255); + GET_ONLY_CAP(CO_GPS, std::string, Str255); + GET_ONLY_CAP(DEV_NAME, std::string, Str255); + GET_ONLY_CAP(DEV_FAMILY, std::string, Str255); + GET_ONLY_CAP(VID, int, Int32); + GET_ONLY_CAP(PID, int, Int32); + + m_query[(CapType)SANE_OPT_ID_HELP] = MsgSupport::Set; + m_caps[(CapType)SANE_OPT_ID_HELP] = [this](Msg msg, Capability& data) -> Result { + if (msg != Msg::Set) + { + if (msg == Msg::Get) + { + Int32 v = 0; + data = Capability::createOneValue((CapType)SANE_OPT_ID_HELP, v); + return success(); + } + else + return { ReturnCode::Failure, ConditionCode::CapUnsupported }; + } + + int val = 0, ret = 0; + SET_SANE_OPT(ret, scanner_, HELP, &val); + + return success(); + }; + + m_query[(CapType)SANE_OPT_ID_LOGIN] = MsgSupport::Set; + m_caps[(CapType)SANE_OPT_ID_LOGIN] = [this](Msg msg, Capability& data) -> Result { + if (msg != Msg::Set) + { + if (msg == Msg::Get) + { + data = Capability::createArray((CapType)SANE_OPT_ID_LOGIN, 2); + return success(); + } + return { ReturnCode::Failure, ConditionCode::CapUnsupported }; + } + + Str32 n(data.array().at(0)), + p(data.array().at(1)); + char buf[64] = { 0 }; + int ret = 0; + + strcpy(buf, n.data()); + strcpy(buf + 32, p.data()); + SET_SANE_OPT(ret, scanner_, LOGIN, buf); + if (ret == SCANNER_ERR_OK) + return success(); + + return { RC::Failure, huagao_ds::condition_code_from_hg_error(ret) }; + }; + m_query[(CapType)SANE_OPT_ID_LOGOUT] = MsgSupport::Set; + m_caps[(CapType)SANE_OPT_ID_LOGOUT] = [this](Msg msg, Capability& data) -> Result { + if (msg != Msg::Set) + { + if (msg == Msg::Get) + { + data = Capability::createArray((CapType)SANE_OPT_ID_LOGIN, 2); + return success(); + } + return { ReturnCode::Failure, ConditionCode::CapUnsupported }; + } + + Str32 n(data.array().at(0)), + p(data.array().at(1)); + char buf[64] = { 0 }; + int ret = 0; + + strcpy(buf, n.data()); + strcpy(buf + 32, p.data()); + SET_SANE_OPT(ret, scanner_, LOGOUT, buf); + if (ret == SCANNER_ERR_OK) + return success(); + + return { RC::Failure, huagao_ds::condition_code_from_hg_error(ret) }; + }; + +#define GET_RESET_ONLY_CAP(name, ctype, ttype) \ + m_query[(CapType)SANE_OPT_ID_##name] = MsgSupport::GetCurrent | MsgSupport::Reset; \ + m_caps[(CapType)SANE_OPT_ID_##name] = [this](Msg msg, Capability& data) -> Result { \ + if(msg == Msg::GetCurrent || msg == Msg::Get) \ + { \ + std::vector all; \ + ttype str; \ + GET_SANE_OPT(ctype, scanner_, name, NULL, &all); \ + copy_type(str, all[sane_opts::RANGE_POS_CURRENT]); \ + return cap_get_one_value(msg, data, str, str, NULL, NULL, NULL); \ + } \ + else if(msg == Msg::Reset) \ + { \ + int tmp = 0, ret = 0; \ + SET_SANE_OPT(ret, scanner_, name, &tmp); \ + if(ret == SCANNER_ERR_OK) \ + return success(); \ + \ + return { RC::Failure, huagao_ds::condition_code_from_hg_error(ret) }; \ + } \ + return {ReturnCode::Failure, ConditionCode::CapUnsupported}; \ + } + GET_RESET_ONLY_CAP(ROLLER_COUNT, int, Int32); + +#define GET_RESET_ONLY_CAP_STR(name) \ + m_query[(CapType)SANE_OPT_ID_##name] = MsgSupport::GetCurrent | MsgSupport::Reset; \ + m_caps[(CapType)SANE_OPT_ID_##name] = [this](Msg msg, Capability& data) -> Result { \ + if(msg == Msg::GetCurrent || msg == Msg::Get) \ + { \ + Str255 str; \ + if(msg == Msg::Get) { data = Capability::createOneValue((CapType)SANE_OPT_ID_##name, str); return success(); } \ + std::string path(""); \ + int len = 0; \ + copy_type(path, data.currentItem()); \ + len = path.length(); \ + if(scanner_->get_value(SANE_OPT_ID_##name, &path[0], &len)) return success(); else return { RC::Failure, CC::OperationError }; \ + } \ + else if(msg == Msg::Reset) \ + { \ + int tmp = 0, ret = 0; \ + SET_SANE_OPT(ret, scanner_, name, &tmp); \ + if(ret == SCANNER_ERR_OK) \ + return success(); \ + \ + return { RC::Failure, huagao_ds::condition_code_from_hg_error(ret) }; \ + } \ + return {ReturnCode::Failure, ConditionCode::CapUnsupported}; \ + } + GET_RESET_ONLY_CAP_STR(DRIVER_LOG); + GET_RESET_ONLY_CAP_STR(DEVICE_LOG); } std::wstring huagao_ds::get_config_file(void) { @@ -3491,7 +3562,7 @@ int huagao_ds::handle_scanner_event(int ev, bool from_event_proc) } else { - swprintf_s(msg, _countof(msg) - 1, L"[%x]Warning: notifyCloseCancel failed with error %d after start scanning failed\r\n", GetCurrentThreadId(), rc, state()); + swprintf_s(msg, _countof(msg) - 1, L"[%x - %s]Warning: notifyCloseCancel failed with error %d after start scanning failed\r\n", GetCurrentThreadId(), desc_state(state(), unk), rc); load_sane_util::log_info(msg, 0); } }