code_app/modules/twainui/hg_settingdialog.cpp

#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();
    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");
#else
    //setWindowTitle(QString::fromStdString(dev_que_.opened_scanner_name()));
    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 = 100;
    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_colorModeValue = 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;
        }
    }

    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_colorModeValue = 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);

    if (0 == strcmp(opt->name, SANE_STD_OPT_NAME_TEXT_DIRECTION))
    {
        if (comboBox->currentText() == 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 (comboBox->currentText() == 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;

    CutPaperTool dlg(m_dpiValue, m_paperSizeValue, 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()
{
    int colorMode = 0; // 0-彩色, 1-灰度
    if (m_colorModeValue.toStdString() == OPTION_VALUE_YSMS_256JHD
            || m_colorModeValue.toStdString() == OPTION_VALUE_YSMS_HB || m_colorModeValue.toStdString() == 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));
    }

    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;

    QMessageBox msg(QMessageBox::NoIcon, title,
                    content, QMessageBox::Ok, this);
    msg.setStyleSheet("QLabel{""min-width: 280px;""}");
    msg.exec();
}

void hg_settingdialog::slot_buttonScanClicked()
{
    //save_scheme();
    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)
{
    //if(e->type() == QEvent::Close)  // consider as cancel ...
    //{
    //    //if(save_)
    //    //    save_scheme();
    //    //else
    //    //    cancel_setting();
    //}

    //HGChar cfgPath[512];
    //GetConfigPath(cfgPath, 512);
    //QString oldFile = QString::fromStdString(cfgPath) + "olddefault.ini";
    //QString newFile = QString::fromStdString(cfgPath) + "default.ini";


    // 配置方案策略更改后的业务保存逻辑：
    // 
    //  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);
}

bool hg_settingdialog::createMsgBoxUi(bool add, std::string &name)
{
    QString text(tr("Please select to overwrite the original configuration:"));
    text += QString::fromStdString(name);
    text += tr(",or add a new configuration");

    QDialog *dlg = new QDialog(this);
    dlg->setWindowTitle(tr("save the configuration"));
    QLabel *label_question = new QLabel;
    label_question->setText(text);

    QRadioButton *radioButtonCover = new QRadioButton;
    radioButtonCover->setText(tr("cover original configuration:") + QString::fromStdString(name));
    radioButtonCover->setChecked(true);
    add = false;
    QRadioButton *radioButtonNew = new QRadioButton;
    radioButtonNew->setText(tr("add new configuration"));

    QHBoxLayout *hLayoutName = new QHBoxLayout;
    QLabel *label_name = new QLabel;
    label_name->setText(tr("rename:"));
    m_lineEdit_name = new QLineEdit;
    std::string name2;
    m_lineEdit_name->setText(QString::fromStdString(getCurUiShemeName(name2)));

    QSpacerItem *spacer1 = new QSpacerItem(20, 20, QSizePolicy::Expanding);
    hLayoutName->addWidget(label_name);
    hLayoutName->addWidget(m_lineEdit_name);
    hLayoutName->addSpacerItem(spacer1);
    label_name->setVisible(false);
    m_lineEdit_name->setVisible(false);

    bool cover = true;
    connect(radioButtonCover, &QRadioButton::clicked, this, [=, &add, &cover](){
        cover = true;
        add = false;
        label_name->setVisible(false);
        m_lineEdit_name->setVisible(false);
    });
    connect(radioButtonNew, &QRadioButton::clicked, this, [=, &add, &cover](){
        cover = false;
        add = true;
        label_name->setVisible(true);
        m_lineEdit_name->setVisible(true);

        m_lineEdit_name->setFocus();
                QTimer::singleShot(0, m_lineEdit_name, &QLineEdit::selectAll);
    });

    QSpacerItem *spacer2 = new QSpacerItem(20, 20, QSizePolicy::Expanding);
    QPushButton *pbtnOk = new QPushButton;
    pbtnOk->setText(tr("ok"));
    connect(pbtnOk, &QPushButton::clicked, this, [=, &name, &cover](){

        QString text = m_lineEdit_name->text();
        static QRegularExpression re("\\s");
            text.remove(re);//Remove space

        name = text.toStdString();

        if(name.empty())
        {
            QMessageBox::information(this, tr("tips"), tr("scheme name cannot be empty"));
            m_lineEdit_name->setText(QString::fromStdString(getCurUiShemeName(name)));
            return;
        }

        if (!cover)
        {
            std::vector<std::string> now;
            cur_cfg_->get_all_schemes(now);
            for(auto& v: now)
            {
                if(v == name)
                {

                    QMessageBox::information(this, tr("tips"), tr("scheme name: ") + QString::fromStdString(name) + tr(" already exists"));
                    m_lineEdit_name->setText(QString::fromStdString(getCurUiShemeName(name)));
                    return;
                }
            }
        }

        dlg->close();
    });

    QHBoxLayout *hLayout_pbtnOk = new QHBoxLayout;
    hLayout_pbtnOk->addSpacerItem(spacer2);
    hLayout_pbtnOk->addWidget(pbtnOk);

    QVBoxLayout *vLayout = new QVBoxLayout;
    vLayout->addWidget(label_question);
    vLayout->addWidget(radioButtonCover);
    vLayout->addWidget(radioButtonNew);
    vLayout->addLayout(hLayoutName);
    vLayout->addLayout(hLayout_pbtnOk);
    dlg->setLayout(vLayout);

    dlg->exec();

    return add;
}

std::string hg_settingdialog::getCurUiShemeName(std::string name)
{
    std::string k(""), val("");
    int         id = 0;
    const SANE_Option_Descriptor* opt = nullptr;

    if (cur_scheme_->first_config(k, val))
    {
        int count = 0;
        do
        {
            id = cur_scheme_->id_from_name(k.c_str());
            opt = id == -1 ? nullptr : m_saneAPI.sane_get_option_descriptor_api(m_devHandle, id);
            if (opt)
            {
                if (count++)
                    name += " + ";

                if (opt->type == SANE_TYPE_STRING)
                    name += from_default_language(val.c_str(), nullptr);
                else
                {
                    name += opt->title;
                    if (opt->type == SANE_TYPE_BOOL)
                    {
                        name += std::string("(");
                        if (*(SANE_Bool*)&val[0] == SANE_TRUE)
                            name += "true)";
                        else
                            name += "false)";
                    }
                    else if (opt->type == SANE_TYPE_INT)
                    {
                        char buf[128] = { 0 };
                        sprintf(buf, "(%d)", *(int*)&val[0]);
                        name += buf;
                    }
                    else if (opt->type == SANE_TYPE_FIXED)
                    {
                        char buf[128] = { 0 };
                        sprintf(buf, "(%.4f)", SANE_UNFIX(*(SANE_Fixed*)&val[0]));
                        name += buf;
                    }
                }
            }
        } while (count < 3 && cur_scheme_->next_config(k, val));
    }
    return name;
}

void hg_settingdialog::save_scheme(void)
{
    if (comb_->currentIndex() == 0)
        return;

    this->cur_scheme_ = this->cur_cfg_->get_scheme(comb_->currentText().toStdString().c_str());
    cur_scheme_->end_setting(true);
    cur_scheme_->begin_setting();
    updateSchemeFromUi();
    cur_scheme_->end_setting(false);
    cur_cfg_->save();
    cur_cfg_->select_scheme(cur_scheme_->get_scheme_name().c_str());
}
void hg_settingdialog::cancel_setting(void)
{
    // restore changed value ...
    cur_scheme_->end_setting(true);
    //dev_que::apply_scheme(&m_saneAPI, m_devHandle, cur_scheme_);
}

std::string hg_settingdialog::getAppVersion()
{
    char v[256] = {0};
    m_saneAPI.sane_control_option_api(m_devHandle, (SANE_Int)0x884A, SANE_ACTION_GET_VALUE, v, NULL);
    return v;
}
void hg_settingdialog::apply_current_scheme(void)
{
    dev_que::apply_scheme(&m_saneAPI, m_devHandle, cur_scheme_);
}

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"));
#endif
}

void hg_settingdialog::applyDeviceScheme()
{
    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*> ctrls = find_control(id);

        if (ctrls.empty())
            continue;

        const SANE_Option_Descriptor* opt = (const SANE_Option_Descriptor*)m_list_defaultOptions.at(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)
                {
                    SANE_Bool value = false;
                    SANE_Int method = 0;

                    m_saneAPI.sane_control_option_api(m_devHandle, id, SANE_ACTION_GET_VALUE, &value, &method);
                    disconnect(cb, SIGNAL(stateChanged(int)), this, SLOT(slot_checkedClicked()));
                    cb->setCheckState(value ? Qt::Checked : Qt::Unchecked);
                    if (strcmp(opt->name, SANE_STD_OPT_NAME_IS_CUSTOM_GAMMA) == 0 && btn_gamma_ != nullptr)
                    {
                        btn_gamma_->setEnabled(value);
                    }
                    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)
            { 
                QSlider* slider = qobject_cast<QSlider*>(ctrls[i]);
                if (slider)
                {
                    SANE_Int value = 0;
                    SANE_Int method = 0;
                    disconnect(slider, SIGNAL(valueChanged(int)), this, SLOT(slot_sliderClicked(int)));
                    m_saneAPI.sane_control_option_api(m_devHandle, id, SANE_ACTION_GET_VALUE, &value, &method);
                    slider->setValue(value);
                    connect(slider, SIGNAL(valueChanged(int)), this, SLOT(slot_sliderClicked(int)));
                }
                else
                {
                    QSpinBox* spin = qobject_cast<QSpinBox*>(ctrls[i]);
                    if (spin)
                    {
                        SANE_Int value = 0;
                        SANE_Int method = 0;
                        disconnect(spin, SIGNAL(valueChanged(int)), this, SLOT(slot_spinBoxClicked(int)));
                        m_saneAPI.sane_control_option_api(m_devHandle, id, SANE_ACTION_GET_VALUE, &value, &method);
                        spin->setValue(value);
                        connect(spin, SIGNAL(valueChanged(int)), this, SLOT(slot_spinBoxClicked(int)));
                    }
                }
            }
        }
        else if (opt->type == SANE_TYPE_FIXED)
        {
            QSlider* slider = NULL;
            QDoubleSpinBox* spin = NULL;
            for (size_t i = 0; i < (size_t)ctrls.size(); ++i)
            {
                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)
            {
                SANE_Fixed value = 0;
                SANE_Int  method = 0;
                m_saneAPI.sane_control_option_api(m_devHandle, id, SANE_ACTION_GET_VALUE, &value, &method);
                double value2 = SANE_UNFIX(value);
                slider->setValue(value2 * 100);
                connect(slider, SIGNAL(valueChanged(int)), this, SLOT(slot_sliderClicked(int)));
            }

            if (spin)
            {
                SANE_Fixed value = 0;
                SANE_Int  method = 0;
                m_saneAPI.sane_control_option_api(m_devHandle, id, SANE_ACTION_GET_VALUE, &value, &method);
                double value2 = SANE_UNFIX(value);
                spin->setValue(value2);
                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)
                {
                    char* value = (char*)malloc(opt->size * 2 + 4);
                    SANE_Int method = 0;
                    disconnect(comb, SIGNAL(currentTextChanged(const QString)), this, SLOT(slot_string_list_comboBoxClicked()));
                    m_saneAPI.sane_control_option_api(m_devHandle, id, SANE_ACTION_GET_VALUE, value, &method);
                    QString value2 = QString(value);
                    comb->setCurrentText(QString(value2));
                    connect(comb, SIGNAL(currentTextChanged(const QString)), this, SLOT(slot_string_list_comboBoxClicked()));
                    free(value);
                }
                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(id - 1).second.toString());
                        connect(edit, SIGNAL(textChanged(const QString&)), this, SLOT(slot_lineEditInput()));
                    }
                }
            }
        }
    }
}

