644 lines
24 KiB
C++
644 lines
24 KiB
C++
#include "form_deviceconfig.h"
|
|
#include <QTabWidget>
|
|
#include <QScrollArea>
|
|
#include <QFormLayout>
|
|
#include <QHBoxLayout>
|
|
#include <QVBoxLayout>
|
|
#include <QLabel>
|
|
#include <QComboBox>
|
|
#include <QSlider>
|
|
#include <QCheckBox>
|
|
#include <QSpinBox>
|
|
#include <QSpacerItem>
|
|
#include <QPushButton>
|
|
#include <QEvent>
|
|
|
|
Form_DeviceConfig::Form_DeviceConfig(SANE_Handle devHandle, const std::vector<DeviceConfig>& deviceConfigs, QWidget *parent)
|
|
: QWidget(parent)
|
|
{
|
|
Init(devHandle);
|
|
|
|
std::vector<DeviceConfigsGroup> deviceConfigsGroups = m_baseDeviceConfigsGroups;
|
|
for (int i = 0; i < (int)deviceConfigs.size(); ++i)
|
|
{
|
|
bool set = false;
|
|
for (int m = 0; m < (int)deviceConfigsGroups.size(); ++m)
|
|
{
|
|
for (int n = 0; n < (int)deviceConfigsGroups[m].deviceConfigs.size(); ++n)
|
|
{
|
|
DeviceConfigEx &deviceConfig = deviceConfigsGroups[m].deviceConfigs[n];
|
|
if (deviceConfig.name == deviceConfigs[i].name && deviceConfig.valueType == deviceConfigs[i].valueType)
|
|
{
|
|
deviceConfig.stringValue = deviceConfigs[i].stringValue;
|
|
deviceConfig.intValue = deviceConfigs[i].intValue;
|
|
deviceConfig.doubleValue = deviceConfigs[i].doubleValue;
|
|
deviceConfig.boolValue = deviceConfigs[i].boolValue;
|
|
set = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (set)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
Update(deviceConfigsGroups);
|
|
}
|
|
|
|
Form_DeviceConfig::~Form_DeviceConfig()
|
|
{
|
|
|
|
}
|
|
|
|
std::vector<DeviceConfig> Form_DeviceConfig::GetDeviceConfigs()
|
|
{
|
|
std::vector<DeviceConfig> deviceConfigs;
|
|
|
|
for (int i = 0; i < (int)m_baseDeviceConfigsGroups.size(); ++i)
|
|
{
|
|
for (int j = 0; j < (int)m_baseDeviceConfigsGroups[i].deviceConfigs.size(); ++j)
|
|
{
|
|
const DeviceConfigEx &deviceConfig = m_baseDeviceConfigsGroups[i].deviceConfigs[j];
|
|
|
|
QWidget *ctrl = nullptr;
|
|
for (int k = 0; k < (int)m_ctrlList.size(); ++k)
|
|
{
|
|
if (deviceConfig.name == m_ctrlList[k]->property("config_name").toString().toStdString())
|
|
{
|
|
ctrl = m_ctrlList[k];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (nullptr != ctrl)
|
|
{
|
|
DeviceConfig dc;
|
|
dc.name = deviceConfig.name;
|
|
dc.valueType = deviceConfig.valueType;
|
|
|
|
if (1 == deviceConfig.rangeType)
|
|
{
|
|
assert(1 == deviceConfig.valueType);
|
|
QComboBox *comboBox = (QComboBox *)ctrl;
|
|
if (deviceConfig.stringValue != comboBox->currentText().toStdString())
|
|
{
|
|
dc.stringValue = comboBox->currentText().toStdString();
|
|
deviceConfigs.push_back(dc);
|
|
}
|
|
}
|
|
else if (2 == deviceConfig.rangeType)
|
|
{
|
|
assert(2 == deviceConfig.valueType);
|
|
QComboBox *comboBox = (QComboBox *)ctrl;
|
|
if (deviceConfig.intValue != comboBox->currentText().toInt())
|
|
{
|
|
dc.intValue = comboBox->currentText().toInt();
|
|
deviceConfigs.push_back(dc);
|
|
}
|
|
}
|
|
else if (3 == deviceConfig.rangeType)
|
|
{
|
|
assert(3 == deviceConfig.valueType);
|
|
QComboBox *comboBox = (QComboBox *)ctrl;
|
|
if (deviceConfig.doubleValue != comboBox->currentText().toDouble())
|
|
{
|
|
dc.doubleValue = comboBox->currentText().toDouble();
|
|
deviceConfigs.push_back(dc);
|
|
}
|
|
}
|
|
else if (4 == deviceConfig.rangeType)
|
|
{
|
|
assert(2 == deviceConfig.valueType);
|
|
QSlider *slider = (QSlider *)ctrl;
|
|
if (deviceConfig.intValue != slider->value())
|
|
{
|
|
dc.intValue = slider->value();
|
|
deviceConfigs.push_back(dc);
|
|
}
|
|
}
|
|
else if (5 == deviceConfig.rangeType)
|
|
{
|
|
assert(3 == deviceConfig.valueType);
|
|
QSlider *slider = (QSlider *)ctrl;
|
|
if (round(deviceConfig.doubleValue * 100) != slider->value())
|
|
{
|
|
dc.doubleValue = slider->value() / 100.0;
|
|
deviceConfigs.push_back(dc);
|
|
}
|
|
}
|
|
else if (0 == deviceConfig.rangeType)
|
|
{
|
|
if (1 == deviceConfig.valueType)
|
|
{
|
|
|
|
}
|
|
else if (2 == deviceConfig.valueType)
|
|
{
|
|
QSpinBox* spinBox = (QSpinBox *)ctrl;
|
|
if (deviceConfig.intValue != spinBox->value())
|
|
{
|
|
dc.intValue = spinBox->value();
|
|
deviceConfigs.push_back(dc);
|
|
}
|
|
}
|
|
else if (3 == deviceConfig.valueType)
|
|
{
|
|
|
|
}
|
|
else if (4 == deviceConfig.valueType)
|
|
{
|
|
QCheckBox *checkBox = (QCheckBox *)ctrl;
|
|
if (deviceConfig.boolValue != checkBox->isChecked())
|
|
{
|
|
dc.boolValue = checkBox->isChecked();
|
|
deviceConfigs.push_back(dc);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return deviceConfigs;
|
|
}
|
|
|
|
bool Form_DeviceConfig::eventFilter(QObject *target, QEvent *event)
|
|
{
|
|
if (typeid(*target) == typeid(QSlider) || typeid(*target) == typeid(QComboBox) || typeid(*target) == typeid(QSpinBox) ||
|
|
typeid(*target) == typeid(QDoubleSpinBox))
|
|
{
|
|
if (event->type() == QEvent::Wheel)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return QWidget::eventFilter(target, event);
|
|
}
|
|
|
|
void Form_DeviceConfig::Init(SANE_Handle devHandle)
|
|
{
|
|
// 1.重置设备
|
|
|
|
SANE_Int num_dev_options = 0;
|
|
sane_control_option(devHandle, 0, SANE_ACTION_GET_VALUE, &num_dev_options, NULL);
|
|
for (int i = 1; i < num_dev_options; ++i)
|
|
{
|
|
const SANE_Option_Descriptor* desp = sane_get_option_descriptor(devHandle, i);
|
|
if (NULL == desp)
|
|
continue;
|
|
|
|
const char* name = desp->name;
|
|
while (' ' == *name)
|
|
++name;
|
|
|
|
if (0 == strcmp(SANE_STD_OPT_NAME_RESTORE, name) && SANE_TYPE_BUTTON == desp->type)
|
|
{
|
|
sane_control_option(devHandle, i, SANE_ACTION_SET_VALUE, NULL, NULL);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// 2.获取基本配置
|
|
|
|
m_baseDeviceConfigsGroups.clear();
|
|
for (int i = 1; i < num_dev_options; ++i)
|
|
{
|
|
const SANE_Option_Descriptor* desp = sane_get_option_descriptor(devHandle, i);
|
|
if (NULL == desp)
|
|
continue;
|
|
|
|
const char* name = desp->name;
|
|
while (' ' == *name)
|
|
++name;
|
|
|
|
const char* title = desp->title;
|
|
while (' ' == *title)
|
|
++title;
|
|
|
|
if (SANE_TYPE_GROUP == desp->type)
|
|
{
|
|
DeviceConfigsGroup group;
|
|
group.groupTitle = title;
|
|
m_baseDeviceConfigsGroups.push_back(group);
|
|
}
|
|
else if (SANE_TYPE_STRING == desp->type)
|
|
{
|
|
char value[256] = { 0 };
|
|
sane_control_option(devHandle, i, SANE_ACTION_GET_VALUE, value, NULL);
|
|
|
|
DeviceConfigEx devConfig;
|
|
devConfig.name = name;
|
|
devConfig.title = title;
|
|
devConfig.valueType = 1;
|
|
devConfig.stringValue = value;
|
|
|
|
devConfig.rangeType = 1;
|
|
if (SANE_CONSTRAINT_STRING_LIST == desp->constraint_type)
|
|
{
|
|
const SANE_String_Const* p = desp->constraint.string_list;
|
|
while (NULL != *p)
|
|
{
|
|
devConfig.stringValueList.push_back(*p);
|
|
++p;
|
|
}
|
|
|
|
assert(!m_baseDeviceConfigsGroups.empty());
|
|
m_baseDeviceConfigsGroups[m_baseDeviceConfigsGroups.size() - 1].deviceConfigs.push_back(devConfig);
|
|
}
|
|
}
|
|
else if (SANE_TYPE_INT == desp->type)
|
|
{
|
|
SANE_Int value = 0;
|
|
sane_control_option(devHandle, i, SANE_ACTION_GET_VALUE, &value, NULL);
|
|
|
|
DeviceConfigEx devConfig;
|
|
devConfig.name = name;
|
|
devConfig.title = title;
|
|
devConfig.valueType = 2;
|
|
devConfig.intValue = (int)value;
|
|
|
|
if (SANE_CONSTRAINT_WORD_LIST == desp->constraint_type)
|
|
{
|
|
devConfig.rangeType = 2;
|
|
const SANE_Word* p = desp->constraint.word_list;
|
|
for (SANE_Int i = 0; i < p[0]; ++i)
|
|
{
|
|
devConfig.intValueList.push_back(p[i + 1]);
|
|
}
|
|
}
|
|
else if (SANE_CONSTRAINT_RANGE == desp->constraint_type)
|
|
{
|
|
devConfig.rangeType = 4;
|
|
devConfig.intValueMin = desp->constraint.range->min;
|
|
devConfig.intValueMax = desp->constraint.range->max;
|
|
}
|
|
|
|
assert(!m_baseDeviceConfigsGroups.empty());
|
|
m_baseDeviceConfigsGroups[m_baseDeviceConfigsGroups.size() - 1].deviceConfigs.push_back(devConfig);
|
|
}
|
|
else if (SANE_TYPE_FIXED == desp->type)
|
|
{
|
|
SANE_Word value = 0;
|
|
sane_control_option(devHandle, i, SANE_ACTION_GET_VALUE, &value, NULL);
|
|
|
|
DeviceConfigEx devConfig;
|
|
devConfig.name = name;
|
|
devConfig.title = title;
|
|
devConfig.valueType = 3;
|
|
devConfig.doubleValue = SANE_UNFIX(value);
|
|
|
|
if (SANE_CONSTRAINT_WORD_LIST == desp->constraint_type)
|
|
{
|
|
devConfig.rangeType = 3;
|
|
const SANE_Word* p = desp->constraint.word_list;
|
|
for (SANE_Int i = 0; i < p[0]; ++i)
|
|
{
|
|
devConfig.doubleValueList.push_back(SANE_UNFIX(p[i + 1]));
|
|
}
|
|
}
|
|
else if (SANE_CONSTRAINT_RANGE == desp->constraint_type)
|
|
{
|
|
devConfig.rangeType = 5;
|
|
devConfig.doubleValueMin = SANE_UNFIX(desp->constraint.range->min);
|
|
devConfig.doubleValueMax = SANE_UNFIX(desp->constraint.range->max);
|
|
}
|
|
|
|
assert(!m_baseDeviceConfigsGroups.empty());
|
|
m_baseDeviceConfigsGroups[m_baseDeviceConfigsGroups.size() - 1].deviceConfigs.push_back(devConfig);
|
|
}
|
|
else if (SANE_TYPE_BOOL == desp->type)
|
|
{
|
|
SANE_Bool value = 0;
|
|
sane_control_option(devHandle, i, SANE_ACTION_GET_VALUE, &value, NULL);
|
|
|
|
DeviceConfigEx devConfig;
|
|
devConfig.name = name;
|
|
devConfig.title = title;
|
|
devConfig.valueType = 4;
|
|
devConfig.boolValue = (bool)value;
|
|
|
|
assert(!m_baseDeviceConfigsGroups.empty());
|
|
m_baseDeviceConfigsGroups[m_baseDeviceConfigsGroups.size() - 1].deviceConfigs.push_back(devConfig);
|
|
}
|
|
}
|
|
|
|
// 3.创建UI
|
|
|
|
QPushButton *defaultBtn = new QPushButton(tr("Default"));
|
|
connect(defaultBtn, &QPushButton::clicked, this, &Form_DeviceConfig::on_defaultBtn_clicked);
|
|
QHBoxLayout *hLayout = new QHBoxLayout;
|
|
hLayout->addSpacerItem(new QSpacerItem(20, 20, QSizePolicy::Expanding));
|
|
hLayout->addWidget(defaultBtn);
|
|
QTabWidget *tabWidget = new QTabWidget(this);
|
|
tabWidget->setTabPosition(QTabWidget::North);
|
|
QVBoxLayout *mainLayout = new QVBoxLayout(this);
|
|
mainLayout->addLayout(hLayout);
|
|
mainLayout->addWidget(tabWidget);
|
|
this->setLayout(mainLayout);
|
|
|
|
for (int i = 0; i < (int)m_baseDeviceConfigsGroups.size(); ++i)
|
|
{
|
|
QWidget *widget = new QWidget;
|
|
QFormLayout* layout = new QFormLayout;
|
|
widget->setLayout(layout);
|
|
|
|
QScrollArea* scrollArea = new QScrollArea(this);
|
|
scrollArea->setWidgetResizable(true);
|
|
scrollArea->setAlignment(Qt::AlignCenter);
|
|
scrollArea->setWindowTitle(QString::fromStdString(m_baseDeviceConfigsGroups[i].groupTitle));
|
|
scrollArea->setWidget(widget);
|
|
|
|
for (int j = 0; j < (int)m_baseDeviceConfigsGroups[i].deviceConfigs.size(); ++j)
|
|
{
|
|
const DeviceConfigEx &deviceConfig = m_baseDeviceConfigsGroups[i].deviceConfigs[j];
|
|
|
|
// 创建Label
|
|
QLabel *label = new QLabel;
|
|
label->setText(QString::fromStdString(deviceConfig.title) + QString(" : "));
|
|
|
|
// 创建控件
|
|
QWidget *ctrl = nullptr;
|
|
QWidget *ctrlWidget = nullptr;
|
|
|
|
if (1 == deviceConfig.rangeType)
|
|
{
|
|
assert(1 == deviceConfig.valueType);
|
|
QComboBox *comboBox = new QComboBox;
|
|
for (int k = 0; k < (int)deviceConfig.stringValueList.size(); ++k)
|
|
comboBox->addItem(QString::fromStdString(deviceConfig.stringValueList[k]));
|
|
//comboBox->setCurrentText(QString::fromStdString(deviceConfig.stringValue));
|
|
comboBox->installEventFilter(this);
|
|
ctrl = comboBox;
|
|
ctrlWidget = comboBox;
|
|
}
|
|
else if (2 == deviceConfig.rangeType)
|
|
{
|
|
assert(2 == deviceConfig.valueType);
|
|
QComboBox *comboBox = new QComboBox;
|
|
for (int k = 0; k < (int)deviceConfig.intValueList.size(); ++k)
|
|
comboBox->addItem(QString::number(deviceConfig.intValueList[k]));
|
|
//comboBox->setCurrentText(QString::number(deviceConfig.intValue));
|
|
comboBox->installEventFilter(this);
|
|
ctrl = comboBox;
|
|
ctrlWidget = comboBox;
|
|
}
|
|
else if (3 == deviceConfig.rangeType)
|
|
{
|
|
assert(3 == deviceConfig.valueType);
|
|
QComboBox *comboBox = new QComboBox;
|
|
for (int k = 0; k < (int)deviceConfig.doubleValueList.size(); ++k)
|
|
comboBox->addItem(QString::number(deviceConfig.doubleValueList[k]));
|
|
//comboBox->setCurrentText(QString::number(deviceConfig.doubleValue));
|
|
comboBox->installEventFilter(this);
|
|
ctrl = comboBox;
|
|
ctrlWidget = comboBox;
|
|
}
|
|
else if (4 == deviceConfig.rangeType)
|
|
{
|
|
assert(2 == deviceConfig.valueType);
|
|
QSlider *slider = new QSlider;
|
|
slider->setOrientation(Qt::Horizontal);
|
|
slider->setRange(deviceConfig.intValueMin, deviceConfig.intValueMax);
|
|
//slider->setValue(deviceConfig.intValue);
|
|
slider->installEventFilter(this);
|
|
connect(slider, SIGNAL(valueChanged(int)), this, SLOT(on_sliderClicked(int)));
|
|
|
|
QSpinBox* spinBox = new QSpinBox;
|
|
spinBox->setMinimumWidth(75);
|
|
spinBox->setMaximumWidth(75);
|
|
spinBox->setRange(deviceConfig.intValueMin, deviceConfig.intValueMax);
|
|
spinBox->setProperty("config_name", QString::fromStdString(deviceConfig.name));
|
|
spinBox->installEventFilter(this);
|
|
connect(spinBox, SIGNAL(valueChanged(int)), this, SLOT(on_spinBoxClicked(int)));
|
|
|
|
ctrl = slider;
|
|
QHBoxLayout* hLayout = new QHBoxLayout;
|
|
hLayout->addWidget(ctrl);
|
|
hLayout->addWidget(spinBox);
|
|
QWidget* sliderSpinWidget = new QWidget(scrollArea);
|
|
sliderSpinWidget->setLayout(hLayout);
|
|
ctrlWidget = sliderSpinWidget;
|
|
}
|
|
else if (5 == deviceConfig.rangeType)
|
|
{
|
|
assert(3 == deviceConfig.valueType);
|
|
QSlider *slider = new QSlider;
|
|
slider->setOrientation(Qt::Horizontal);
|
|
slider->setRange(round(deviceConfig.doubleValueMin * 100), round(deviceConfig.doubleValueMax * 100));
|
|
//slider->setValue(round(deviceConfig.doubleValue * 100));
|
|
slider->installEventFilter(this);
|
|
connect(slider, SIGNAL(valueChanged(int)), this, SLOT(on_sliderClicked(int)));
|
|
|
|
QDoubleSpinBox* doubleSpinBox = new QDoubleSpinBox;
|
|
doubleSpinBox->setMinimumWidth(75);
|
|
doubleSpinBox->setMaximumWidth(75);
|
|
doubleSpinBox->setRange(round(deviceConfig.doubleValueMin * 100), round(deviceConfig.doubleValueMax * 100));
|
|
doubleSpinBox->setDecimals(2);
|
|
doubleSpinBox->setSingleStep(0.01);
|
|
doubleSpinBox->setProperty("config_name", QString::fromStdString(deviceConfig.name));
|
|
doubleSpinBox->installEventFilter(this);
|
|
connect(doubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(on_doubleSpinboxClicked(double)));
|
|
|
|
ctrl = slider;
|
|
QHBoxLayout* hLayout = new QHBoxLayout;
|
|
hLayout->addWidget(ctrl);
|
|
hLayout->addWidget(doubleSpinBox);
|
|
QWidget* sliderSpinWidget = new QWidget(scrollArea);
|
|
sliderSpinWidget->setLayout(hLayout);
|
|
ctrlWidget = sliderSpinWidget;
|
|
}
|
|
else if (0 == deviceConfig.rangeType)
|
|
{
|
|
if (1 == deviceConfig.valueType)
|
|
{
|
|
|
|
}
|
|
else if (2 == deviceConfig.valueType)
|
|
{
|
|
QSpinBox* spinBox = new QSpinBox;
|
|
spinBox->setMinimumWidth(75);
|
|
spinBox->setMaximumWidth(75);
|
|
spinBox->setRange(-1, 1000);
|
|
//spinBox->setValue(deviceConfig.intValue);
|
|
spinBox->installEventFilter(this);
|
|
ctrl = spinBox;
|
|
ctrlWidget = spinBox;
|
|
}
|
|
else if (3 == deviceConfig.valueType)
|
|
{
|
|
|
|
}
|
|
else if (4 == deviceConfig.valueType)
|
|
{
|
|
QCheckBox *checkBox = new QCheckBox;
|
|
//checkBox->setChecked(deviceConfig.boolValue);
|
|
ctrl = checkBox;
|
|
ctrlWidget = checkBox;
|
|
}
|
|
}
|
|
|
|
if (nullptr != ctrl)
|
|
{
|
|
ctrl->setProperty("config_name", QString::fromStdString(deviceConfig.name));
|
|
m_ctrlList.push_back(ctrl);
|
|
}
|
|
|
|
if (nullptr != ctrlWidget)
|
|
{
|
|
layout->addRow(label, ctrlWidget);
|
|
}
|
|
}
|
|
|
|
tabWidget->addTab(scrollArea, QString::fromStdString(m_baseDeviceConfigsGroups[i].groupTitle));
|
|
}
|
|
}
|
|
|
|
void Form_DeviceConfig::Update(std::vector<DeviceConfigsGroup> &deviceConfigsGroups)
|
|
{
|
|
for (int i = 0; i < (int)deviceConfigsGroups.size(); ++i)
|
|
{
|
|
for (int j = 0; j < (int)deviceConfigsGroups[i].deviceConfigs.size(); ++j)
|
|
{
|
|
const DeviceConfigEx &deviceConfig = deviceConfigsGroups[i].deviceConfigs[j];
|
|
|
|
QWidget *ctrl = nullptr;
|
|
for (int k = 0; k < (int)m_ctrlList.size(); ++k)
|
|
{
|
|
if (deviceConfig.name == m_ctrlList[k]->property("config_name").toString().toStdString())
|
|
{
|
|
ctrl = m_ctrlList[k];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (nullptr != ctrl)
|
|
{
|
|
if (1 == deviceConfig.rangeType)
|
|
{
|
|
assert(1 == deviceConfig.valueType);
|
|
QComboBox *comboBox = (QComboBox *)ctrl;
|
|
comboBox->setCurrentText(QString::fromStdString(deviceConfig.stringValue));
|
|
}
|
|
else if (2 == deviceConfig.rangeType)
|
|
{
|
|
assert(2 == deviceConfig.valueType);
|
|
QComboBox *comboBox = (QComboBox *)ctrl;
|
|
comboBox->setCurrentText(QString::number(deviceConfig.intValue));
|
|
}
|
|
else if (3 == deviceConfig.rangeType)
|
|
{
|
|
assert(3 == deviceConfig.valueType);
|
|
QComboBox *comboBox = (QComboBox *)ctrl;
|
|
comboBox->setCurrentText(QString::number(deviceConfig.doubleValue));
|
|
}
|
|
else if (4 == deviceConfig.rangeType)
|
|
{
|
|
assert(2 == deviceConfig.valueType);
|
|
QSlider *slider = (QSlider *)ctrl;
|
|
slider->setValue(deviceConfig.intValue);
|
|
}
|
|
else if (5 == deviceConfig.rangeType)
|
|
{
|
|
assert(3 == deviceConfig.valueType);
|
|
QSlider *slider = (QSlider *)ctrl;
|
|
slider->setValue(round(deviceConfig.doubleValue * 100));
|
|
}
|
|
else if (0 == deviceConfig.rangeType)
|
|
{
|
|
if (1 == deviceConfig.valueType)
|
|
{
|
|
|
|
}
|
|
else if (2 == deviceConfig.valueType)
|
|
{
|
|
QSpinBox* spinBox = (QSpinBox *)ctrl;
|
|
spinBox->setValue(deviceConfig.intValue);
|
|
}
|
|
else if (3 == deviceConfig.valueType)
|
|
{
|
|
|
|
}
|
|
else if (4 == deviceConfig.valueType)
|
|
{
|
|
QCheckBox *checkBox = (QCheckBox *)ctrl;
|
|
checkBox->setChecked(deviceConfig.boolValue);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Form_DeviceConfig::on_defaultBtn_clicked()
|
|
{
|
|
Update(m_baseDeviceConfigsGroups);
|
|
}
|
|
|
|
void Form_DeviceConfig::on_sliderClicked(int value)
|
|
{
|
|
QSlider *slider = qobject_cast<QSlider*>(sender());
|
|
QString sliderProverty = slider->property("config_name").toString();
|
|
|
|
QList<QAbstractSpinBox*> buttons = this->findChildren<QAbstractSpinBox*>();
|
|
foreach(QAbstractSpinBox* abstractSpinBox, buttons)
|
|
{
|
|
QString spinBoxProverty = abstractSpinBox->property("config_name").toString();
|
|
if (spinBoxProverty == sliderProverty)
|
|
{
|
|
if (typeid(*abstractSpinBox) == typeid(QSpinBox))
|
|
{
|
|
QSpinBox* spinBox = reinterpret_cast<QSpinBox*>(abstractSpinBox);
|
|
spinBox->setValue(value);
|
|
}
|
|
else
|
|
{
|
|
QDoubleSpinBox* doubleSpinBox = reinterpret_cast<QDoubleSpinBox*>(abstractSpinBox);
|
|
double temp = value * doubleSpinBox->singleStep();
|
|
doubleSpinBox->setValue(temp);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void Form_DeviceConfig::on_spinBoxClicked(int value)
|
|
{
|
|
QSpinBox* spinBox = qobject_cast<QSpinBox*>(sender());
|
|
QString spinBoxProverty = spinBox->property("config_name").toString();
|
|
|
|
QList<QSlider*> buttons = this->findChildren<QSlider*>();
|
|
foreach(QSlider* slider, buttons)
|
|
{
|
|
QString sliderProverty = slider->property("config_name").toString();
|
|
if (sliderProverty == spinBoxProverty)
|
|
{
|
|
slider->setValue(value);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Form_DeviceConfig::on_doubleSpinboxClicked(double value)
|
|
{
|
|
QDoubleSpinBox* spinBox = qobject_cast<QDoubleSpinBox*>(sender());
|
|
QString spinBoxProverty = spinBox->property("config_name").toString();
|
|
|
|
QList<QSlider*> buttons = this->findChildren<QSlider*>();
|
|
foreach(QSlider* slider, buttons)
|
|
{
|
|
QString sliderProverty = slider->property("config_name").toString();
|
|
if (sliderProverty == spinBoxProverty)
|
|
{
|
|
int temp = value / spinBox->singleStep() + 0.5;
|
|
slider->setValue(temp);
|
|
break;
|
|
}
|
|
}
|
|
}
|