lmh188
/
code_app
mirror of http://192.168.10.5:8099/sane/code_app.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
code_app/modules/twainui/hg_settingdialog.cpp

2564 lines
89 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#include "Manager.h"
#include "hg_settingdialog.h"
#include <QDebug>
#include <QLatin1String>
#ifdef HG_CMP_MSC
#include <shlobj.h>
#endif
#include "cutpapertool.h"
#include "setpicclrtool.h"
#include "base/HGDef.h"
#include "base/HGUtility.h"
#include "HGString.h"
#include "sane/sane_option_definitions.h"
#include "lang/app_language.h"
#include "dialog_input.h"
#include <typeinfo>
#include "device_menu.h"
#include "app_cfg.h"
#include "base/HGBase64.h"
std::string hg_settingdialog::property_combox_data_type_ = "combox_value_type";
static int m_customCutAreaUnit = 0;
extern Manager* g_manager;
hg_settingdialog::hg_settingdialog(class Manager *mgr, SANE_Handle handle, const SANEAPI* saneApi, bool showScan, const char* devName, gb::scanner_cfg* cfg,
std::function<void(ui_result)> callback, std::function<void(int, void*, int)>* notify, QWidget *parent)
: QDialog(parent)
, save_(false)
, btn_cut_area_(nullptr), btn_gamma_(nullptr), clicked_gamma_(false)
, custom_area_lable_(nullptr), comb_(nullptr)
, m_devHandle(handle)
, m_showScan(showScan)
, m_devName(devName)
, m_callback(callback)
, m_isRefreshUi(false)
, changed_count_(0)
, cur_cfg_(cfg)
, m_isMultiOutMode(false)
, m_isScanning(false)
, m_isAutoFinish(false)
{
m_mgr = mgr;
setAttribute(Qt::WA_DeleteOnClose, true);
setIcon();
cur_scheme_ = cur_cfg_->get_scheme();
if (!cur_scheme_)
cur_scheme_ = cur_cfg_->get_scheme(gb::scanner_cfg::user_default_scheme_name().c_str());
cur_scheme_->begin_setting();
m_dpiId = -1;
m_dpiValue = 200;
m_paperSizeId = -1;
m_paperSizeValue.clear();
m_cutLeftId = -1;
m_cutTopId = -1;
m_cutRightId = -1;
m_cutBottomId = -1;
m_cutWidth = 210;
m_cutHeight = 297;
m_cutLeftValue = 0;
m_cutTopValue = 0;
m_cutRightValue = 210;
m_cutBottomValue = 297;
m_colorModeId = -1;
m_colorModeValue.clear();
m_multiColorValue.clear();
memset(&m_gammaData, 0, sizeof(m_gammaData));
for(int i = 0; i < sizeof(m_gammaData.table) / sizeof(m_gammaData.table[0]); ++i)
m_gammaData.table[i] = i & 0x0ff;
memset(&m_originGammaData, 0, sizeof(m_originGammaData));
memcpy(&m_saneAPI, saneApi, sizeof(SANEAPI));
m_closeButton = closeButtonNormal;
def_value_ = new gb::sane_config_schm();
initUi();
m_list_originDeviceScheme.clear();
m_list_originDeviceScheme = m_list_defaultOptions;
m_originGammaData = m_gammaData;
connect(comb_, SIGNAL(currentTextChanged(const QString)), this, SLOT(on_current_scheme_changed()));
connect(this, SIGNAL(scan_status(QString,bool)),this, SLOT(on_scan_status(QString, bool)), Qt::QueuedConnection);
if (notify != nullptr)
{
*notify = FuncNotify;
}
}
hg_settingdialog::~hg_settingdialog()
{
if (cur_scheme_ != nullptr)
cur_scheme_->release();
//cur_cfg_->release();
m_mgr->m_settingUi = NULL;
if (m_isAutoFinish)
{
m_callback(UI_RESULT_CLOSE_NORMAL);
}
else if (!quit_)
{
m_callback(UI_RESULT_CLOSE_SETTING);
}
}
void hg_settingdialog::apply_scheme(SANE_Handle dev, LPSANEAPI api, gb::sane_config_schm* schm)
{
const SANE_Option_Descriptor* desc = nullptr;
SANE_Int count = 0;
typedef struct _sod
{
int id;
const SANE_Option_Descriptor* desc;
}SOD;
std::vector<SOD> sods;
api->sane_control_option_api(dev, 0, SANE_ACTION_GET_VALUE, &count, nullptr);
for (int i = 1; i < count; ++i)
{
desc = api->sane_get_option_descriptor_api(dev, i);
if (!desc)
continue;
if (0 == strcmp(SANE_STD_OPT_NAME_RESTORE, desc->name))
api->sane_control_option_api(dev, i, SANE_ACTION_SET_VALUE, NULL, NULL);
if (desc->type == SANE_TYPE_BUTTON || desc->type == SANE_TYPE_GROUP)
continue;
SOD sod;
sod.id = i;
sod.desc = desc;
sods.push_back(sod);
}
SANE_Int info = 0;
std::string val("");
//api->sane_control_option_api(dev, SANE_OPT_ID_CUSTOM_GAMMA, SANE_ACTION_SET_VALUE, &val[0], &info);
if (schm)
{
std::string n("");
char* buf = nullptr;
if (schm->first_config(n, val))
{
do
{
if (gb::sane_config_schm::is_option_data(n))
{
if (n == SANE_STD_OPT_NAME_IS_CUSTOM_GAMMA)
{
api->sane_control_option_api(dev, SANE_OPT_ID_CUSTOM_GAMMA, SANE_ACTION_SET_VALUE, &val[0], &info);
}
else if (n == SANE_STD_OPT_NAME_CUSTOM_AREA)
{
m_customCutAreaUnit = *(int*)&val[0];
}
}
else
{
for (auto& v : sods)
{
if (n == v.desc->name)
{
if (v.desc->type == SANE_TYPE_STRING)
{
buf = new char[v.desc->size + 4];
strcpy(buf, val.c_str());
const char* value2 = from_default_language(buf, nullptr);
api->sane_control_option_api(dev, v.id, SANE_ACTION_SET_VALUE, (void*)value2, &info);
delete[] buf;
}
else
api->sane_control_option_api(dev, v.id, SANE_ACTION_SET_VALUE, &val[0], &info);
break;
}
}
}
} while (schm->next_config(n, val));
}
}
}
void hg_settingdialog::FuncNotify(int event, void* msg, int flag)
{
hg_settingdialog* p = (hg_settingdialog*)g_manager->m_settingUi;
if (nullptr == p)
{
return;
}
switch (event)
{
case SANE_EVENT_WORKING:
{
QString finishInfo;
if (0 != flag)
{
finishInfo = (char*)msg;
}
emit p->scan_status(finishInfo, true);
}
break;
case SANE_EVENT_SCAN_FINISHED:
{
QString finishInfo;
if (0 != flag)
{
finishInfo = (char*)msg;
}
emit p->scan_status(finishInfo, false);
}
break;
}
}
void hg_settingdialog::initUi()
{
update_opt_value_from_driver();
createUI();
#if defined(OEM_ZHONGJING)
setWindowTitle("Microtek DocWizard EX TWAIN");
#elif defined(OEM_NEUTRAL)
QString title = QString::fromStdString(m_devName);
title.remove(0, title.indexOf(" "));
title = QString("NeuScan ") + title;
setWindowTitle(title);
#else
setWindowTitle(QString::fromStdString(m_devName));
#endif
Qt::WindowFlags type = Qt::Dialog | Qt::WindowCloseButtonHint;
#ifdef HG_CMP_MSC
OSVERSIONINFOW info;
info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
if (GetVersionExW(&info))
{
if (info.dwMajorVersion == 6 && info.dwMinorVersion == 1)
{
type = Qt::SubWindow | Qt::Popup | Qt::WindowStaysOnTopHint;
}
}
#endif
setWindowFlags(type);
resize(740, height());
}
void hg_settingdialog::update_opt_value_from_driver()
{
bool first = true;
m_list_defaultOptions.clear();
m_list_getOpt.clear();
// custom gamma ...
m_saneAPI.sane_control_option_api(m_devHandle, SANE_OPT_ID_CUSTOM_GAMMA, SANE_ACTION_GET_VALUE, &m_gammaData, nullptr);
SANE_Int dev_options = 0;
m_saneAPI.sane_control_option_api(m_devHandle, 0, SANE_ACTION_GET_VALUE, &dev_options, nullptr);
for (int i = 1, j= dev_options; i < j; i++)
{
const SANE_Option_Descriptor* opt = m_saneAPI.sane_get_option_descriptor_api(m_devHandle, i);
SANE_Int method = 0;
if (opt == nullptr)
{
m_list_defaultOptions.append(QPair<const void*, QVariant>(opt, QVariant(0)));
}
else
{
if(opt->type == SANE_TYPE_INT)
{
SANE_Int init = 0;
m_saneAPI.sane_control_option_api(m_devHandle, i, SANE_ACTION_GET_VALUE, &init, &method);
m_list_defaultOptions.append(QPair<const void*, QVariant>(opt, QVariant(init)));
m_list_getOpt.append(QPair<int, const void*>(i, opt));
if(first)
{
unsigned int n = i;
dev_que::get_default_value(&m_saneAPI, m_devHandle, n, &init);
def_value_->set_default_value(i, opt->name, (char*)&init, sizeof(init));
}
}
else if(opt->type == SANE_TYPE_FIXED)
{
SANE_Fixed init = 0;
m_saneAPI.sane_control_option_api(m_devHandle, i, SANE_ACTION_GET_VALUE, &init, &method);
m_list_defaultOptions.append(QPair<const void*, QVariant>(opt, QVariant(init)));
m_list_getOpt.append(QPair<int, const void*>(i, opt));
if(first)
{
unsigned int n = i;
dev_que::get_default_value(&m_saneAPI, m_devHandle, n, &init);
def_value_->set_default_value(i, opt->name, (char*)&init, sizeof(init));
}
}
else if(opt->type == SANE_TYPE_BOOL)
{
SANE_Bool init = 0;
m_saneAPI.sane_control_option_api(m_devHandle, i, SANE_ACTION_GET_VALUE, &init, &method);
m_list_defaultOptions.append(QPair<const void*, QVariant>(opt, QVariant(init)));
m_list_getOpt.append(QPair<int, const void*>(i, opt));
if(first)
{
unsigned int n = i;
dev_que::get_default_value(&m_saneAPI, m_devHandle, n, &init);
def_value_->set_default_value(i, opt->name, (char*)&init, sizeof(init));
}
}
else if(opt->type == SANE_TYPE_STRING)
{
char *init = (char*)malloc(opt->size * 2 + 4);
m_saneAPI.sane_control_option_api(m_devHandle, i, SANE_ACTION_GET_VALUE, init, &method);
const char* value2 = from_default_language(init, nullptr);
m_list_defaultOptions.append(QPair<const void*, QVariant>(opt, QVariant(QString::fromStdString(value2))));
m_list_getOpt.append(QPair<int, const void*>(i, opt));
if(first)
{
unsigned int n = i;
int err = dev_que::get_default_value(&m_saneAPI, m_devHandle, n, init);
(void)err;
std::string langCN(to_default_language(init, nullptr));
def_value_->set_default_value(i, opt->name, &langCN[0], langCN.length());
}
free(init);
}
else
{
m_list_defaultOptions.append(QPair<const void*, QVariant>(opt, QVariant(0)));
m_list_getOpt.append(QPair<int, const void*>(i, opt));
}
}
}
}
QString hg_settingdialog::find_current_scheme_menu(int *scheme_id)
{
QString text(comb_->currentText());
if(scheme_id)
{
if(comb_->currentIndex() >= 0 && comb_->currentIndex() < comb_->count())
*scheme_id = comb_->currentIndex();
else {
*scheme_id = -1;
}
}
return text;
}
void hg_settingdialog::create_scheme_management_ui(QVBoxLayout* layout)
{
QLabel *title = new QLabel(this);
m_label_restore = new QLabel(this);
bool enabled = false;
QHBoxLayout *hLayout = new QHBoxLayout();
int width = 180;
int width2 = 110;
int space = 10;
#if defined (loongarch64)
width2 = 120;
space = 5;
#endif
std::vector<std::string> schemes;
std::string cur_schm(cur_cfg_->get_current_scheme_name());
cur_cfg_->get_all_schemes(schemes);
comb_ = new QComboBox(this);
layout->addSpacing(30);
for(int i = 0; i < (int)schemes.size(); ++i)
{
comb_->addItem(QString::fromStdString(schemes[i]));
if(cur_schm == schemes[i])
{
enabled = true;
comb_->setCurrentText(QString::fromStdString(schemes[i]));
}
}
if(!enabled)
comb_->setCurrentIndex(0);
title->setFixedWidth(width);
comb_->setFixedWidth(width);
title->setText(tr("existing configuration scheme"));
layout->addWidget(title);
layout->addWidget(comb_);
layout->addSpacing(space);
m_pbtn_addNew = new QPushButton(this);
m_pbtn_addNew->setText(tr("Add new"));
m_pbtn_addNew->setFixedWidth(width2);
layout->addWidget(m_pbtn_addNew);
connect(m_pbtn_addNew, SIGNAL(clicked(bool)), this, SLOT(slot_pushButton_scheme_management()));
layout->addSpacing(space);
m_pbtn_Save = new QPushButton(this);
m_pbtn_Save->setText(tr("Save"));
m_pbtn_Save->setFixedWidth(width2);
layout->addWidget(m_pbtn_Save);
connect(m_pbtn_Save, SIGNAL(clicked(bool)), this, SLOT(slot_pushButton_scheme_management()));
layout->addSpacing(space);
m_deleteCur = new QPushButton(this);
m_deleteCur->setText(tr("Delete"));
m_deleteCur->setEnabled(enabled);
m_deleteCur->setFixedWidth(width2);
layout->addWidget(m_deleteCur);
connect(m_deleteCur, SIGNAL(clicked(bool)), this, SLOT(slot_pushButton_scheme_management()));
layout->addSpacing(space);
m_deleteAll = new QPushButton(this);
m_deleteAll->setText(tr("Delete all"));
m_deleteAll->setEnabled(enabled);
m_deleteAll->setFixedWidth(width2);
layout->addWidget(m_deleteAll);
connect(m_deleteAll, SIGNAL(clicked(bool)), this, SLOT(slot_pushButton_scheme_management()));
layout->addSpacing(space);
m_label_restore->setWordWrap(true);
m_label_restore->setStyleSheet("color:red;");
QString prompt = QString(tr("The current parameter settings are inconsistent with the configuration scheme '%1'. To use the configuration scheme '%1' parameters, please click the restore button"));
m_label_restore->setText(prompt.arg(comb_->currentText()));
layout->addWidget(m_label_restore);
m_pbtn_restore = new QPushButton(this);
m_pbtn_restore->setText(tr("Restore"));
m_pbtn_restore->setFixedWidth(width2);
layout->addWidget(m_pbtn_restore);
connect(m_pbtn_restore, SIGNAL(clicked(bool)), this, SLOT(slot_pushButton_scheme_management()));
layout->addStretch();
updateRestorePushButton();
m_deleteCur->setEnabled(true);
m_deleteAll->setEnabled(true);
m_pbtn_Save->setEnabled(true);
int index = comb_->currentIndex();
int count = comb_->count();
if (index == 0)
{
m_deleteCur->setEnabled(false);
m_pbtn_Save->setEnabled(false);
}
if (count == 1)
{
m_deleteAll->setEnabled(false);
}
//title = new QLabel(this);
//title->setText(tr("confgiuration information:"));
//layout->addWidget(title);
// sketch_ = new QTextEdit(this);
// sketch_->setReadOnly(true);
// sketch_->setFixedSize(width, 200);
// sketch_->setVisible(false);
//layout->addWidget(sketch_);
//on_current_scheme_changed();
}
void hg_settingdialog::createUI()
{
QTabWidget *tabWidgetCreation = new QTabWidget(this);
QPushButton *buttonAbout = new QPushButton(this);
buttonAbout->setText(tr("about..."));
QPushButton *buttonScan = new QPushButton(this);
buttonScan->setText(tr("scan"));
QPushButton *buttonOk = new QPushButton(this);
buttonOk->setText(tr("ok"));
buttonOk->setDefault(true);
QPushButton *buttonCancel = new QPushButton(this);
buttonCancel->setText(tr("cancel"));
buttonCancel->setShortcut(Qt::Key_Escape);
QHBoxLayout *hlayoutOkAndCancel = new QHBoxLayout;
hlayoutOkAndCancel->addStretch();
hlayoutOkAndCancel->addWidget(buttonAbout);
hlayoutOkAndCancel->addWidget(buttonScan);
hlayoutOkAndCancel->addWidget(buttonOk);
hlayoutOkAndCancel->addWidget(buttonCancel);
QWidget *widgetOkAndCancel = new QWidget();
widgetOkAndCancel->setLayout(hlayoutOkAndCancel);
connect(buttonAbout, SIGNAL(clicked(bool)), this, SLOT(slot_buttonAboutClicked()));
connect(buttonScan, SIGNAL(clicked(bool)), this, SLOT(slot_buttonScanClicked()));
connect(buttonOk, SIGNAL(clicked(bool)), this, SLOT(slot_buttonOkClicked()));
connect(buttonCancel, SIGNAL(clicked(bool)), this, SLOT(slot_buttonCancelClicked()));
if (!m_showScan)
{
buttonScan->setVisible(false);
}
QHBoxLayout *h = new QHBoxLayout();
QVBoxLayout *v1 = new QVBoxLayout(),
*v2 = new QVBoxLayout();
create_scheme_management_ui(v1);
v2->addWidget(tabWidgetCreation);
QGroupBox *grp = new QGroupBox(tr("configuration scheme management"), this);
grp->setLayout(v1);
grp->setFixedSize(195, 500);
h->addWidget(grp);
h->addLayout(v2);
QVBoxLayout* mainVerticalLayout = new QVBoxLayout(this);
mainVerticalLayout->addLayout(h);
// mainVerticalLayout->addWidget(tabWidgetCreation);
mainVerticalLayout->addWidget(widgetOkAndCancel);
this->setLayout(mainVerticalLayout);
QScrollArea* scrollArea = new QScrollArea;
scrollArea->setWidgetResizable(true);
scrollArea->setAlignment(Qt::AlignCenter);
QFormLayout* layout = new QFormLayout;
QWidget* widget = new QWidget;
widget->setLayout(layout);
bool isBegin = true;
for (int i = 0; i < m_list_defaultOptions.size(); i++)
{
const SANE_Option_Descriptor* opt = reinterpret_cast<const SANE_Option_Descriptor*>(m_list_defaultOptions.at(i).first);
int ind = -1;
std::string cur_val("");
if(opt == nullptr) continue;
h = nullptr;
cur_scheme_->get_config(opt->name, cur_val);
switch (opt->type)
{
case SANE_TYPE_BOOL:
{
QCheckBox *checkBoxCreation = new QCheckBox;
if (strcmp(opt->name, SANE_STD_OPT_NAME_CUSTOM_AREA) == 0)
{
QWidget* widget_cbtn_pbtn = new QWidget;
widget_cbtn_pbtn->setMaximumWidth(200);
QLabel *label = new QLabel;
label->setText(QString::fromStdString(opt->title) + QString(" : "));
btn_cut_area_ = new QPushButton;
btn_cut_area_->setText(tr("regional crop"));
btn_cut_area_->setFixedWidth(150);
QHBoxLayout *hLayout = new QHBoxLayout;
hLayout->addWidget(checkBoxCreation);
hLayout->addWidget(btn_cut_area_);
widget_cbtn_pbtn->setLayout(hLayout);
custom_area_lable_ = label;
reinterpret_cast<QFormLayout*>(widget->layout())->addRow(label, widget_cbtn_pbtn);
connect(btn_cut_area_, SIGNAL(clicked(bool)), this, SLOT(slot_cutButtonClicked()));
}
else if (strcmp(opt->name, SANE_STD_OPT_NAME_IS_CUSTOM_GAMMA) == 0)
{
//continue;
QWidget* widget_cbtn_pbtn = new QWidget(scrollArea);
widget_cbtn_pbtn->setMaximumWidth(200);
btn_gamma_ = new QPushButton(widget_cbtn_pbtn);
btn_gamma_->setText(tr("custom tone curve"));
btn_gamma_->setFixedWidth(150);
QHBoxLayout *hLayout = new QHBoxLayout;
hLayout->addWidget(checkBoxCreation);
hLayout->addWidget(btn_gamma_);
widget_cbtn_pbtn->setLayout(hLayout);
reinterpret_cast<QFormLayout*>(widget->layout())->addRow(opt->title + QString(" : "), widget_cbtn_pbtn);
connect(btn_gamma_, SIGNAL(clicked(bool)), this, SLOT(slot_gammaButtonClicked()));
}
else
reinterpret_cast<QFormLayout*>(widget->layout())->addRow(opt->title + QString(" : "), checkBoxCreation);
checkBoxCreation->setToolTip(opt->desc);
int id = i + 1;
bool enable = *(bool*)&cur_val[0];
checkBoxCreation->setProperty("controls_id", id);
checkBoxCreation->setChecked(enable);
if (strcmp(opt->name, SANE_STD_OPT_NAME_IS_CUSTOM_GAMMA) == 0 && btn_gamma_ != nullptr)
{
btn_gamma_->setEnabled(enable);
}
if (strcmp(opt->name, SANE_STD_OPT_NAME_CUSTOM_AREA) == 0)
btn_cut_area_->setEnabled(enable);
else if (strcmp(opt->name, SANE_STD_OPT_NAME_IS_CUSTOM_GAMMA) == 0 && btn_gamma_ != nullptr)
btn_gamma_->setEnabled(enable);
connect(checkBoxCreation, SIGNAL(stateChanged(int)), this, SLOT(slot_checkedClicked()));
m_list_widgets.append(checkBoxCreation);
m_list_getOpt.append(QPair<int, const void*>(id, opt));
break;
}
case SANE_TYPE_INT:
{
switch(opt->constraint_type)
{
case SANE_CONSTRAINT_NONE:
{
QSpinBox* spinBox = new QSpinBox(scrollArea);
#ifdef HG_CMP_MSC
spinBox->setMinimumWidth(75);
#else
spinBox->setMinimumWidth(150);
#endif
spinBox->setToolTip(opt->desc);
spinBox->setRange(1, 1000);
int id = i + 1;
spinBox->setProperty("controls_id", id);
QHBoxLayout* hLayout = new QHBoxLayout;
hLayout->addWidget(spinBox);
hLayout->addStretch();
reinterpret_cast<QFormLayout*>(widget->layout())->addRow(opt->title + QString(" : "), spinBox);
m_list_widgets.append(spinBox);
m_list_getOpt.append(QPair<int, const void*>(id, opt));
spinBox->setValue(*(int*)&cur_val[0]);
connect(spinBox, SIGNAL(valueChanged(int)), this, SLOT(slot_spinBoxClicked(int)));
break;
}
case SANE_CONSTRAINT_RANGE:
{
QWidget* widget_slider_spin = new QWidget(scrollArea);
QSlider* sliderCreation = new QSlider(widget_slider_spin);
if (0 == strcmp(opt->name, SANE_STD_OPT_NAME_THRESHOLD) || 0 == strcmp(opt->name, SANE_STD_OPT_NAME_ANTI_NOISE_LEVEL) ||
0 == strcmp(opt->name, SANE_STD_OPT_NAME_MARGIN))
{
sliderCreation->installEventFilter(this);
}
sliderCreation->setOrientation(Qt::Horizontal);
sliderCreation->setRange(opt->constraint.range->min, opt->constraint.range->max);
sliderCreation->setToolTip(opt->desc);
sliderCreation->setProperty("controls_id", i+1);
sliderCreation->setValue(m_list_defaultOptions.at(i).second.toInt());
QSpinBox* spinBox = new QSpinBox(widget_slider_spin);
#ifdef HG_CMP_MSC
widget_slider_spin->setMinimumWidth(200);
sliderCreation->setMinimumWidth(100);
spinBox->setMinimumWidth(75);
#else
widget_slider_spin->setMinimumWidth(300);
sliderCreation->setMinimumWidth(120);
spinBox->setMinimumWidth(150);
#endif
spinBox->setToolTip(opt->desc);
spinBox->setRange(opt->constraint.range->min, opt->constraint.range->max);
spinBox->setSingleStep(1);
spinBox->setValue(m_list_defaultOptions.at(i).second.toInt());
int id = i + 1;
spinBox->setProperty("controls_id", id);
m_list_sliderSpinbox.append(QPair<QObject*, QObject*>(sliderCreation, spinBox));
QHBoxLayout* hLayout = new QHBoxLayout;
hLayout->addWidget(sliderCreation);
hLayout->addWidget(spinBox);
// hLayout->addStretch();
widget_slider_spin->setLayout(hLayout);
reinterpret_cast<QFormLayout*>(widget->layout())->addRow(opt->title + QString(" : "), widget_slider_spin);
m_list_widgets.append(sliderCreation);
m_list_widgets.append(spinBox);
m_list_getOpt.append(QPair<int, const void*>(id, opt));
int cur = *(int*)&cur_val[0];
spinBox->setValue(cur);
sliderCreation->setValue(cur);
connect(spinBox, SIGNAL(valueChanged(int)), this, SLOT(slot_spinBoxClicked(int)));
connect(sliderCreation, SIGNAL(valueChanged(int)), this, SLOT(slot_sliderClicked(int)));
break;
}
case SANE_CONSTRAINT_WORD_LIST:
{
QComboBox* comboBoxCreation = new QComboBox(scrollArea);
comboBoxCreation->setToolTip(opt->desc);
int id = i + 1;
comboBoxCreation->setProperty("controls_id", id);
reinterpret_cast<QFormLayout*>(widget->layout())->addRow(opt->title + QString(" : "), comboBoxCreation);
auto p_str = opt->constraint.word_list;
char buf[20];
for(SANE_Int i = 0; i < p_str[0]; ++i)
{
sprintf(buf, "%d", p_str[i + 1]);
comboBoxCreation->addItem(QString::fromStdString(buf));
}
sprintf(buf, "%d", m_list_defaultOptions.at(i).second.toInt());
comboBoxCreation->setProperty(hg_settingdialog::property_combox_data_type_.c_str(), COMBO_VAL_INT);
m_list_widgets.append(comboBoxCreation);
m_list_getOpt.append(QPair<int, const void*>(id, opt));
char nstr[40] = {0};
sprintf(nstr, "%d", *(int*)&cur_val[0]);
comboBoxCreation->setCurrentText(QString::fromStdString(nstr));
connect(comboBoxCreation, SIGNAL(currentTextChanged(const QString)), this, SLOT(slot_string_list_comboBoxClicked()));
break;
}
case SANE_CONSTRAINT_STRING_LIST:
break;
}
break;
}
case SANE_TYPE_FIXED:
{
QWidget* widget_slider_spin = new QWidget(scrollArea);
QSlider* sliderCreation = new QSlider(widget_slider_spin);
sliderCreation->setOrientation(Qt::Horizontal);
sliderCreation->setToolTip(opt->desc);
int id = i + 1;
sliderCreation->setProperty("controls_id", id);
sliderCreation->setRange(SANE_UNFIX(opt->constraint.range->min) * 100, SANE_UNFIX(opt->constraint.range->max) * 100);
sliderCreation->setValue(SANE_UNFIX(m_list_defaultOptions.at(i).second.toDouble()) * 100);
QDoubleSpinBox* spinBox = new QDoubleSpinBox(widget_slider_spin);
#ifdef HG_CMP_MSC
widget_slider_spin->setMinimumWidth(200);
sliderCreation->setMinimumWidth(100);
spinBox->setMinimumWidth(75);
#else
widget_slider_spin->setMinimumWidth(300);
sliderCreation->setMinimumWidth(120);
spinBox->setMinimumWidth(150);
#endif
spinBox->setToolTip(opt->desc);
spinBox->setDecimals(2);
spinBox->setSingleStep(0.01);
spinBox->setRange(SANE_UNFIX(opt->constraint.range->min), SANE_UNFIX(opt->constraint.range->max));
spinBox->setValue(sliderCreation->value() * spinBox->singleStep());
spinBox->setProperty("controls_id", id);
m_list_sliderSpinbox.append(QPair<QObject*, QObject*>(sliderCreation, spinBox));
QHBoxLayout* hLayout = new QHBoxLayout;
hLayout->addWidget(sliderCreation);
hLayout->addWidget(spinBox);
// hLayout->addStretch();
widget_slider_spin->setLayout(hLayout);
reinterpret_cast<QFormLayout*>(widget->layout())->addRow(opt->title + QString(" : "), widget_slider_spin);
m_list_widgets.append(sliderCreation);
m_list_widgets.append(spinBox);
m_list_getOpt.append(QPair<int, const void*>(id, opt));
// iniRead(md5(opt->title), id, sliderCreation);
// iniRead(md5(opt->title), id, spinBox);
float v = SANE_UNFIX(*(SANE_Fixed*)&cur_val[0]);
sliderCreation->setValue(v * 100);
spinBox->setValue(sliderCreation->value() * spinBox->singleStep());
connect(spinBox, SIGNAL(valueChanged(double)), this, SLOT(slot_doubleSpinboxClicked(double)));
connect(sliderCreation, SIGNAL(valueChanged(int)), this, SLOT(slot_sliderClicked(int)));
break;
}
case SANE_TYPE_STRING:
{
switch(opt->constraint_type)
{
case SANE_CONSTRAINT_NONE:
{
QLineEdit *lineEdit = new QLineEdit(scrollArea);
lineEdit->setToolTip(opt->desc);
int id = i + 1;
lineEdit->setProperty("controls_id", id);
reinterpret_cast<QFormLayout*>(widget->layout())->addRow(opt->title + QString(" : "), lineEdit);
m_list_widgets.append(lineEdit);
m_list_getOpt.append(QPair<int, const void*>(id, opt));
// iniRead(md5(opt->title), id, lineEdit);
bool readOnly = IS_CAP_READONLY(opt->cap);
lineEdit->setEnabled(!readOnly);
lineEdit->setText(QString::fromStdString(cur_val));
connect(lineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(slot_lineEditInput()));
break;
}
case SANE_CONSTRAINT_RANGE:
break;
case SANE_CONSTRAINT_WORD_LIST:
break;
case SANE_CONSTRAINT_STRING_LIST:
{
QComboBox* comboBoxCreation = new QComboBox(scrollArea);
comboBoxCreation->setToolTip(opt->desc);
int id = i + 1;
comboBoxCreation->setProperty("controls_id", id);
reinterpret_cast<QFormLayout*>(widget->layout())->addRow(opt->title + QString(" : "), comboBoxCreation);
if (0 == strcmp(opt->name, SANE_STD_OPT_NAME_TEXT_DIRECTION))
{
comboBoxCreation->installEventFilter(this);
}
auto p_str = opt->constraint.string_list;
QStringList stringList;
while(*p_str)
{
stringList.append(*p_str);
p_str++;
}
if(stringList.isEmpty() != true)
{
for(int i = 0; i < (stringList.size()); i++)
comboBoxCreation->addItem(stringList.at(i));
}
comboBoxCreation->setCurrentText(m_list_defaultOptions.at(i).second.toString());
comboBoxCreation->setProperty(hg_settingdialog::property_combox_data_type_.c_str(), COMBO_VAL_STRING);
//printf("Option %02d default value is: %s\n", i + 1, m_list_defaultOptions.at(i).second.toString().data());
m_list_widgets.append(comboBoxCreation);
m_list_getOpt.append(QPair<int, const void*>(id, opt));
// iniRead(md5(opt->title), id, comboBoxCreation);
comboBoxCreation->setCurrentText(QString::fromStdString(cur_val));
connect(comboBoxCreation, SIGNAL(currentTextChanged(const QString)), this, SLOT(slot_string_list_comboBoxClicked()));
break;
}
}
break;
}
case SANE_TYPE_BUTTON:
{
QPushButton* pushButton = new QPushButton(this);
pushButton->setText(opt->title);
pushButton->setToolTip(opt->desc);
int id = i + 1;
pushButton->setProperty("controls_id", id);
hlayoutOkAndCancel->insertWidget(0, pushButton, 0, Qt::AlignRight);
connect(pushButton, SIGNAL(clicked(bool)), this, SLOT(slot_pushButtonClicked()));
break;
}
case SANE_TYPE_GROUP:
{
if (isBegin)
{
scrollArea->setWindowTitle(opt->title);
isBegin = false;
}else{
scrollArea->setWidget(widget);
tabWidgetCreation->addTab(scrollArea, scrollArea->windowTitle());
scrollArea = new QScrollArea;
scrollArea->setWidgetResizable(true);
scrollArea->setWindowTitle(opt->title);
layout = new QFormLayout;
widget = new QWidget;
widget->setLayout(layout);
}
m_list_widgets.append(nullptr);
break;
}
} //switch(opt->type)
// if (Utf8ToStdString(opt->title) == "分辨率")
if (strcmp(opt->name, SANE_STD_OPT_NAME_RESOLUTION) == 0)
{
m_dpiId = i + 1;
m_dpiValue = m_list_defaultOptions.at(i).second.toInt();
}
// else if (Utf8ToStdString(opt->title) == "纸张尺寸")
else if (strcmp(opt->name, SANE_STD_OPT_NAME_PAPER) == 0)
{
m_paperSizeId = i + 1;
m_paperSizeValue = m_list_defaultOptions.at(i).second.toString();
}
if (0 == strcmp(opt->name, SANE_STD_OPT_NAME_CUSTOM_AREA_LEFT))
{
m_cutLeftId = i + 1;
m_cutLeftValue = SANE_UNFIX(m_list_defaultOptions.at(i).second.toInt());
if (opt->constraint_type == SANE_CONSTRAINT_RANGE)
m_cutWidth = SANE_UNFIX(opt->constraint.range->max);
}
else if (0 == strcmp(opt->name, SANE_STD_OPT_NAME_CUSTOM_AREA_TOP))
{
m_cutTopId = i + 1;
m_cutTopValue = SANE_UNFIX(m_list_defaultOptions.at(i).second.toInt());
if (opt->constraint_type == SANE_CONSTRAINT_RANGE)
m_cutHeight = SANE_UNFIX(opt->constraint.range->max);
}
else if (0 == strcmp(opt->name, SANE_STD_OPT_NAME_CUSTOM_AREA_RIGHT))
{
m_cutRightId = i + 1;
m_cutRightValue = SANE_UNFIX(m_list_defaultOptions.at(i).second.toInt());
}
else if (0 == strcmp(opt->name, SANE_STD_OPT_NAME_CUSTOM_AREA_BOTTOM))
{
m_cutBottomId = i + 1;
m_cutBottomValue = SANE_UNFIX(m_list_defaultOptions.at(i).second.toInt());
}
// else if (Utf8ToStdString(opt->title) == "颜色模式")
if (strcmp(opt->name, SANE_STD_OPT_NAME_COLOR_MODE) == 0)
{
m_colorModeId = i + 1;
m_colorModeValue = m_list_defaultOptions.at(i).second.toString();
}
// else if (Utf8ToStdString(opt->title) == "伽玛" || Utf8ToStdString(opt->title) == "伽玛值")
} //for
hlayoutOkAndCancel->insertWidget(0, buttonAbout, 0, Qt::AlignRight);
updateUIStatus();
scrollArea->setWidget(widget);
tabWidgetCreation->addTab(scrollArea, scrollArea->windowTitle());
}
void hg_settingdialog::refresh_control_value(int op_id)
{
QVector<QWidget*> ctrls = find_control(op_id);
if(ctrls.empty())
return;
const SANE_Option_Descriptor* opt = (const SANE_Option_Descriptor*)m_list_defaultOptions.at(op_id - 1).first;
if(opt->type == SANE_TYPE_BOOL)
{
for(size_t i = 0; i < (size_t)ctrls.size(); ++i)
{
QCheckBox* cb = qobject_cast<QCheckBox*>(ctrls[i]);
if(cb)
{
disconnect(cb, SIGNAL(stateChanged(int)), this, SLOT(slot_checkedClicked()));
cb->setChecked(m_list_defaultOptions.at(op_id - 1).second.toBool());
if (0 == strcmp(opt->name, SANE_STD_OPT_NAME_IS_MULTI_OUT))
{
m_isMultiOutMode = cb->isChecked();
}
if (strcmp(opt->name, SANE_STD_OPT_NAME_IS_CUSTOM_GAMMA) == 0 && btn_gamma_ != nullptr)
{
btn_gamma_->setEnabled(m_list_defaultOptions.at(op_id - 1).second.toBool());
}
if (strcmp(opt->name, SANE_STD_OPT_NAME_CUSTOM_AREA) == 0 && btn_cut_area_ != nullptr)
{
btn_cut_area_->setEnabled(m_list_defaultOptions.at(op_id - 1).second.toBool());
}
connect(cb, SIGNAL(stateChanged(int)), this, SLOT(slot_checkedClicked()));
break;
}
}
}
else if(opt->type == SANE_TYPE_INT)
{
for(size_t i = 0; i < (size_t)ctrls.size(); ++i)
{
QComboBox* comb = qobject_cast<QComboBox*>(ctrls[i]);
if(comb)
{
char buf[40] = {0};
sprintf(buf, "%d", m_list_defaultOptions.at(op_id - 1).second.toInt());
comb->disconnect(comb, SIGNAL(currentTextChanged(const QString)), this, SLOT(slot_string_list_comboBoxClicked()));
auto p_str = opt->constraint.word_list;
char buf2[20];
comb->clear();
for (SANE_Int i = 0; i < p_str[0]; ++i)
{
sprintf(buf2, "%d", p_str[i + 1]);
comb->addItem(QString::fromStdString(buf2));
}
comb->setCurrentText(QString::fromStdString(buf));
connect(comb, SIGNAL(currentTextChanged(const QString)), this, SLOT(slot_string_list_comboBoxClicked()));
}
else
{
QSlider* slider = qobject_cast<QSlider*>(ctrls[i]);
if(slider)
{
disconnect(slider, SIGNAL(valueChanged(int)), this, SLOT(slot_sliderClicked(int)));
slider->setValue(m_list_defaultOptions.at(op_id - 1).second.toInt());
if (opt->constraint_type == SANE_CONSTRAINT_RANGE)
slider->setRange(opt->constraint.range->min, opt->constraint.range->max);
connect(slider, SIGNAL(valueChanged(int)), this, SLOT(slot_sliderClicked(int)));
}
else
{
QSpinBox* spin = qobject_cast<QSpinBox*>(ctrls[i]);
if(spin)
{
disconnect(spin, SIGNAL(valueChanged(int)), this, SLOT(slot_spinBoxClicked(int)));
spin->setValue(m_list_defaultOptions.at(op_id - 1).second.toInt());
if (opt->constraint_type == SANE_CONSTRAINT_RANGE)
spin->setRange(opt->constraint.range->min, opt->constraint.range->max);
connect(spin, SIGNAL(valueChanged(int)), this, SLOT(slot_spinBoxClicked(int)));
}
}
}
}
}
else if(opt->type == SANE_TYPE_FIXED)
{
double val = SANE_UNFIX(m_list_defaultOptions.at(op_id - 1).second.toInt());
QSlider *slider = NULL;
QDoubleSpinBox* spin = NULL;
for(size_t i = 0; i < (size_t)ctrls.size(); ++i)
{
QComboBox* comb = qobject_cast<QComboBox*>(ctrls[i]);
if(comb)
{
char buf[40] = {0};
sprintf(buf, "%f", val);
comb->disconnect(comb, SIGNAL(currentTextChanged(const QString)), this, SLOT(slot_string_list_comboBoxClicked()));
comb->setCurrentText(QString::fromStdString(buf));
connect(comb, SIGNAL(currentTextChanged(const QString)), this, SLOT(slot_string_list_comboBoxClicked()));
}
else if(!slider)
{
slider = qobject_cast<QSlider*>(ctrls[i]);
// if(slider)
// disconnect(slider, SIGNAL(valueChanged(int)), this, SLOT(slot_sliderClicked(int)));
}
else if(!spin)
{
spin = qobject_cast<QDoubleSpinBox*>(ctrls[i]);
// if(spin)
// disconnect(spin, SIGNAL(valueChanged(double)), this, SLOT(slot_spinBoxClicked(double)));
}
}
if (slider)
{
disconnect(slider, SIGNAL(valueChanged(int)), this, SLOT(slot_sliderClicked(int)));
if (opt->constraint_type == SANE_CONSTRAINT_RANGE)
slider->setRange(SANE_UNFIX(opt->constraint.range->min) * 100, SANE_UNFIX(opt->constraint.range->max) * 100);
slider->setValue(val * 100);
connect(slider, SIGNAL(valueChanged(int)), this, SLOT(slot_sliderClicked(int)));
}
if (spin)
{
disconnect(spin, SIGNAL(valueChanged(double)), this, SLOT(slot_spinBoxClicked(double)));
if (opt->constraint_type == SANE_CONSTRAINT_RANGE)
spin->setRange(SANE_UNFIX(opt->constraint.range->min), SANE_UNFIX(opt->constraint.range->max));
spin->setValue(val);
connect(spin, SIGNAL(valueChanged(double)), this, SLOT(slot_spinBoxClicked(double)));
}
}
else if(opt->type == SANE_TYPE_STRING)
{
for(size_t i = 0; i < (size_t)ctrls.size(); ++i)
{
QComboBox* comb = qobject_cast<QComboBox*>(ctrls[i]);
if(comb)
{
disconnect(comb, SIGNAL(currentTextChanged(const QString)), this, SLOT(slot_string_list_comboBoxClicked()));
comb->clear();
auto p_str = opt->constraint.string_list;
QStringList stringList;
while (*p_str)
{
stringList.append(*p_str);
p_str++;
}
if (stringList.isEmpty() != true)
{
for (int i = 0; i < (stringList.size()); i++)
comb->addItem(stringList.at(i));
}
QString strValue = m_list_defaultOptions.at(op_id - 1).second.toString();
comb->setCurrentText(strValue);
if (m_isMultiOutMode && 0 == strcmp(opt->name, SANE_STD_OPT_NAME_MULTI_OUT_TYPE))
{
m_multiColorValue = strValue;
}
else if (!m_isMultiOutMode && 0 == strcmp(opt->name, SANE_STD_OPT_NAME_COLOR_MODE))
{
m_colorModeValue = strValue;
}
// comb->setProperty(hg_settingdialog::property_combox_data_type_.c_str(), COMBO_VAL_STRING);
connect(comb, SIGNAL(currentTextChanged(const QString)), this, SLOT(slot_string_list_comboBoxClicked()));
}
else
{
QLineEdit* edit = qobject_cast<QLineEdit*>(ctrls[i]);
if(edit)
{
disconnect(edit, SIGNAL(textChanged(const QString&)), this, SLOT(slot_lineEditInput()));
edit->setText(m_list_defaultOptions.at(op_id - 1).second.toString());
connect(edit, SIGNAL(textChanged(const QString&)), this, SLOT(slot_lineEditInput()));
}
}
}
}
}
QVector<QWidget*> hg_settingdialog::find_control(int opt_num)
{
QVector<QWidget*> list_w;
for(int i = 0; i< m_list_widgets.size(); i++)
{
if (m_list_widgets.at(i) == nullptr) continue;
QWidget* w = m_list_widgets.at(i);
int id = w->property("controls_id").toInt();
if(opt_num == id)
list_w.append(w);
}
return list_w;
}
void hg_settingdialog::updateUIStatus()
{
update_opt_value_from_driver();
SANE_Int dev_options = 0;
m_saneAPI.sane_control_option_api(m_devHandle, 0, SANE_ACTION_GET_VALUE, &dev_options, nullptr);
for(int id = 1, optons = dev_options; id < optons; id++)
{
QVector<QWidget*> list_widgets = find_control(id);
if (list_widgets.empty()) continue;
QWidget* widget = list_widgets.first();
if (widget == nullptr) continue;
QWidget* parentWidget = widget->parentWidget();
while (parentWidget->layout() &&
typeid(*(parentWidget->layout())) != typeid(QFormLayout))
{
widget = parentWidget;
parentWidget = widget->parentWidget();
}
QFormLayout* layout = reinterpret_cast<QFormLayout*>(parentWidget->layout());
const SANE_Option_Descriptor* opt = reinterpret_cast<const SANE_Option_Descriptor*>(m_list_defaultOptions.at(id - 1).first);
bool hide = (opt->cap & SANE_CAP_INACTIVE) == SANE_CAP_INACTIVE;
QWidget* w_label = layout ? layout->labelForField(widget) : nullptr;
if( strcmp(opt->name, SANE_STD_OPT_NAME_CUSTOM_AREA_LEFT) == 0 ||
strcmp(opt->name, SANE_STD_OPT_NAME_CUSTOM_AREA_TOP) == 0 ||
strcmp(opt->name, SANE_STD_OPT_NAME_CUSTOM_AREA_RIGHT) == 0 ||
strcmp(opt->name, SANE_STD_OPT_NAME_CUSTOM_AREA_BOTTOM) == 0 )
hide = true;
refresh_control_value(id);
//if (strcmp(opt->name, SANE_STD_OPT_NAME_BRIGHTNESS) == 0 ||
// strcmp(opt->name, SANE_STD_OPT_NAME_CONTRAST) == 0 ||
// strcmp(opt->name, SANE_STD_OPT_NAME_GAMMA) == 0 ||
// strcmp(opt->name, SANE_STD_OPT_NAME_IS_CUSTOM_GAMMA) == 0)
//{
// if (w_label)
// w_label->show();
// widget->setVisible(true);
//}
//else
//{
if(w_label)
hide ? w_label->hide() : w_label->show();
widget->setVisible(!hide);
//}
if(strcmp(opt->name, SANE_STD_OPT_NAME_CUSTOM_AREA) == 0)
{
if(hide)
{
custom_area_lable_->hide();
btn_cut_area_->hide();
}
else
{
custom_area_lable_->show();
btn_cut_area_->show();
}
}
}
}
void hg_settingdialog::on_scan_status(QString info, bool isScanning)
{
if (!info.isEmpty())
{
QMessageBox::information(this, tr("Prompt"), info);
}
m_isScanning = isScanning;
this->setEnabled(!isScanning);
setAttribute(Qt::WA_DeleteOnClose, !isScanning);
if (!isScanning)
{
m_isAutoFinish = true;
close();
}
}
void hg_settingdialog::slot_checkedClicked()
{
QCheckBox *checkBox = qobject_cast<QCheckBox*>(sender());
SANE_Int id = checkBox->property("controls_id").toInt();
SANE_Bool checkBoxcurrentState = checkBox->isChecked();
if (checkBox->underMouse())
{
m_isRefreshUi = false;
}
SANE_Int method = 0;
SANE_Status ret = m_saneAPI.sane_control_option_api(m_devHandle, id, SANE_ACTION_SET_VALUE, &checkBoxcurrentState, &method);
if (ret == SANE_STATUS_UNSUPPORTED)
{
SANE_Bool value = false;
ret = m_saneAPI.sane_control_option_api(m_devHandle, id, SANE_ACTION_GET_VALUE, &value, &method);
disconnect(checkBox, SIGNAL(stateChanged(int)), this, SLOT(slot_checkedClicked()));
checkBox->setCheckState(value ? Qt::Checked : Qt::Unchecked);
connect(checkBox, SIGNAL(stateChanged(int)), this, SLOT(slot_checkedClicked()));
QMessageBox::information(this, tr("Prompt"), tr("The funtion is unsupported"));
return;
}
if((method & SANE_INFO_RELOAD_OPTIONS) == SANE_INFO_RELOAD_OPTIONS)
updateUIStatus();
else if(method & SANE_INFO_INEXACT)
checkBox->setCheckState(checkBoxcurrentState ? Qt::CheckState::Checked : Qt::CheckState::Unchecked);
const SANE_Option_Descriptor* opt = nullptr;
for (int i = 0; i < m_list_getOpt.size(); i++)
{
if (m_list_getOpt.at(i).first == id)
{
opt = reinterpret_cast<const SANE_Option_Descriptor*>(m_list_getOpt.at(i).second);
break;
}
}
if (strcmp(opt->name, SANE_STD_OPT_NAME_IS_MULTI_OUT) == 0)
{
if (checkBoxcurrentState)
{
m_isMultiOutMode = true;
}
else
{
m_isMultiOutMode = false;
m_multiColorValue.clear();
}
}
if(strcmp(opt->name, SANE_STD_OPT_NAME_CUSTOM_AREA) == 0)
btn_cut_area_->setEnabled(checkBoxcurrentState);
else if (strcmp(opt->name, SANE_STD_OPT_NAME_IS_CUSTOM_GAMMA) == 0 && btn_gamma_ != nullptr)
btn_gamma_->setEnabled(checkBoxcurrentState);
//cur_scheme_->config_changed(id, (char*)&checkBoxcurrentState, sizeof(checkBoxcurrentState));
if (!m_isRefreshUi && checkBoxcurrentState && (0 == strcmp(opt->name, SANE_STD_OPT_NAME_RID_MORR) || 0 == strcmp(opt->name, SANE_STD_OPT_NAME_RID_GRID)))
{
QMessageBox::information(this, tr("Prompt"), tr("This function may cause a decrease in the speed of drawing."));
}
updateRestorePushButton();
}
void hg_settingdialog::slot_string_list_comboBoxClicked()
{
QComboBox *comboBox = qobject_cast<QComboBox*>(sender());
SANE_Int id = comboBox->property("controls_id").toInt();
std::string comboBoxcurrentItem(comboBox->currentText().toUtf8());
int type = comboBox->property(hg_settingdialog::property_combox_data_type_.c_str()).toInt();
if (id == m_dpiId)
{
m_dpiValue = atoi(comboBoxcurrentItem.c_str());
qDebug("dpi=%d", m_dpiValue);
}
else if (id == m_paperSizeId)
{
m_paperSizeValue = comboBoxcurrentItem.c_str();
qDebug("paperSize=%s", comboBoxcurrentItem.c_str());
}
else if (id == m_colorModeId)
{
m_colorModeValue = comboBoxcurrentItem.c_str();
qDebug("colorMode=%s", comboBoxcurrentItem.c_str());
}
if (m_isMultiOutMode)
{
m_multiColorValue = comboBoxcurrentItem.c_str();
qDebug("colorMode=%s", comboBoxcurrentItem.c_str());
}
const SANE_Option_Descriptor* opt = nullptr;
for (int i = 0; i < m_list_getOpt.size(); i++)
{
if (m_list_getOpt.at(i).first == id)
{
opt = reinterpret_cast<const SANE_Option_Descriptor*>(m_list_getOpt.at(i).second);
break;
}
}
SANE_Int method = 0;
SANE_String buf = (SANE_String)malloc(opt->size * 2 + 4);
if(type == COMBO_VAL_INT)
*((SANE_Int*)buf) = atoi(comboBoxcurrentItem.c_str());
else if(type == COMBO_VAL_FLOAT)
*((SANE_Fixed*)buf) = SANE_FIX(atof(comboBoxcurrentItem.c_str()));
else
strcpy(buf, comboBoxcurrentItem.c_str());
SANE_Status ret = m_saneAPI.sane_control_option_api(m_devHandle, id, SANE_ACTION_SET_VALUE, buf, &method);
if (ret == SANE_STATUS_UNSUPPORTED)
{
char* value = (char*)malloc(opt->size * 2 + 4);
ret = m_saneAPI.sane_control_option_api(m_devHandle, id, SANE_ACTION_GET_VALUE, value, &method);
if (value != nullptr)
comboBox->setCurrentText(QString::fromStdString(value));
free(value);
QMessageBox::information(this, tr("Prompt"), tr("The funtion is unsupported"));
return;
}
if((method & SANE_INFO_RELOAD_OPTIONS) == SANE_INFO_RELOAD_OPTIONS)
updateUIStatus();
else if(method & SANE_INFO_INEXACT)
comboBox->setCurrentText(QString::fromStdString(buf));
//if(type == COMBO_VAL_INT)
// cur_scheme_->config_changed(id, buf, sizeof(SANE_Int));
//else if(type == COMBO_VAL_FLOAT)
// cur_scheme_->config_changed(id, buf, sizeof(SANE_Fixed));
//else
//{
// std::string langCN(to_default_language(buf, nullptr));
// cur_scheme_->config_changed(id, &langCN[0], langCN.length());
//}
free(buf);
bool ok = false;
if (0 == strcmp(opt->name, SANE_STD_OPT_NAME_TEXT_DIRECTION))
{
if (0 == strcmp(to_default_language(comboBox->currentText().toStdString().c_str(), &ok), OPTION_VALUE_WGFX_ZDWBFXSB))
{
if (!m_isRefreshUi)
QMessageBox::information(this, tr("Prompt"), tr("This function may cause a decrease in the speed of drawing."));
}
}
if (0 == strcmp(opt->name, SANE_STD_OPT_NAME_SCAN_MODE))
{
if (0 == strcmp(to_default_language(comboBox->currentText().toStdString().c_str(), &ok), OPTION_VALUE_SMZS_SMZDZS))
{
SANE_Int scanCount = 0;
int scan_count_id = 0;
find_option_description(SANE_STD_OPT_NAME_SCAN_COUNT, &scan_count_id);
SANE_Status ret = m_saneAPI.sane_control_option_api(m_devHandle, scan_count_id, SANE_ACTION_GET_VALUE, &scanCount, &method);
if (scanCount < 2)
{
SANE_Int value = 1;
ret = m_saneAPI.sane_control_option_api(m_devHandle, scan_count_id, SANE_ACTION_SET_VALUE, &value, &method);
}
}
}
updateRestorePushButton();
}
void hg_settingdialog::slot_pushButtonClicked()
{
QPushButton *pushButton = qobject_cast<QPushButton*>(sender());
SANE_Int id = pushButton->property("controls_id").toInt(),
after = 0;
// restore to default setting ?
SANE_Status ret = m_saneAPI.sane_control_option_api(m_devHandle, id, SANE_ACTION_SET_VALUE, NULL, &after);
if (ret == SANE_STATUS_UNSUPPORTED)
{
QMessageBox::information(this, tr("Prompt"), tr("The funtion is unsupported"));
return;
}
if((after & SANE_INFO_RELOAD_OPTIONS) == SANE_INFO_RELOAD_OPTIONS)
updateUIStatus();
const SANE_Option_Descriptor* opt = m_saneAPI.sane_get_option_descriptor_api(m_devHandle, id);
if(opt && strcmp(opt->name, SANE_STD_OPT_NAME_RESTORE) == 0)
{
restore_2_default_settings();
}
}
void hg_settingdialog::slot_cutButtonClicked()
{
//int width = 0.03937 * m_cutWidth * m_dpiValue;
//int height = 0.03937 * m_cutHeight * m_dpiValue;
//qreal left = 0.03937 * m_cutLeftValue * m_dpiValue;
//qreal top = 0.03937 * m_cutTopValue * m_dpiValue;
//qreal right = 0.03937 * m_cutRightValue * m_dpiValue;
//qreal bottom = 0.03937 * m_cutBottomValue * m_dpiValue;
bool ok = false;
CutPaperTool dlg(m_dpiValue, QString::fromStdString(to_default_language(m_paperSizeValue.toStdString().c_str(), &ok)), 300, m_customCutAreaUnit, this);
QRectF rc(m_cutLeftValue, m_cutTopValue, m_cutRightValue - m_cutLeftValue, m_cutBottomValue - m_cutTopValue);
dlg.setCutRectMM(rc);
if (dlg.exec())
{
QRectF rcRet = dlg.getCutRectMM();
m_cutLeftValue = rcRet.left();
m_cutTopValue = rcRet.top();
m_cutRightValue = rcRet.right();
m_cutBottomValue = rcRet.bottom();
SANE_Int info;
SANE_Word value = SANE_FIX(m_cutLeftValue);
m_saneAPI.sane_control_option_api(m_devHandle, m_cutLeftId, SANE_ACTION_SET_VALUE, &value, &info);
//cur_scheme_->config_changed(m_cutLeftId, (char*)&value, sizeof(value));
value = SANE_FIX(m_cutTopValue);
m_saneAPI.sane_control_option_api(m_devHandle, m_cutTopId, SANE_ACTION_SET_VALUE, &value, &info);
//cur_scheme_->config_changed(m_cutTopId, (char*)&value, sizeof(value));
value = SANE_FIX(m_cutRightValue);
m_saneAPI.sane_control_option_api(m_devHandle, m_cutRightId, SANE_ACTION_SET_VALUE, &value, &info);
//cur_scheme_->config_changed(m_cutRightId, (char*)&value, sizeof(value));
value = SANE_FIX(m_cutBottomValue);
m_saneAPI.sane_control_option_api(m_devHandle, m_cutBottomId, SANE_ACTION_SET_VALUE, &value, &info);
//cur_scheme_->config_changed(m_cutBottomId, (char*)&value, sizeof(value));
m_customCutAreaUnit = dlg.getUnit();
updateRestorePushButton();
}
}
void hg_settingdialog::slot_gammaButtonClicked()
{
bool ok = false;
int colorMode = 0; // 0-彩色, 1-灰度
if (0 == strcmp(to_default_language(m_colorModeValue.toStdString().c_str(), &ok), OPTION_VALUE_YSMS_256JHD) ||
0 == strcmp(to_default_language(m_colorModeValue.toStdString().c_str(), &ok), OPTION_VALUE_YSMS_HB) ||
0 == strcmp(to_default_language(m_multiColorValue.toStdString().c_str(), &ok), OPTION_VALUE_DLSCLX_HD_HB))
{
colorMode = 1;
}
setPicClrTool dlg(colorMode, this);
if (1 == colorMode)
{
QList<QPoint> grayKeyTable;
for (int i = 0; i < m_gammaData.count[GAMMA_INDEX_GRAY]; ++i)
{
uchar x = m_gammaData.pt_gray[i];
uchar y = m_gammaData.table[256 * GAMMA_INDEX_GRAY + x];
grayKeyTable.append(QPoint(x, y));
}
if (!grayKeyTable.empty())
{
dlg.setGrayKeyTable(grayKeyTable);
}
}
else if (0 == colorMode)
{
QList<QPoint> colorKeyTable;
for (int i = 0; i < m_gammaData.count[GAMMA_INDEX_COLOR]; ++i)
{
uchar x = m_gammaData.pt_color[i];
uchar y = m_gammaData.table[256 * GAMMA_INDEX_COLOR + x];
colorKeyTable.append(QPoint(x, y));
}
QList<QPoint> rKeyTable;
for (int i = 0; i < m_gammaData.count[GAMMA_INDEX_RED]; ++i)
{
uchar x = m_gammaData.pt_red[i];
uchar y = m_gammaData.table[256 * GAMMA_INDEX_RED + x];
rKeyTable.append(QPoint(x, y));
}
QList<QPoint> gKeyTable;
for (int i = 0; i < m_gammaData.count[GAMMA_INDEX_GREEN]; ++i)
{
uchar x = m_gammaData.pt_green[i];
uchar y = m_gammaData.table[256 * GAMMA_INDEX_GREEN + x];
gKeyTable.append(QPoint(x, y));
}
QList<QPoint> bKeyTable;
for (int i = 0; i < m_gammaData.count[GAMMA_INDEX_BLUE]; ++i)
{
uchar x = m_gammaData.pt_blue[i];
uchar y = m_gammaData.table[256 * GAMMA_INDEX_BLUE + x];
bKeyTable.append(QPoint(x, y));
}
QVector<QList<QPoint>> keyTableList;
if (!colorKeyTable.empty() && !rKeyTable.empty() && !gKeyTable.empty() && !bKeyTable.empty())
{
keyTableList.append(colorKeyTable);
keyTableList.append(rKeyTable);
keyTableList.append(gKeyTable);
keyTableList.append(bKeyTable);
dlg.setRGBKeyTable(keyTableList);
}
}
int rgbTypeIndex = 0;
rgbTypeIndex = m_gammaData.app_data & 0x0F;
int colorTypeIndex = 0;
colorTypeIndex = (m_gammaData.app_data & 0xF0) >> 4;
dlg.setRgbAndColorType(rgbTypeIndex, colorTypeIndex);
if (dlg.exec())
{
clicked_gamma_ = true;
if (1 == colorMode)
{
QList<QPoint> keyTable = dlg.getGrayKeyTable();
m_gammaData.count[GAMMA_INDEX_GRAY] = HGMIN(4, keyTable.size());
int i = 0;
for (QPoint pt : keyTable)
{
if (i >= 4)
break;
m_gammaData.pt_gray[i] = pt.x();
++i;
}
dlg.getGrayTable(m_gammaData.table, 256);
}
else
{
QVector<QList<QPoint>> keyTableList = dlg.getRGBKeyTable();
m_gammaData.count[GAMMA_INDEX_COLOR] = HGMIN(4, keyTableList[0].size());
int i = 0;
for (QPoint pt : keyTableList[0])
{
if (i >= 4)
break;
m_gammaData.pt_color[i] = pt.x();
++i;
}
m_gammaData.count[GAMMA_INDEX_RED] = HGMIN(4, keyTableList[1].size());
i = 0;
for (QPoint pt : keyTableList[1])
{
if (i >= 4)
break;
m_gammaData.pt_red[i] = pt.x();
++i;
}
m_gammaData.count[GAMMA_INDEX_GREEN] = HGMIN(4, keyTableList[2].size());
i = 0;
for (QPoint pt : keyTableList[2])
{
if (i >= 4)
break;
m_gammaData.pt_green[i] = pt.x();
++i;
}
m_gammaData.count[GAMMA_INDEX_BLUE] = HGMIN(4, keyTableList[3].size());
i = 0;
for (QPoint pt : keyTableList[3])
{
if (i >= 4)
break;
m_gammaData.pt_blue[i] = pt.x();
++i;
}
dlg.getRGBTable(m_gammaData.table + 256, 256 * 4);
}
QVector<int> type = dlg.getRgbAndColorType();
m_gammaData.app_data = type[0] | (type[1] << 4);
dev_que::set_custom_gamma(&m_saneAPI, m_devHandle, &m_gammaData);
updateRestorePushButton();
}
}
void hg_settingdialog::slot_word_list_comboBoxClicked(int value)
{
QComboBox *comboBox = qobject_cast<QComboBox*>(sender());
SANE_Int id = comboBox->property("controls_id").toInt();
SANE_Int temp = value;
const SANE_Option_Descriptor* opt = nullptr;
for (int i = 0; i < m_list_getOpt.size(); i++)
{
if (m_list_getOpt.at(i).first == id)
{
opt = reinterpret_cast<const SANE_Option_Descriptor*>(m_list_getOpt.at(i).second);
break;
}
}
// m_list_IdValueTitle.append(QPair<QPair<int, QVariant>, QString>(QPair<int, QVariant>(id, temp), md5(opt->title)));
SANE_Int method = 0;
SANE_Status ret = m_saneAPI.sane_control_option_api(m_devHandle, id, SANE_ACTION_SET_VALUE, &temp, &method);
if (ret == SANE_STATUS_UNSUPPORTED)
{
char* value = (char*)malloc(opt->size * 2 + 4);
ret = m_saneAPI.sane_control_option_api(m_devHandle, id, SANE_ACTION_GET_VALUE, value, &method);
if (value != nullptr)
comboBox->setCurrentText(QString::fromStdString(value));
free(value);
QMessageBox::information(this, tr("Prompt"), tr("The funtion is unsupported"));
return;
}
if((method & SANE_INFO_RELOAD_OPTIONS) == SANE_INFO_RELOAD_OPTIONS)
updateUIStatus();
else if(method & SANE_INFO_INEXACT)
{
char buf[20];
sprintf(buf, "%d", temp);
comboBox->setCurrentText(QString::fromStdString(buf));
}
//cur_scheme_->config_changed(id, (char*)&temp, sizeof(temp));
updateRestorePushButton();
}
void hg_settingdialog::slot_sliderClicked(int value)
{
QSlider *slider = qobject_cast<QSlider*>(sender());
SANE_Int id = slider->property("controls_id").toInt();
if (id == m_dpiId)
{
m_dpiValue = value;
qDebug("dpi=%d", m_dpiValue);
}
QAbstractSpinBox* spin = nullptr;
for(int i = 0; i < m_list_sliderSpinbox.size(); i++)
if (m_list_sliderSpinbox.at(i).first == slider)
{
spin = reinterpret_cast<QAbstractSpinBox*>(m_list_sliderSpinbox.at(i).second);
break;
}
const SANE_Option_Descriptor* opt = nullptr;
for (int i = 0; i < m_list_getOpt.size(); i++)
{
if (m_list_getOpt.at(i).first == id)
{
opt = reinterpret_cast<const SANE_Option_Descriptor*>(m_list_getOpt.at(i).second);
break;
}
}
if (spin != nullptr)
{
SANE_Int val = value, method = 0;
bool db_val = false;
if (typeid(*spin) == typeid(QSpinBox))
{
QSpinBox* spin_ = reinterpret_cast<QSpinBox*>(spin);
spin_->setValue(value);
}
else
{
QDoubleSpinBox* spin_ = reinterpret_cast<QDoubleSpinBox*>(spin);
double temp = value * spin_->singleStep();
if(temp != spin_->value())
spin_->setValue(temp);
val = SANE_FIX(temp);
db_val = true;
}
SANE_Status ret = m_saneAPI.sane_control_option_api(m_devHandle, id, SANE_ACTION_SET_VALUE, &val, &method);
if (ret == SANE_STATUS_UNSUPPORTED)
{
if (!db_val)
{
SANE_Int value = 0;
ret = m_saneAPI.sane_control_option_api(m_devHandle, id, SANE_ACTION_GET_VALUE, &value, &method);
slider->setValue(value);
}
else
{
SANE_Fixed value = 0;
ret = m_saneAPI.sane_control_option_api(m_devHandle, id, SANE_ACTION_GET_VALUE, &value, &method);
slider->setValue(value);
}
QMessageBox::information(this, tr("Prompt"), tr("The funtion is unsupported"));
return;
}
if((method & SANE_INFO_RELOAD_OPTIONS) == SANE_INFO_RELOAD_OPTIONS)
updateUIStatus();
else if(method & SANE_INFO_INEXACT)
{
if(db_val)
{
QDoubleSpinBox* spin_ = reinterpret_cast<QDoubleSpinBox*>(spin);
double v = SANE_UNFIX(val);
spin_->setValue(v);
slider->setValue(spin_->value() / spin_->singleStep());
}
else
{
QSpinBox* spin_ = reinterpret_cast<QSpinBox*>(spin);
spin_->setValue(val);
slider->setValue(spin_->value() / spin_->singleStep());
}
}
//cur_scheme_->config_changed(id, (char*)&val, sizeof(val));
updateRestorePushButton();
}
}
void hg_settingdialog::slot_doubleSpinboxClicked(double value)
{
QDoubleSpinBox* spinBox = qobject_cast<QDoubleSpinBox*>(sender());
QAbstractSlider* slider = nullptr;
int id = spinBox->property("controls_id").toInt();
for (int i = 0; i < m_list_sliderSpinbox.size(); i++)
{
if (m_list_sliderSpinbox.at(i).second == spinBox)
{
slider = reinterpret_cast<QAbstractSlider*>(m_list_sliderSpinbox.at(i).first);
break;
}
}
if(slider != nullptr)
{
int temp = static_cast<int>(value / spinBox->singleStep() + 0.5);
QSlider* slider_ = reinterpret_cast<QSlider*>(slider);
if (slider_->value() != temp)
slider_->setValue(temp);
}
}
void hg_settingdialog::slot_spinBoxClicked(int value)
{
QSpinBox* spinBox = qobject_cast<QSpinBox*>(sender());
int id = spinBox->property("controls_id").toInt();
const SANE_Option_Descriptor* opt = nullptr;
for (int i = 0; i < m_list_getOpt.size(); i++)
{
if (m_list_getOpt.at(i).first == id)
{
opt = reinterpret_cast<const SANE_Option_Descriptor*>(m_list_getOpt.at(i).second);
break;
}
}
QAbstractSlider* slider = nullptr;
for (int i = 0; i < m_list_sliderSpinbox.size(); i++)
{
if (m_list_sliderSpinbox.at(i).second == spinBox)
{
slider = reinterpret_cast<QAbstractSlider*>(m_list_sliderSpinbox.at(i).first);
break;
}
}
if(slider == nullptr)
{
SANE_Int temp = value;
//m_list_IdValueTitle.append(QPair<QPair<int, QVariant>, QString>(QPair<int, QVariant>(id, temp), md5(opt->title)));
SANE_Int method = 0;
SANE_Status ret = m_saneAPI.sane_control_option_api(m_devHandle, id, SANE_ACTION_SET_VALUE, &temp, &method);
if (ret == SANE_STATUS_UNSUPPORTED)
{
QMessageBox::information(this, tr("Prompt"), tr("The funtion is unsupported"));
return;
}
if((method & SANE_INFO_RELOAD_OPTIONS) == SANE_INFO_RELOAD_OPTIONS)
updateUIStatus();
else if(value != temp)
{
disconnect(spinBox, SIGNAL(valueChanged(int)), this, SLOT(slot_spinBoxClicked(int)));
spinBox->setValue(temp);
connect(spinBox, SIGNAL(valueChanged(int)), this, SLOT(slot_spinBoxClicked(int)));
}
//cur_scheme_->config_changed(id, (char*)&temp, sizeof(temp));
updateRestorePushButton();
}
else
{
QSlider* slider_ = reinterpret_cast<QSlider*>(slider);
slider_->setValue(spinBox->value());
}
}
void hg_settingdialog::slot_lineEditInput()
{
QLineEdit* lineEdit = qobject_cast<QLineEdit*>(sender());
int id = lineEdit->property("controls_id").toInt();
std::string lineEditCurrentText(lineEdit->text().toUtf8());
const SANE_Option_Descriptor* opt = nullptr;
for (int i = 0; i < m_list_getOpt.size(); i++)
{
if (m_list_getOpt.at(i).first == id)
{
opt = reinterpret_cast<const SANE_Option_Descriptor*>(m_list_getOpt.at(i).second);
break;
}
}
//m_list_IdValueTitle.append(QPair<QPair<int, QVariant>, QString>(QPair<int, QVariant>(id, &lineEditCurrentText.at(0)), md5(opt->title)));
SANE_Int method = 0;
void *buf = NULL;
SANE_Int nv = 0;
if(opt->type == SANE_TYPE_INT)
{
nv = atoi(lineEditCurrentText.c_str());
buf = &nv;
}
else if(opt->type == SANE_TYPE_FIXED)
{
nv = SANE_FIX(atof(lineEditCurrentText.c_str()));
buf = &nv;
}
else
{
buf = malloc(opt->size * 2 + 4);
strcpy((char*)buf, lineEditCurrentText.c_str());
}
SANE_Status ret = m_saneAPI.sane_control_option_api(m_devHandle, id, SANE_ACTION_SET_VALUE, buf, &method);
if (ret == SANE_STATUS_UNSUPPORTED)
{
QMessageBox::information(this, tr("Prompt"), tr("The funtion is unsupported"));
return;
}
if((method & SANE_INFO_RELOAD_OPTIONS) == SANE_INFO_RELOAD_OPTIONS)
updateUIStatus();
else if(method & SANE_INFO_INEXACT)
{
char mem[20], *v = mem;
if(opt->type == SANE_TYPE_INT)
sprintf(mem, "%d", nv);
else if(opt->type == SANE_TYPE_FIXED)
sprintf(mem, "%f", SANE_UNFIX(nv));
else
v = (char*)buf;
lineEdit->setText(QString::fromStdString(v));
}
const SANE_Option_Descriptor* opt2 = nullptr;
for (int i = 0; i < m_list_getOpt.size(); i++)
{
if (m_list_getOpt.at(i).first == id)
{
opt2 = reinterpret_cast<const SANE_Option_Descriptor*>(m_list_getOpt.at(i).second);
break;
}
}
if(opt2->type == SANE_TYPE_INT || opt2->type == SANE_TYPE_FIXED)
{
//cur_scheme_->config_changed(id, (char*)buf, sizeof(SANE_Int));
updateRestorePushButton();
}
else
{
std::string langCN(to_default_language((char*)buf, nullptr));
//cur_scheme_->config_changed(id, &langCN[0], langCN.length());
updateRestorePushButton();
}
if (buf != nullptr)
free(buf);
}
void hg_settingdialog::slot_buttonAboutClicked()
{
char info[256] = { 0 };
SANE_Int data = 0;
SANE_Status ret = SANE_STATUS_GOOD;
QString content;
QString title = tr("about ") + QString::fromStdString(m_devName);
ret = m_saneAPI.sane_control_option_api(m_devHandle, (SANE_Int)0x8855, SANE_ACTION_GET_VALUE, info, NULL);
if (ret != SANE_STATUS_GOOD)
{
QString str = tr("Not supported");
strcpy(info, str.toStdString().c_str());
}
content += tr("<p>Device model: %1</p>").arg(QString(info));
info[0] = 0;
ret = m_saneAPI.sane_control_option_api(m_devHandle, (SANE_Int)0x884A, SANE_ACTION_GET_VALUE, info, NULL);
if (ret != SANE_STATUS_GOOD)
{
QString str = tr("Not supported");
strcpy(info, str.toStdString().c_str());
}
content += tr("<p>Driver version: %1</p>").arg(QString(info));
info[0] = 0;
ret = m_saneAPI.sane_control_option_api(m_devHandle, (SANE_Int)0x8857, SANE_ACTION_GET_VALUE, info, NULL);
if (ret != SANE_STATUS_GOOD)
{
QString str = tr("Not supported");
strcpy(info, str.toStdString().c_str());
}
content += tr("<p>Firmware number: %1</p>").arg(QString(info));
info[0] = 0;
ret = m_saneAPI.sane_control_option_api(m_devHandle, (SANE_Int)0x8856, SANE_ACTION_GET_VALUE, info, NULL);
if (ret != SANE_STATUS_GOOD)
{
QString str = tr("Not supported");
strcpy(info, str.toStdString().c_str());
}
content += tr("<p>Serial number: %1</p>").arg(QString(info));
info[0] = 0;
ret = m_saneAPI.sane_control_option_api(m_devHandle, (SANE_Int)0x9902, SANE_ACTION_GET_VALUE, &data, NULL);
if (ret != SANE_STATUS_GOOD)
{
QString str = tr("Not supported");
strcpy(info, str.toStdString().c_str());
content += tr("<p>Roller count: %1</p>").arg(QString(info));
info[0] = 0;
}
else
{
content += tr("<p>Roller count: %1</p>").arg(QString::number(data));
}
ret = m_saneAPI.sane_control_option_api(m_devHandle, (SANE_Int)0x8849, SANE_ACTION_GET_VALUE, &data, NULL);
if (ret != SANE_STATUS_GOOD)
{
QString str = tr("Not supported");
strcpy(info, str.toStdString().c_str());
content += tr("<p>History count: %1</p>").arg(QString(info));
info[0] = 0;
}
else
{
content += tr("<p>History count: %1</p>").arg(QString::number(data));
}
#if !defined (OEM_ZHONGJING)
info[0] = 0;
ret = m_saneAPI.sane_control_option_api(m_devHandle, (SANE_Int)0x8866, SANE_ACTION_GET_VALUE, info, NULL);
if (ret != SANE_STATUS_GOOD)
{
QString str = tr("Not supported");
strcpy(info, str.toStdString().c_str());
}
content += tr("<p>Initial startup time: %1</p>").arg(QString(info));
info[0] = 0;
#endif
QMessageBox msg(QMessageBox::NoIcon, title,
content, QMessageBox::Ok, this);
#ifdef HG_CMP_MSC
msg.setStyleSheet("QLabel{""min-width: 280px;""}");
#else
msg.setStyleSheet("QLabel{""min-width: 300px;""}");
#endif
int code = lang_get_cur_code_page();
if (code == 1258)
msg.setStyleSheet("QLabel{""min-width: 320px;""}");
msg.exec();
}
void hg_settingdialog::slot_buttonScanClicked()
{
m_closeButton = closeButtonScan;
if (!quit_)
m_callback(UI_RESULT_START_SCAN);
}
void hg_settingdialog::slot_buttonOkClicked()
{
m_closeButton = closeButtonOk;
close();
}
void hg_settingdialog::slot_buttonCancelClicked()
{
m_closeButton = closeButtonCancel;
close();
}
void hg_settingdialog::keyPressEvent(QKeyEvent *e)
{
if (e->key() == Qt::Key_Return)
{
slot_buttonOkClicked();
}
else
{
QDialog::keyPressEvent(e);
}
}
int hg_settingdialog::get_changed_items(void)
{
return changed_count_;
}
int hg_settingdialog::getCloseButtonCliked()
{
return m_closeButton;
}
gb::sane_config_schm *hg_settingdialog::getCurScheme()
{
return cur_scheme_;
}
//生成UTF-8编码的MD5值
QString hg_settingdialog::md5(QString key)
{
QCryptographicHash md5(QCryptographicHash::Md5);
md5.addData(key.toUtf8());
return QString(md5.result().toHex());
}
const void* hg_settingdialog::find_option_description(int id)
{
for(int i = 0; i < m_list_getOpt.size(); i++)
{
if (m_list_getOpt.at(i).first == id)
return reinterpret_cast<const SANE_Option_Descriptor*>(m_list_getOpt.at(i).second);
}
return nullptr;
}
const void* hg_settingdialog::find_option_description(const std::string& title, int* id)
{
for(int i = 0; i < m_list_getOpt.size(); i++)
{
std::string t((reinterpret_cast<const SANE_Option_Descriptor*>(m_list_getOpt.at(i).second))->name);
if (title == t)
{
if(id)
*id = m_list_getOpt.at(i).first;
return reinterpret_cast<const SANE_Option_Descriptor*>(m_list_getOpt.at(i).second);
}
}
return nullptr;
}
void hg_settingdialog::closeEvent(QCloseEvent* e)
{
// 配置方案策略更改后的业务保存逻辑：
//
// 1、用户模板方案，显示的点击buttonSave时才保存；
// 2、默认方案，点击确定按钮后在此处保存；非默认方案保存用户的选择
// 3、点击取消按钮时，恢复至该窗口初始化时候的状态
//
// 代码逻辑：
// 1、属性值改变时，不再同时同步到配置方案中，而是点击确定后再一起保存
// 2、用户切换方案时，如果当前值与方案不匹配，则将改变同步到默认方案（暂时关闭该功能）
// 3、点击确定按钮后，如果当前方案非用户模板，则保存进默认配置；如果为用户模板，则更新当前方案索引
// 4、点出取消按钮，恢复驱动值至该对话框初始化状态，不对配置作变更
//
if (m_isScanning)
{
e->ignore();
return;
}
int index = comb_->currentIndex();
if (m_closeButton == closeButtonOk)
{
if (cur_scheme_)
cur_scheme_->release();
cur_scheme_ = cur_cfg_->get_scheme(comb_->currentText().toStdString().c_str());
if (comb_->currentIndex() == 0)
{
cur_scheme_ = cur_cfg_->get_scheme(gb::scanner_cfg::user_default_scheme_name().c_str());
updateSchemeFromUi(cur_scheme_);
}
cur_cfg_->select_scheme(cur_scheme_->get_scheme_name().c_str());
cur_cfg_->save();
}
else
{
// 配置方案内容不再随时变动
cancelScheme();
}
e->accept();
}
void hg_settingdialog::save_to_default_if_ui_not_equal_scheme(gb::sane_config_schm* cur, bool save)
{
int index = 1; // comb_->currentIndex();
if (index)
{
gb::sane_config_schm* schm = new gb::sane_config_schm();
updateSchemeFromUi(schm);
if ((cur && !schm->is_equal(cur)) ||
(!cur && schm->has_changed()))
{
index = 0;
}
schm->release();
}
if (index == 0 || !cur)
{
cur = cur_cfg_->get_scheme(gb::scanner_cfg::user_default_scheme_name().c_str());
updateSchemeFromUi(cur);
}
if (save)
{
cur_cfg_->select_scheme(cur->get_scheme_name().c_str());
cur_cfg_->save();
}
}
bool hg_settingdialog::eventFilter(QObject *target, QEvent *event)
{
if (typeid(*target) == typeid(QSlider))
{
if (event->type() == QEvent::Wheel)
{
return true;
}
}
else if (typeid(*target) == typeid(QComboBox))
{
if (event->type() == QEvent::MouseButtonPress)
{
m_isRefreshUi = false;
}
}
return QDialog::eventFilter(target, event);
}
void hg_settingdialog::setIcon()
{
this->setWindowIcon(QIcon(":logo/image_rsc/logo/logo.ico"));
#if defined(OEM_HANWANG)
this->setWindowIcon(QIcon(":logo/image_rsc/logo/Hanvon_logo1.ico"));
#elif defined(OEM_LISICHENG)
this->setWindowIcon(QIcon(":logo/image_rsc/logo/Lanxum_logo.ico"));
#elif defined(OEM_CANGTIAN)
this->setWindowIcon(QIcon(":logo/image_rsc/logo/Cumtenn_logo.ico"));
#elif defined(OEM_ZHONGJING)
this->setWindowIcon(QIcon(":logo/image_rsc/logo/Microtek_logo.ico"));
#elif defined(OEM_ZIGUANG)
this->setWindowIcon(QIcon(":logo/image_rsc/logo/uniscan.ico"));
#elif defined(OEM_NEUTRAL)
this->setWindowIcon(QIcon(":logo/image_rsc/logo/NoBrand_logo.ico"));
#elif defined(OEM_DELI)
this->setWindowIcon(QIcon(":logo/image_rsc/logo/deli.ico"));
#elif defined(OEM_MEISONGDA)
this->setWindowIcon(QIcon(":logo/image_rsc/logo/maxsound_logo.ico"));
#elif defined(OEM_GUANGDIANTONG)
this->setWindowIcon(QIcon(":logo/image_rsc/logo/toec_logo.ico"));
#endif
}
void hg_settingdialog::cancelScheme()
{
SANE_Int none = 0;
for (int i = 0; i < m_list_originDeviceScheme.size(); i++)
{
const SANE_Option_Descriptor* opt = reinterpret_cast<const SANE_Option_Descriptor*>(m_list_originDeviceScheme.at(i).first);
if (!opt || opt->type == SANE_TYPE_BUTTON || opt->type == SANE_TYPE_GROUP)
continue;
if (opt->type == SANE_TYPE_BOOL)
{
SANE_Bool v = m_list_originDeviceScheme.at(i).second.toBool();
m_saneAPI.sane_control_option_api(m_devHandle, i + 1, SANE_ACTION_SET_VALUE, &v, &none);
if (0 == strcmp(opt->name, SANE_STD_OPT_NAME_IS_CUSTOM_GAMMA))
{
m_saneAPI.sane_control_option_api(m_devHandle, 0x885A, SANE_ACTION_SET_VALUE, &m_originGammaData, NULL);
}
}
else if (opt->type == SANE_TYPE_INT)
{
SANE_Int v = m_list_originDeviceScheme.at(i).second.toInt();;
m_saneAPI.sane_control_option_api(m_devHandle, i + 1, SANE_ACTION_SET_VALUE, &v, &none);
}
else if (opt->type == SANE_TYPE_FIXED)
{
double v = SANE_UNFIX(m_list_originDeviceScheme.at(i).second.toDouble());
SANE_Int v2 = SANE_FIX(v);
m_saneAPI.sane_control_option_api(m_devHandle, i + 1, SANE_ACTION_SET_VALUE, &v2, &none);
}
else
{
QString v = m_list_originDeviceScheme.at(i).second.toString();
std::string v2 = v.toStdString();
m_saneAPI.sane_control_option_api(m_devHandle, i + 1, SANE_ACTION_SET_VALUE, (void*)v2.c_str(), &none);
}
}
}
void hg_settingdialog::updateSchemeFromUi(gb::sane_config_schm* schm)
{
SANE_Int dev_options = 0;
bool custom_area = false, custom_gamma = false;
m_saneAPI.sane_control_option_api(m_devHandle, 0, SANE_ACTION_GET_VALUE, &dev_options, nullptr);
if (!schm)
schm = cur_scheme_;
schm->copy_default_value(def_value_);
for (int i = 1, j = dev_options; i < j; i++)
{
const SANE_Option_Descriptor* opt = m_saneAPI.sane_get_option_descriptor_api(m_devHandle, i);
SANE_Int method = 0;
if (opt == nullptr)
{
continue;
}
else
{
if (opt->type == SANE_TYPE_INT)
{
SANE_Int init = 0;
m_saneAPI.sane_control_option_api(m_devHandle, i, SANE_ACTION_GET_VALUE, &init, &method);
schm->config_changed(i, (char*)&init, sizeof(init));
}
else if (opt->type == SANE_TYPE_FIXED)
{
SANE_Fixed init = 0;
m_saneAPI.sane_control_option_api(m_devHandle, i, SANE_ACTION_GET_VALUE, &init, &method);
schm->config_changed(i, (char*)&init, sizeof(init));
}
else if (opt->type == SANE_TYPE_BOOL)
{
SANE_Bool init = 0;
m_saneAPI.sane_control_option_api(m_devHandle, i, SANE_ACTION_GET_VALUE, &init, &method);
schm->config_changed(i, (char*)&init, sizeof(init));
if (std::string(opt->name) == SANE_STD_OPT_NAME_CUSTOM_AREA)
{
custom_area = init == SANE_TRUE;
}
else if (std::string(opt->name) == SANE_STD_OPT_NAME_IS_CUSTOM_GAMMA)
{
custom_gamma = init == SANE_TRUE;
}
}
else if (opt->type == SANE_TYPE_STRING)
{
char* init = (char*)malloc(opt->size * 2 + 4);
m_saneAPI.sane_control_option_api(m_devHandle, i, SANE_ACTION_GET_VALUE, init, &method);
std::string value = QString(init).toStdString();
const char* vv = to_default_language(value.c_str(), nullptr);
schm->config_changed(i, vv, strlen(vv));
free(init);
}
}
}
if (!custom_area)
{
schm->remove_config(SANE_STD_OPT_NAME_CUSTOM_AREA_LEFT);
schm->remove_config(SANE_STD_OPT_NAME_CUSTOM_AREA_TOP);
schm->remove_config(SANE_STD_OPT_NAME_CUSTOM_AREA_RIGHT);
schm->remove_config(SANE_STD_OPT_NAME_CUSTOM_AREA_BOTTOM);
}
else
{
schm->config_changed(SANE_STD_OPT_NAME_CUSTOM_AREA, (char*)&m_customCutAreaUnit, sizeof(m_customCutAreaUnit), true);
}
if (custom_gamma)
{
SANE_Gamma gamma;
m_saneAPI.sane_control_option_api(m_devHandle, SANE_OPT_ID_CUSTOM_GAMMA, SANE_ACTION_GET_VALUE, &gamma, nullptr);
schm->config_changed(SANE_STD_OPT_NAME_IS_CUSTOM_GAMMA, (char*)&gamma, sizeof(gamma), true);
}
}
void hg_settingdialog::updateSchemeManagerUi()
{
m_deleteCur->setEnabled(true);
m_deleteAll->setEnabled(true);
m_pbtn_Save->setEnabled(true);
if (comb_->currentIndex() == 0)
{
m_deleteCur->setEnabled(false);
m_pbtn_Save->setEnabled(false);
}
if (comb_->count() == 1)
{
m_deleteAll->setEnabled(false);
}
}
void hg_settingdialog::updateRestorePushButton()
{
gb::sane_config_schm* cfgScheme = new gb::sane_config_schm();
bool ok = false;
cfgScheme = cur_cfg_->get_scheme(to_default_language(comb_->currentText().toStdString().c_str(), &ok));
gb::sane_config_schm* schm = new gb::sane_config_schm();
updateSchemeFromUi(schm);
bool restore = false;
if ((cfgScheme && !schm->is_equal(cfgScheme)))
{
restore = true;
}
QString prompt = QString(tr("The current parameter settings are inconsistent with the configuration scheme '%1'. To use the configuration scheme '%1' parameters, please click the restore button"));
m_label_restore->setText(prompt.arg(comb_->currentText()));
m_label_restore->setVisible(restore);
m_pbtn_restore->setVisible(restore);
}
std::string sane_val_to_string(const char* val, SANE_Value_Type type)
{
char buf[128] = {0};
std::string ret("");
switch(type)
{
case SANE_TYPE_BOOL:
ret = *(SANE_Bool*)val == SANE_TRUE ? "true" : "false";
break;
case SANE_TYPE_INT:
sprintf(buf, "%d", *(int*)val);
ret = buf;
break;
case SANE_TYPE_FIXED:
sprintf(buf, "%.4f", SANE_UNFIX(*(SANE_Fixed*)val));
ret = buf;
break;
default:
ret = val;
break;
}
return ret;
}
void hg_settingdialog::on_current_scheme_changed()
{
updateSchemeManagerUi();
//save_to_default_if_ui_not_equal_scheme(cur_scheme_, false);
if (cur_scheme_)
cur_scheme_->release();
cur_scheme_ = cur_cfg_->get_scheme(comb_->currentText().toStdString().c_str());
hg_settingdialog::apply_scheme(m_devHandle, &m_saneAPI, cur_scheme_);
updateUIStatus();
updateRestorePushButton();
}
void hg_settingdialog::slot_pushButton_scheme_management(void)
{
QPushButton* btn = qobject_cast<QPushButton*>(sender());
if(btn == m_pbtn_addNew)
{
int id = 0;
QString text(find_current_scheme_menu(&id));
int index = comb_->count();
if(!text.isEmpty() && id >= 0)
{
Dialog_Input dlg(this);
dlg.setEditText(text);
dlg.setWindowTitle(tr("Add new scheme"));
if(dlg.exec())
{
QString defaultSetting = "\351\273\230\350\256\244\350\256\276\347\275\256";//默认设置
QString newCfgName = dlg.getText();
for (int i = 0; i < comb_->count(); ++i)
{
if (newCfgName == comb_->itemText(i) || newCfgName == "Default setting" || newCfgName == "default_setting"
|| newCfgName == defaultSetting)
{
QMessageBox::information(this, tr("tips"), tr("The configuration scheme already exists"));
return;
}
}
disconnect(comb_, SIGNAL(currentTextChanged(const QString)), this, SLOT(on_current_scheme_changed()));
comb_->insertItem(index, newCfgName);
connect(comb_, SIGNAL(currentTextChanged(const QString)), this, SLOT(on_current_scheme_changed()));
gb::sane_config_schm* scheme = new gb::sane_config_schm();
if (cur_scheme_ != nullptr)
{
cur_scheme_->end_setting(true);
cur_scheme_->release();
}
scheme->set_scheme_name(newCfgName.toStdString().c_str());
cur_scheme_ = scheme;
updateSchemeFromUi();
cur_cfg_->add_scheme(cur_scheme_, newCfgName.toStdString().c_str());
// cur_cfg_->select_scheme(cur_scheme_->get_scheme_name().c_str());
cur_cfg_->save();
disconnect(comb_, SIGNAL(currentTextChanged(const QString)), this, SLOT(on_current_scheme_changed()));
comb_->setCurrentIndex(index);
connect(comb_, SIGNAL(currentTextChanged(const QString)), this, SLOT(on_current_scheme_changed()));
updateRestorePushButton();
changed_count_++;
}
}
}
else if (btn == m_pbtn_Save)
{
gb::sane_config_schm* schm = cur_cfg_->get_scheme(comb_->currentText().toStdString().c_str());
updateSchemeFromUi(schm);
cur_cfg_->save();
schm->release();
updateRestorePushButton();
}
else if(btn == m_deleteCur)
{
int id = -1;
QString text(find_current_scheme_menu(&id));
if(text.isEmpty())
return;
QMessageBox msg(QMessageBox::Question, tr("be sure to delete the configuration"),
tr("Are you sure you want to delete the configuration \"") + text + tr("\" ?"), QMessageBox::Yes | QMessageBox::No, this);
msg.exec();
if (msg.clickedButton() != msg.button(QMessageBox::Yes))
return;
gb::sane_config_schm *sch = cur_cfg_->get_scheme(text.toStdString().c_str());
cur_cfg_->remove_scheme(text.toStdString().c_str());
comb_->removeItem(id);
sch->release();
if(sch == cur_scheme_)
{
restore_2_default_settings();
updateUIStatus();
}
on_current_scheme_changed();
changed_count_++;
cur_cfg_->save();
}
else if(btn == m_deleteAll)
{
QMessageBox msg(QMessageBox::Question, tr("be sure to delete the configuration"),
tr("Are you sure you want to delete the configuration?"), QMessageBox::Yes | QMessageBox::No, this);
msg.exec();
if (msg.clickedButton() != msg.button(QMessageBox::Yes))
return;
restore_2_default_settings();
updateUIStatus();
comb_->clear();
changed_count_++;
cur_cfg_->remove_all_schemes();
cur_cfg_->save();
std::vector<std::string> schemes;
cur_cfg_->get_all_schemes(schemes);
for (int i = 0; i < (int)schemes.size(); ++i)
{
comb_->addItem(QString::fromStdString(schemes[i]));
comb_->setCurrentText(QString::fromStdString(schemes[i]));
}
}
else if (btn == m_pbtn_restore)
{
bool ok = false;
cur_scheme_ = cur_cfg_->get_scheme(to_default_language(comb_->currentText().toStdString().c_str(), &ok));
hg_settingdialog::apply_scheme(m_devHandle, &m_saneAPI, cur_scheme_);
updateUIStatus();
updateRestorePushButton();
}
updateSchemeManagerUi();
}
void hg_settingdialog::restore_2_default_settings(void)
{
hg_settingdialog::apply_scheme(m_devHandle, &m_saneAPI, nullptr);
updateRestorePushButton();
}
Reference in New Issue View Git Blame Copy Permalink