void hg_settingdialog::updateDefaultScheme()
{
    update_opt_value_from_driver();

    m_isRefreshUi = true;
    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*> ctrls = find_control(id);

        if(ctrls.empty())
            continue;

        const SANE_Option_Descriptor* opt = (const SANE_Option_Descriptor*)m_list_defaultOptions.at(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()));

                    if (comb_->currentIndex() == 0)
                    {
                        if (searchKeyName("default", opt->name))
                        {
                            bool check = getDefaultCfgValue("default", opt->name, false);
                            cb->setCheckState(check ? Qt::Checked : Qt::Unchecked);
                            if (strcmp(opt->name, SANE_STD_OPT_NAME_IS_CUSTOM_GAMMA) == 0 && btn_gamma_ != nullptr)
                            {
                                btn_gamma_->setEnabled(check);
                            }
                        }
                    }
                    //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)
            {
                QSlider* slider = qobject_cast<QSlider*>(ctrls[i]);
                if(slider)
                {
                    //disconnect(slider, SIGNAL(valueChanged(int)), this, SLOT(slot_sliderClicked(int)));

                    if (comb_->currentIndex() == 0)
                    {
                        if (searchKeyName("default", opt->name))
                        {
                            int value = getDefaultCfgValue("default", opt->name, 0);
                            slider->setValue(value);
                        }
                    }
                    //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)));

                        if (comb_->currentIndex() == 0)
                        {
                            if (searchKeyName("default", opt->name))
                            {
                                int value = getDefaultCfgValue("default", opt->name, 0);
                                spin->setValue(value);
                            }
                        }
                        //connect(spin, SIGNAL(valueChanged(int)), this, SLOT(slot_spinBoxClicked(int)));
                    }
                }
            }
        }
        else if(opt->type == SANE_TYPE_FIXED)
        {
            QSlider *slider = NULL;
            QDoubleSpinBox* spin = NULL;
            for(size_t i = 0; i < (size_t)ctrls.size(); ++i)
            {
                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)
            {
                if (comb_->currentIndex() == 0)
                {
                    if (searchKeyName("default", opt->name))
                    {
                        float value = getDefaultCfgValue("default", opt->name, QString("")).toFloat();
                        slider->setValue(value * 100);
                    }
                    //connect(slider, SIGNAL(valueChanged(int)), this, SLOT(slot_sliderClicked(int)));
                }

                if (spin)
                {
                    if (comb_->currentIndex() == 0)
                    {
                        if (searchKeyName("default", opt->name))
                        {
                            float value = getDefaultCfgValue("default", opt->name, QString("")).toFloat();
                            spin->setValue(value);
                        }
                        //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()));

                    if (comb_->currentIndex() == 0)
                    {
                        if (searchKeyName("default", opt->name))
                        {
                            QString value = getDefaultCfgValue("default", opt->name, QString(""));
                            comb->setCurrentText(value);
                        }
                        //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(id - 1).second.toString());
                            //connect(edit, SIGNAL(textChanged(const QString&)), this, SLOT(slot_lineEditInput()));
                        }
                    }
                }
            }
        }
        if (comb_->currentIndex() == 0)
        {
            if (0 == strcmp(opt->name, SANE_STD_OPT_NAME_CUSTOM_AREA_LEFT) && searchKeyName("default", "cutLeftvalue"))
            {
                double value = getDefaultCfgValue("default", "cutLeftvalue", QString("")).toDouble();
                m_cutLeftValue = value;
            }
            if (0 == strcmp(opt->name, SANE_STD_OPT_NAME_CUSTOM_AREA_LEFT) && searchKeyName("default", "cutLeftvalue"))
            {
                double value = getDefaultCfgValue("default", "cutTopValue", QString("")).toDouble();
                m_cutTopValue = value;
            }
            if (0 == strcmp(opt->name, SANE_STD_OPT_NAME_CUSTOM_AREA_RIGHT) && searchKeyName("default", "cutLeftvalue"))
            {
                double value = getDefaultCfgValue("default", "cutRightvalue", QString("")).toDouble();
                m_cutRightValue = value;
            }
            if (0 == strcmp(opt->name, SANE_STD_OPT_NAME_CUSTOM_AREA_LEFT) && searchKeyName("default", "cutLeftvalue"))
            {
                double value = getDefaultCfgValue("default", "cutBottomvalue", QString("")).toDouble();
                m_cutBottomValue = value;
            }
            if (0 == strcmp(opt->name, SANE_STD_OPT_NAME_IS_CUSTOM_GAMMA) && searchKeyName("default", "curves"))
            {
                QString value = getDefaultCfgValue("default", "curves", QString(""));
                if (!value.isEmpty())
                {
                    HGSize length = 0;
                    std::string base64Data = value.toStdString();
                    HGBase_Base64Decode((const HGByte*)base64Data.c_str(), base64Data.size(), NULL, &length);

                    if (length == sizeof(SANE_Gamma))
                    {
                        HGBase_Base64Decode((const HGByte*)base64Data.c_str(), base64Data.size(), (HGByte*)&m_gammaData, &length);
                    }
                }
            }
        }
    }
}

