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

调整JSON，为统一APP配置做准备

This commit is contained in:
gb 2022-10-25 16:41:09 +08:00
parent 942c8f8748
commit 93ad04eb6a
8 changed files with 149 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
sane/DlgPage.cpp
View File

@ -158,9 +158,9 @@ void dlg_base::notify_ui_event(int ev)
if (ui_event_notify_) if (ui_event_notify_)
ui_event_notify_(ev, this, ui_notify_param_); ui_event_notify_(ev, this, ui_notify_param_);
} }
gb::sane_config* dlg_base::get_config(void) gb::sane_config_schm* dlg_base::get_config(void)
{ {
gb::sane_config* cfg = NULL; gb::sane_config_schm* cfg = NULL;
SendMessage(parent_, WM_GET_CONFIG_OBJ, 0, (LPARAM)&cfg); SendMessage(parent_, WM_GET_CONFIG_OBJ, 0, (LPARAM)&cfg);
@ -796,7 +796,7 @@ void dlg_page::handle_command(WORD code, WORD id, HANDLE ctrl)
{ {
SANE_Fixed val = SANE_FIX(dlg.x_in_mm()); SANE_Fixed val = SANE_FIX(dlg.x_in_mm());
SANE_Int after = 0; SANE_Int after = 0;
gb::sane_config* cfg = get_config(); gb::sane_config_schm* cfg = get_config();
sane_.sane_control_option_api(dev_, id_custom_left_, SANE_ACTION_SET_VALUE, &val, &after); sane_.sane_control_option_api(dev_, id_custom_left_, SANE_ACTION_SET_VALUE, &val, &after);
if (cfg) if (cfg)
@ -833,7 +833,7 @@ void dlg_page::handle_command(WORD code, WORD id, HANDLE ctrl)
dlg.get_gamma(&gamma); dlg.get_gamma(&gamma);
sane_.sane_io_control_api(dev_, IO_CTRL_CODE_SET_CUSTOM_GAMMA, &gamma, &len); sane_.sane_io_control_api(dev_, IO_CTRL_CODE_SET_CUSTOM_GAMMA, &gamma, &len);
gb::sane_config* cfg = get_config(); gb::sane_config_schm* cfg = get_config();
if (cfg) if (cfg)
cfg->config_changed(id_custom_gamma_, (char*)&gamma, sizeof(gamma), true); cfg->config_changed(id_custom_gamma_, (char*)&gamma, sizeof(gamma), true);
} }
@ -1077,7 +1077,7 @@ void dlg_page::control_action(HWND wnd)
{ {
SANE_Int after = 0; SANE_Int after = 0;
SANE_Status statu = sane_.sane_control_option_api(dev_, id - dlg_page::dyn_id_base, SANE_ACTION_SET_VALUE, val, &after); SANE_Status statu = sane_.sane_control_option_api(dev_, id - dlg_page::dyn_id_base, SANE_ACTION_SET_VALUE, val, &after);
gb::sane_config* cfg = get_config(); gb::sane_config_schm* cfg = get_config();
done_ = false; done_ = false;
if (cfg) if (cfg)
{ {

4
sane/DlgPage.h
View File

@ -22,7 +22,7 @@
extern HMODULE g_my_inst; extern HMODULE g_my_inst;
namespace gb namespace gb
{ {
class sane_config; class sane_config_schm;
} }
class dlg_base class dlg_base
@ -41,7 +41,7 @@ protected:
virtual void on_font_changed(void); virtual void on_font_changed(void);
void create(void); void create(void);
void notify_ui_event(int ev); void notify_ui_event(int ev);
gb::sane_config* get_config(void); gb::sane_config_schm* get_config(void);
public: public:
dlg_base(HWND parent, UINT idd); dlg_base(HWND parent, UINT idd);

4
sane/DlgSetting.cpp
View File

@ -58,7 +58,7 @@ BOOL dlg_setting::handle_message(UINT msg, WPARAM wp, LPARAM lp)
refresh_controls((int)wp); refresh_controls((int)wp);
break; break;
case WM_GET_CONFIG_OBJ: case WM_GET_CONFIG_OBJ:
*((gb::sane_config**)lp) = cfg_; *((gb::sane_config_schm**)lp) = cfg_;
break; break;
default: default:
ret = FALSE; ret = FALSE;
@ -351,7 +351,7 @@ void dlg_setting::refresh_controls(int src_sn)
} }
} }
void dlg_setting::set_config(gb::sane_config* cfg, const wchar_t* file) void dlg_setting::set_config(gb::sane_config_schm* cfg, const wchar_t* file)
{ {
cfg_ = cfg; cfg_ = cfg;
cfg_file_ = file; cfg_file_ = file;

6
sane/DlgSetting.h
View File

@ -17,7 +17,7 @@
namespace gb namespace gb
{ {
class sane_config; class sane_config_schm;
} }
class dlg_setting : public dlg_base class dlg_setting : public dlg_base
{ {
@ -29,7 +29,7 @@ class dlg_setting : public dlg_base
bool err_; bool err_;
int id_help_; int id_help_;
int id_restore_; int id_restore_;
gb::sane_config* cfg_; gb::sane_config_schm* cfg_;
std::wstring cfg_file_; std::wstring cfg_file_;
HWND tab_; HWND tab_;
@ -55,7 +55,7 @@ public:
~dlg_setting(); ~dlg_setting();
public: public:
void set_config(gb::sane_config* cfg, const wchar_t* file); void set_config(gb::sane_config_schm* cfg, const wchar_t* file);
HWND window(void); HWND window(void);
HWND parent(void); HWND parent(void);
//void show(void); //void show(void);

163
sane/gb_json.cpp
View File

@ -31,6 +31,34 @@ namespace gb
return ret; return ret;
} }
refer::refer() : ref_(1)
{}
refer::~refer()
{}
long refer::add_ref(void)
{
#if defined(WIN32) || defined(_WIN64)
return InterlockedIncrement(&ref_);
#else
return ++ref_;
#endif
}
long refer::release(void)
{
#if defined(WIN32) || defined(_WIN64)
long ref = InterlockedDecrement(&ref_);
#else
long ref = --ref_;
#endif
if (ref == 0)
delete this;
return ref;
}
json::json(char* json_txt) : obj_(0), cur_child_(0), is_array_(false) json::json(char* json_txt) : obj_(0), cur_child_(0), is_array_(false)
{ {
memset(&walk_head_, 0, sizeof(walk_head_)); memset(&walk_head_, 0, sizeof(walk_head_));
@ -325,7 +353,7 @@ namespace gb
val = new json(); val = new json();
if (!val->attach_cjson(obj)) if (!val->attach_cjson(obj))
{ {
delete val; val->release();
return false; return false;
} }
@ -831,19 +859,19 @@ namespace gb
namespace gb namespace gb
{ {
std::string sane_config::opt_data_appendix_("_data"); std::string sane_config_schm::opt_data_appendix_("_data");
sane_config::sane_config() : jsn_(NULL), bkp_(NULL), in_setting_(false) sane_config_schm::sane_config_schm() : jsn_(NULL), bkp_(NULL), in_setting_(false), scheme_name_("")
{ {
def_val_ = new gb::json(); def_val_ = new gb::json();
} }
sane_config::~sane_config() sane_config_schm::~sane_config_schm()
{ {
clear(); clear();
delete def_val_; def_val_->release();
} }
bool sane_config::hex(unsigned char ch, unsigned char* val) bool sane_config_schm::hex(unsigned char ch, unsigned char* val)
{ {
bool ret = true; bool ret = true;
@ -864,15 +892,15 @@ namespace gb
return ret; return ret;
} }
bool sane_config::hex_char(const char* data, unsigned char* val) bool sane_config_schm::hex_char(const char* data, unsigned char* val)
{ {
unsigned char v = 0; unsigned char v = 0;
bool ret = false; bool ret = false;
if (sane_config::hex(*data++, &v)) if (sane_config_schm::hex(*data++, &v))
{ {
v <<= 4; v <<= 4;
if (sane_config::hex(*data++, &v)) if (sane_config_schm::hex(*data++, &v))
{ {
if (val) if (val)
*val = v; *val = v;
@ -883,13 +911,13 @@ namespace gb
return ret; return ret;
} }
bool sane_config::is_option_data(std::string& name) bool sane_config_schm::is_option_data(std::string& name)
{ {
size_t pos = name.find(sane_config::opt_data_appendix_); size_t pos = name.find(sane_config_schm::opt_data_appendix_);
if (pos != std::string::npos) if (pos != std::string::npos)
{ {
if (pos + sane_config::opt_data_appendix_.length() == name.length()) if (pos + sane_config_schm::opt_data_appendix_.length() == name.length())
{ {
name.erase(pos); name.erase(pos);
@ -900,17 +928,17 @@ namespace gb
return false; return false;
} }
void sane_config::clear() void sane_config_schm::clear()
{ {
if (jsn_) if (jsn_)
delete jsn_; jsn_->release();
jsn_ = NULL; jsn_ = NULL;
if (bkp_) if (bkp_)
delete bkp_; bkp_->release();
bkp_ = NULL; bkp_ = NULL;
file_ = L""; file_ = L"";
} }
std::string sane_config::to_hex_letter(const char* data, size_t bytes) std::string sane_config_schm::to_hex_letter(const char* data, size_t bytes)
{ {
std::string hex(""); std::string hex("");
const unsigned char* ptr = (const unsigned char*)data; const unsigned char* ptr = (const unsigned char*)data;
@ -924,7 +952,7 @@ namespace gb
return hex; return hex;
} }
std::string sane_config::from_hex_letter(const char* data, size_t bytes) std::string sane_config_schm::from_hex_letter(const char* data, size_t bytes)
{ {
std::string stream(""); std::string stream("");
@ -932,7 +960,7 @@ namespace gb
for (size_t i = 0; i < bytes; ++i) for (size_t i = 0; i < bytes; ++i)
{ {
unsigned char ch = 0; unsigned char ch = 0;
if (!sane_config::hex_char(data, &ch)) if (!sane_config_schm::hex_char(data, &ch))
break; break;
stream.append(1, ch); stream.append(1, ch);
data += 2; data += 2;
@ -940,7 +968,7 @@ namespace gb
return stream; return stream;
} }
std::string sane_config::default_value(const char* hex_title) std::string sane_config_schm::default_value(const char* hex_title)
{ {
std::string val(""); std::string val("");
@ -949,7 +977,7 @@ namespace gb
return val; return val;
} }
bool sane_config::load_from_file(const wchar_t* file) bool sane_config_schm::load_from_file(const wchar_t* file)
{ {
clear(); clear();
@ -975,7 +1003,7 @@ namespace gb
return ret; return ret;
} }
bool sane_config::load_from_mem(const char* mem) bool sane_config_schm::load_from_mem(const char* mem)
{ {
gb::base64 b64; gb::base64 b64;
std::string stream(b64.decode(mem, lstrlenA(mem))); std::string stream(b64.decode(mem, lstrlenA(mem)));
@ -984,7 +1012,7 @@ namespace gb
jsn_ = new gb::json(); jsn_ = new gb::json();
if (!jsn_->attach_text(&stream[0])) if (!jsn_->attach_text(&stream[0]))
{ {
delete jsn_; jsn_->release();
jsn_ = NULL; jsn_ = NULL;
return false; return false;
@ -992,7 +1020,7 @@ namespace gb
return true; return true;
} }
bool sane_config::save_to(const wchar_t* file) bool sane_config_schm::save_to(const wchar_t* file)
{ {
bool ret = false; bool ret = false;
std::string encode(to_text_stream()); std::string encode(to_text_stream());
@ -1014,43 +1042,43 @@ namespace gb
return ret; return ret;
} }
void sane_config::set_default_value(int sn, const char* name, const char* val, size_t bytes) void sane_config_schm::set_default_value(int sn, const char* name, const char* val, size_t bytes)
{ {
id_name_[sn] = name; id_name_[sn] = name;
def_val_->set_value(name, to_hex_letter(val, bytes).c_str()); def_val_->set_value(name, to_hex_letter(val, bytes).c_str());
} }
bool sane_config::first_config(std::string& name, std::string& val) bool sane_config_schm::first_config(std::string& name, std::string& val)
{ {
bool ret = false; bool ret = false;
std::string raw_v(""); std::string raw_v("");
if (jsn_ && jsn_->first_child(raw_v, &name)) if (jsn_ && jsn_->first_child(raw_v, &name))
{ {
val = sane_config::from_hex_letter(raw_v.c_str(), raw_v.length()); val = sane_config_schm::from_hex_letter(raw_v.c_str(), raw_v.length());
ret = true; ret = true;
} }
return ret; return ret;
} }
bool sane_config::next_config(std::string& name, std::string& val) bool sane_config_schm::next_config(std::string& name, std::string& val)
{ {
bool ret = false; bool ret = false;
std::string raw_v(""); std::string raw_v("");
if (jsn_ && jsn_->next_child(raw_v, &name)) if (jsn_ && jsn_->next_child(raw_v, &name))
{ {
val = sane_config::from_hex_letter(raw_v.c_str(), raw_v.length()); val = sane_config_schm::from_hex_letter(raw_v.c_str(), raw_v.length());
ret = true; ret = true;
} }
return ret; return ret;
} }
void sane_config::begin_setting(bool restore) void sane_config_schm::begin_setting(bool restore)
{ {
if (bkp_) if (bkp_)
delete bkp_; bkp_->release();
bkp_ = jsn_; bkp_ = jsn_;
in_setting_ = true; in_setting_ = true;
jsn_ = new gb::json(); jsn_ = new gb::json();
@ -1061,7 +1089,7 @@ namespace gb
jsn_->attach_text(&stream[0]); jsn_->attach_text(&stream[0]);
} }
} }
void sane_config::config_changed(const char* name, const char* val, size_t bytes) void sane_config_schm::config_changed(const char* name, const char* val, size_t bytes, bool extra)
{ {
std::string hex_v(to_hex_letter(val, bytes)), std::string hex_v(to_hex_letter(val, bytes)),
def(default_value(name)); def(default_value(name));
@ -1070,58 +1098,57 @@ namespace gb
jsn_->remove(name); jsn_->remove(name);
else else
jsn_->set_value(name, hex_v.c_str()); jsn_->set_value(name, hex_v.c_str());
}
void sane_config::config_changed(int sn, const char* val, size_t bytes, bool extra) if (extra)
{ {
std::string name(""), jsn_->set_value((name + sane_config_schm::opt_data_appendix_).c_str(), hex_v.c_str());
hex_v(to_hex_letter(val, bytes)), }
def(""); else
{
def = default_value(name);
if (hex_v == def)
{
jsn_->remove(name);
jsn_->remove((name + sane_config_schm::opt_data_appendix_).c_str());
}
else
jsn_->set_value(name, hex_v.c_str());
}
}
void sane_config_schm::config_changed(int sn, const char* val, size_t bytes, bool extra)
{
std::string name("");
if (id_name_.count(sn)) if (id_name_.count(sn))
{ {
name = id_name_[sn]; name = id_name_[sn];
if (extra) config_changed(name.c_str(), val, bytes, extra);
{
name += sane_config::opt_data_appendix_;
jsn_->set_value(name.c_str(), hex_v.c_str());
}
else
{
def = default_value(name.c_str());
if (hex_v == def)
{
jsn_->remove(name.c_str());
jsn_->remove((name + sane_config::opt_data_appendix_).c_str());
}
else
jsn_->set_value(name.c_str(), hex_v.c_str());
} }
} }
} void sane_config_schm::remove_config(const char* name)
void sane_config::remove_config(const char* name)
{ {
if (jsn_) if (jsn_)
jsn_->remove(name); jsn_->remove(name);
} }
void sane_config::end_setting(bool cancel) void sane_config_schm::end_setting(bool cancel)
{ {
if (in_setting_) if (in_setting_)
{ {
if (cancel) if (cancel)
{ {
delete jsn_; jsn_->release();
jsn_ = bkp_; jsn_ = bkp_;
bkp_ = NULL; bkp_ = NULL;
} }
else if (bkp_) else if (bkp_)
{ {
delete bkp_; bkp_->release();
bkp_ = NULL; bkp_ = NULL;
} }
} }
in_setting_ = false; in_setting_ = false;
} }
int sane_config::id_from_name(const char* name) int sane_config_schm::id_from_name(const char* name)
{ {
for (const auto& v : id_name_) for (const auto& v : id_name_)
{ {
@ -1131,7 +1158,7 @@ namespace gb
return -1; return -1;
} }
std::string sane_config::to_text_stream(void) std::string sane_config_schm::to_text_stream(void)
{ {
if (jsn_) if (jsn_)
{ {
@ -1151,7 +1178,7 @@ namespace gb
else else
return ""; return "";
} }
std::string sane_config::get_version(void) std::string sane_config_schm::get_version(void)
{ {
std::string ver(""); std::string ver("");
@ -1160,7 +1187,15 @@ namespace gb
return ver; return ver;
} }
void sane_config::update(bool(__stdcall* is_float)(int, void*), void* param, const char* (__stdcall* t2n)(const char*), std::string* discard) std::string sane_config_schm::get_scheme_name(void)
{
return scheme_name_;
}
void sane_config_schm::set_scheme_name(const char* name)
{
scheme_name_ = name ? name : "";
}
void sane_config_schm::update(bool(__stdcall* is_float)(int, void*), void* param, const char* (__stdcall* t2n)(const char*), std::string* discard)
{ {
if (!jsn_) if (!jsn_)
return; return;
@ -1184,7 +1219,7 @@ namespace gb
changed = true; changed = true;
do do
{ {
jsn_->change_key(name.c_str(), t2n(sane_config::from_hex_letter(name.c_str(), name.length()).c_str())); jsn_->change_key(name.c_str(), t2n(sane_config_schm::from_hex_letter(name.c_str(), name.length()).c_str()));
} while (jsn_->next_child(val, &name)); } while (jsn_->next_child(val, &name));
} }
} }
@ -1213,4 +1248,10 @@ namespace gb
if (changed) if (changed)
save_to(NULL); save_to(NULL);
} }
///////////////////////////////////////////////////////////////////////////////////
// scanner_cfg
} }

35
sane/gb_json.h
View File

@ -12,7 +12,21 @@
namespace gb namespace gb
{ {
class json class refer
{
volatile long ref_;
protected:
refer();
virtual ~refer();
public:
long add_ref(void);
long release(void);
};
class json : public refer
{ {
cJSON *obj_; cJSON *obj_;
cJSON *cur_child_; cJSON *cur_child_;
@ -23,9 +37,11 @@ namespace gb
cJSON* find_child(cJSON *parent, std::vector<std::string>& path, bool create, cJSON*** addr = NULL); cJSON* find_child(cJSON *parent, std::vector<std::string>& path, bool create, cJSON*** addr = NULL);
cJSON* find(const char* path, bool create = false, cJSON*** addr = NULL); cJSON* find(const char* path, bool create = false, cJSON*** addr = NULL);
protected:
~json();
public: public:
json(char* json_txt = 0); json(char* json_txt = 0);
~json();
static std::string to_string(cJSON* root, bool formatted); static std::string to_string(cJSON* root, bool formatted);
static std::string get_value_as_string(cJSON* root, bool integer = false); static std::string get_value_as_string(cJSON* root, bool integer = false);
@ -82,23 +98,26 @@ namespace gb
std::string decode(const char* data, size_t bytes); std::string decode(const char* data, size_t bytes);
}; };
class sane_config class sane_config_schm : public refer
{ {
std::string scheme_name_;
std::wstring file_; std::wstring file_;
json* jsn_; json* jsn_;
json* bkp_; json* bkp_;
json* def_val_; json* def_val_;
bool in_setting_; bool in_setting_;
std::map<int, std::string> id_name_; std::map<int, std::string> id_name_; // (id, default-val)
void clear(); void clear();
std::string to_hex_letter(const char* data, size_t bytes); std::string to_hex_letter(const char* data, size_t bytes);
std::string from_hex_letter(const char* data, size_t bytes); std::string from_hex_letter(const char* data, size_t bytes);
std::string default_value(const char* name); std::string default_value(const char* name);
protected:
~sane_config_schm();
public: public:
sane_config(); sane_config_schm();
~sane_config();
static std::string opt_data_appendix_; static std::string opt_data_appendix_;
static bool hex(unsigned char ch, unsigned char* val); static bool hex(unsigned char ch, unsigned char* val);
@ -113,13 +132,15 @@ namespace gb
bool first_config(std::string& name, std::string& val); bool first_config(std::string& name, std::string& val);
bool next_config(std::string& name, std::string& val); bool next_config(std::string& name, std::string& val);
void begin_setting(bool restore = false); void begin_setting(bool restore = false);
void config_changed(const char* name, const char* val, size_t bytes); void config_changed(const char* name, const char* val, size_t bytes, bool extra = false);
void config_changed(int sn, const char* val, size_t bytes, bool extra = false); void config_changed(int sn, const char* val, size_t bytes, bool extra = false);
void remove_config(const char* name); void remove_config(const char* name);
void end_setting(bool cancel); void end_setting(bool cancel);
int id_from_name(const char* name); int id_from_name(const char* name);
std::string to_text_stream(void); std::string to_text_stream(void);
std::string get_version(void); std::string get_version(void);
std::string get_scheme_name(void);
void set_scheme_name(const char* name);
void update(bool(__stdcall* is_float)(int, void*), void* param, const char*(__stdcall* t2n)(const char*), std::string* discard = NULL); void update(bool(__stdcall* is_float)(int, void*), void* param, const char*(__stdcall* t2n)(const char*), std::string* discard = NULL);
}; };
} }

9
sane/scanner.cpp
View File

@ -323,7 +323,7 @@ scanner::scanner(SCANNERID id) : handle_(NULL), id_(id), ex_id_(EXTENSION_ID_BAS
, scanner_name_(L""), cfg_(NULL), is_ui_wait_img_(false), is_scanning_(false) , scanner_name_(L""), cfg_(NULL), is_ui_wait_img_(false), is_scanning_(false)
, scanner_ev_handler_(NULL), evh_param_(NULL), app_wnd_(NULL) , scanner_ev_handler_(NULL), evh_param_(NULL), app_wnd_(NULL)
{ {
cfg_ = new gb::sane_config(); cfg_ = new gb::sane_config_schm();
tmp_path_ = local_trans::a2u(hg_sane_middleware::sane_path().c_str()); tmp_path_ = local_trans::a2u(hg_sane_middleware::sane_path().c_str());
{ {
char* tmp = getenv("LOCALAPPDATA"); char* tmp = getenv("LOCALAPPDATA");
@ -350,7 +350,10 @@ scanner::~scanner()
{ {
close(); close();
if (cfg_) if (cfg_)
delete cfg_; {
cfg_->release();
cfg_ = NULL;
}
} }
bool scanner::is_belong_serial(int vid, int pid, SCANNERID serial) bool scanner::is_belong_serial(int vid, int pid, SCANNERID serial)
@ -574,7 +577,7 @@ void scanner::apply_config(void)
int id = cfg_->id_from_name(n.c_str()); int id = cfg_->id_from_name(n.c_str());
if (id == -1) if (id == -1)
{ {
if (gb::sane_config::is_option_data(n)) if (gb::sane_config_schm::is_option_data(n))
{ {
id = cfg_->id_from_name(n.c_str()); id = cfg_->id_from_name(n.c_str());
if (id == is_custom_gamma_id_) if (id == is_custom_gamma_id_)

4
sane/scanner.h
View File

@ -26,7 +26,7 @@ class dlg_indicator;
class dlg_setting; class dlg_setting;
namespace gb namespace gb
{ {
class sane_config; class sane_config_schm;
} }
class scanner : public ISaneInvoker, virtual public refer class scanner : public ISaneInvoker, virtual public refer
@ -51,7 +51,7 @@ class scanner : public ISaneInvoker, virtual public refer
SANE_FinalImgFormat img_fmt_; SANE_FinalImgFormat img_fmt_;
std::unique_ptr<dlg_indicator> indicator_; std::unique_ptr<dlg_indicator> indicator_;
std::unique_ptr<dlg_setting> setting_; std::unique_ptr<dlg_setting> setting_;
gb::sane_config* cfg_; gb::sane_config_schm* cfg_;
int(__stdcall* scanner_ev_handler_)(int, void*); int(__stdcall* scanner_ev_handler_)(int, void*);
void* evh_param_; void* evh_param_;