void hg_settingdialog::saveOriginDeviceScheme()
{
    m_list_originDeviceScheme.clear();

    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_originDeviceScheme.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_originDeviceScheme.append(QPair<const void*, QVariant>(opt, QVariant(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_originDeviceScheme.append(QPair<const void*, QVariant>(opt, QVariant(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_originDeviceScheme.append(QPair<const void*, QVariant>(opt, QVariant(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);
                m_list_originDeviceScheme.append(QPair<const void*, QVariant>(opt, QVariant(QString::fromStdString(init))));

                free(init);
            }
            else
            {
                m_list_originDeviceScheme.append(QPair<const void*, QVariant>(opt, QVariant(0)));
            }
        }
    }
}

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::restoreDeviceScheme()
{
    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; i < dev_options; ++i)
    {
        const SANE_Option_Descriptor* opt = m_saneAPI.sane_get_option_descriptor_api(m_devHandle, i);
        if (!opt)
            continue;

        if (0 == strcmp(SANE_STD_OPT_NAME_RESTORE, opt->name))
        {
            m_saneAPI.sane_control_option_api(m_devHandle, i, SANE_ACTION_SET_VALUE, NULL, NULL);
            break;
        }
    }
}

void hg_settingdialog::processIniFile()
{
    HGChar cfgPath[512];
    GetConfigPath(cfgPath, 512);
    QString oldFile = QString::fromStdString(cfgPath) + "olddefault.ini";
    QString newFile = QString::fromStdString(cfgPath) + "default.ini";

    QFile::remove(oldFile);
    QFile::copy(newFile, oldFile);
}

void hg_settingdialog::initGammaData()
{
    QString value = getDefaultCfgValue("default", "curves", QString(""));
    if (!value.isEmpty())
    {
        HGSize length = 0;
        std::string base64Data = value.toStdString();
        HGBase_Base64Decode((const HGByte*)base64Data.c_str(), base64Data.size(), NULL, &length);

        if (length == sizeof(SANE_Gamma))
        {
            HGBase_Base64Decode((const HGByte*)base64Data.c_str(), base64Data.size(), (HGByte*)&m_gammaData, &length);
        }
    }
}

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();
    cfgScheme = cur_cfg_->get_scheme(comb_->currentText().toStdString().c_str());

    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();

    //if (comb_->currentIndex() == 0)
    //{
    //    restoreDeviceScheme();
    //    applyDeviceScheme();
    //
    //    HGChar cfgPath[512];
    //    GetConfigPath(cfgPath, 512);
    //    QString oldFile = QString::fromStdString(cfgPath) + "olddefault.ini";
    //    QString newFile = QString::fromStdString(cfgPath) + "default.ini";
    //    QFile::remove(newFile);
    //    QFile file(oldFile);
    //    file.rename(newFile);
    //    QFile::copy(newFile, oldFile);
    //
    //    updateDefaultScheme();
    //
    //    return;
    //}
    //
    //QString text(find_current_scheme_menu());
    //gb::sane_config_schm *cur = nullptr;
    //
    //cur_cfg_->select_scheme(text.toStdString().c_str());
    //cur = cur_cfg_->get_scheme();
    //if(!cur)
    //    cur = new gb::sane_config_schm();
    //cur->copy_default_value(cur_scheme_);
    //cur_scheme_->end_setting(true);
    //cur_scheme_->release();
    //cur_scheme_ = cur;
    //cur_scheme_->begin_setting();
    //
    //apply_current_scheme();
    //updateUIStatus();
    //changed_count_++;
    //
    //QString    scheme(comb_->currentText());
    //bool enabled = false;
    //gb::sane_config_schm    *schm = cur_cfg_->get_scheme(scheme.toStdString().c_str());
    //
    //if(schm)
    //    enabled = true;
    //
    //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;
    //
    //QString info(tr(""));
    //std::string name(""), val("");
    //if(schm && schm->first_config(name, val))
    //{
    //    do
    //    {
    //        QString title;
    //        SANE_Value_Type type = SANE_TYPE_STRING;
    //        for (int ii = 0; ii < m_list_defaultOptions.size(); ii++)
    //        {
    //            const SANE_Option_Descriptor* opt = reinterpret_cast<const SANE_Option_Descriptor*>(m_list_defaultOptions.at(ii).first);
    //            if(strcmp(opt->name, name.c_str()) == 0)
    //            {
    //                title = QString::fromStdString(opt->title);
    //                type = opt->type;
    //                if(type == SANE_TYPE_STRING)
    //                    val = from_default_language(val.c_str(), nullptr);
    //                break;
    //            }
    //        }
    //
    //        if(title.length())
    //        {
    //            info += tr("<h6><b>") + title + tr(":</b></h6>");
    //            info += tr("<p>    ") + QString::fromStdString(sane_val_to_string(val.c_str(), type)) + tr("</p>");
    //        }
    //        else {
    //            if(val.length() == sizeof(SANE_Gamma))
    //                memcpy(&m_gammaData, val.c_str(), sizeof(SANE_Gamma));
    //        }
    //    }while(schm->next_config(name, val));
    //}
    //if(schm)
    //    schm->release();
    //
    //sketch_->setHtml(info);
}
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();
        //if (comb_->currentIndex() == 0)
        //    processIniFile();
        //else
        //    save_scheme();
    }
    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)
    {
        cur_scheme_ = cur_cfg_->get_scheme(comb_->currentText().toStdString().c_str());
        hg_settingdialog::apply_scheme(m_devHandle, &m_saneAPI, cur_scheme_);
        updateUIStatus();
        updateRestorePushButton();
    }

    updateSchemeManagerUi();
}
void hg_settingdialog::restore_2_default_settings(void)
{
        //cur_scheme_->end_setting(true);
        //->select_scheme(nullptr);
        //dev_que_.apply_scheme(&m_saneAPI, nullptr);
        //cur_cfg_->save();

    hg_settingdialog::apply_scheme(m_devHandle, &m_saneAPI, nullptr);
    updateRestorePushButton();
        //gb::sane_config_schm *s = new gb::sane_config_schm();
        //s->copy_default_value(cur_scheme_);
        //cur_scheme_->release();
        //cur_scheme_ = s;
        //cur_scheme_->begin_setting();
}