wheeldetect/tpvs17/tpMain/QSystemSettingDlg.cpp

#include "QSystemSettingDlg.h"
#include <QDir>
#include <QObject>
#include "QCheckBox"
#include "QLabel"
#include "QSpinBox"
#include "DetectState.h"
#include "QFileDialog"
#include "QMessageBox"
#include "qshowimg.h"
#include <QDesktopServices>
#include "InfoFile.h"



#define DEVELOP_UI_CHECK_SAVE_GOOD			"SaveGoodcheckBox"
#define DEVELOP_UI_CHECK_SAVE_BAD			"SaveBadcheckBox"
#define DEVELOP_UI_CHECK_SAVE_CUTGOOD		"SaveCutGoodcheckBox"
#define DEVELOP_UI_CHECK_SAVE_CUTBAD		"SaveCutBadcheckBox"
#define DEVELOP_UI_CHECK_CHKBOXALL2A		"chkBoxAll2A"
#pragma execution_character_set("utf-8")
const QString DEVELOP_DETECT_CAMERE_VIRSUAL = QObject::tr("虚拟相机触发");
const QString DEVELOP_DETECT_CAMERE_TRUE = QObject::tr("硬件相机触发");
const QString DEVELOP_DETECT_DEBUG_NOUSER = QObject::tr("调试免登陆");
const QString DEVELOP_DETECT_DEBUG_USER = QObject::tr("正常工作模式");

const QString DEVELOP_DETECT_CAM_OUTTRIGER = QObject::tr("传感器触发");
const QString DEVELOP_DETECT_CAM_SOFTER = QObject::tr("软件触发");

const QString DEVELOP_PLC_TRIGER_DOWM = QObject::tr("下降沿触发");
const QString DEVELOP_PLC_TRIGER_UP = QObject::tr("上升沿触发");

QSystemSettingDlg::QSystemSettingDlg(QWidget *parent)
	: QWidget(parent)
{
	ui.setupUi(this);
	setWindowIcon(QIcon(":/image/leaper"));
	m_setting = new QSettings(".\\user\\systemfile.ini", QSettings::IniFormat);
	readSettingFile();
	m_listwidgetItemStr.append(tr("相关设备配置"));
	m_listwidgetItemStr.append(tr("检测图像设置"));
	m_listwidgetItemStr.append(tr("PLC相关设置"));
	m_listwidgetItemStr.append(tr("报警灯测试"));
	m_listwidgetItemStr.append(tr("高级功能"));
	{
		InitTreeWidget(ui.treeWidget);
		addComRoot(ui.treeWidget, m_listwidgetItemStr.at(0));//相关设备配置
		addPicRoot(ui.treeWidget, m_listwidgetItemStr.at(1));//检测图像设置
		addPLCRoot(ui.treeWidget, m_listwidgetItemStr.at(2));//PLC相关设置
		addLightRoot(ui.treeWidget, m_listwidgetItemStr.at(3));//报警灯测试
		ui.treeWidget->expandAll();
		addSuperRoot(ui.treeWidget, m_listwidgetItemStr.at(4));//高级功能
	}

	{
		ui.listWidget->clear();
		ui.listWidget->addItems(m_listwidgetItemStr);
		for (int nIndex = 0; nIndex < ui.listWidget->count(); nIndex++)
		{
			QListWidgetItem *itenn = ui.listWidget->item(nIndex);
			itenn->setBackgroundColor(QColor(0, 50, 50, 100));
			QSize s = itenn->sizeHint();
			itenn->setSizeHint(QSize(s.width(), 30));
		}
		connect(ui.listWidget, SIGNAL(currentRowChanged(int)), this, SLOT(onSetCurrentIndex(int)));
	}
	ui.label->setVisible(false);
}

QSystemSettingDlg::~QSystemSettingDlg()
{
	for (int nIndex = 0; nIndex < developitems.size(); nIndex++) {
		QTreeWidgetItem* pItem = developitems.at(nIndex);
		delete pItem;
		pItem = NULL;
	}
	for (int nIndex = 0; nIndex < comitems.size(); nIndex++) {
		QTreeWidgetItem* pItem = comitems.at(nIndex);
		delete pItem;
		pItem = NULL;
	}
	for (int nIndex = 0; nIndex < camitems.size(); nIndex++) {
		QTreeWidgetItem* pItem = camitems.at(nIndex);
		delete pItem;
		pItem = NULL;
	}
	for (int nIndex = 0; nIndex < picitems.size(); nIndex++) {
		QTreeWidgetItem* pItem = picitems.at(nIndex);
		delete pItem;
		pItem = NULL;
	}
	for (int nIndex = 0; nIndex < PLCitems.size(); nIndex++) {
		QTreeWidgetItem* pItem = PLCitems.at(nIndex);
		delete pItem;
		pItem = NULL;
	}
	for (int nIndex = 0; nIndex < lightitems.size(); nIndex++) {
		QTreeWidgetItem* pItem = lightitems.at(nIndex);
		delete pItem;
		pItem = NULL;
	}	
// 	for (QMap<QString, class QTreeWidgetItem *>::iterator its = m_TreeItemMap.begin(); its != m_TreeItemMap.end(); ++its)
// 	{
// 		delete *its;
// 		*its = NULL;
// 	}
	m_TreeItemMap.clear();
	for (int nIndex = 0; nIndex < m_listObj.size(); nIndex++) {
		QObject* p = m_listObj.at(nIndex);
		delete p;
		p = NULL;
	}

	if (pDiskCleanThread) {
		pDiskCleanThread->ExitThread();
		pDiskCleanThread->quit();
		pDiskCleanThread->wait(50);
		delete pDiskCleanThread;
		pDiskCleanThread = NULL;
	}
	if (m_setting) {
		delete m_setting;
		m_setting = NULL;
	}
}

void QSystemSettingDlg::onShowWidget(int nLevel)
{
	if (nLevel == 9 || DetectState::instance()->m_Debug == 100) {

		HidPLCUI(false);
		HidDevelopUI(false);
	}
	else if (nLevel == 5) {

		HidDevelopUI(true);
		HidPLCUI(true);
	}
	else if (nLevel == 4) {
		ui.treeWidget->setItemHidden(picitems.at(7), true);
		HidDevelopUI(true);
		HidPLCUI(true);
	}
	else {
		HidDevelopUI(true);
		HidPLCUI(true);
	}
	ui.listWidget->setCurrentRow(0);
}

bool QSystemSettingDlg::InitTreeWidget(QTreeWidget* pTreewidget)
{
	if (pTreewidget == NULL)
		return false;
	QStringList header;
	header.append(tr("属性"));
	header.append(tr("值"));
	pTreewidget->setHeaderLabels(header);
	pTreewidget->header()->setStretchLastSection(true);
	pTreewidget->setColumnCount(2);
	pTreewidget->setStyleSheet("QTreeView::item:hover{background-color:rgb(0,255,0,50)}"
		"QTreeView::item:selected{background-color:rgb(67,101,234,100)}");
	//pTreewidget->setSelectionModel(QAbstractItemView::ExtendedSelection);
	pTreewidget->setColumnWidth(0, 180);
	return true;
}

void QSystemSettingDlg::addComRoot(class QTreeWidget *pTreewidget, QString strName /*= QString()*/)
{
	QTreeWidgetItem *pLanguage = new QTreeWidgetItem(pTreewidget, QStringList(tr("语言")));
	m_Language = new QComboBox;
	pTreewidget->setItemWidget(pLanguage, 1, m_Language);
	m_TreeItemMap.insert("language", pLanguage);

	m_Language->setObjectName("m_Language");
	QString strpath = QCoreApplication::applicationDirPath() + "/language/";
	QStringList strList = getDirNames(strpath);
	if (strList.size() <= 0)
		strList << "Chinese";
	m_Language->addItems(strList);
	QSettings languageSetting("hubdetect.ini", QSettings::IniFormat);
	QString strLangeage = languageSetting.value("language", "Chinese").toString();
	m_Language->setCurrentText(strLangeage);
	connect(m_Language, SIGNAL(currentTextChanged(const QString &)), this, SLOT(oncurrentChanged(const QString &)));
	m_listObj.append(m_Language);
}

QStringList QSystemSettingDlg::getDirNames(QString strPath)
{
	QStringList strDirNames;
	QDir dir(strPath);
	if (!dir.exists())
	{
		return strDirNames;
	}
	dir.setFilter(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot);
	dir.setSorting(QDir::DirsFirst);	// 文件夹优先
	// 转换成一个List
	QFileInfoList list = dir.entryInfoList();
	if (list.size() < 1)
	{
		return strDirNames;
	}
	int i = 0;
	do
	{
		QFileInfo fileInfo = list.at(i);
		QString tt = fileInfo.fileName();
		// 如果是文件夹
		bool bisDir = fileInfo.isDir();
		if (bisDir)
		{
			strDirNames.append(fileInfo.fileName());
		}
		i++;
	} while (i < list.size());
	return strDirNames;
}

void QSystemSettingDlg::addPicRoot(QTreeWidget *pTreewidget, QString strName)
{
	QTreeWidgetItem *m_RootItems = new QTreeWidgetItem(pTreewidget, QStringList(tr("检测图像设置")));
	m_TreeItemMap.insert(strName, m_RootItems);
	m_RootItems->setSizeHint(1, QSize(100, 30));
	picitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("抠图后"))));
	picitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("抠图后"))));
	picitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("原图"))));
	picitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("原图"))));
	picitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("检测结果"))));
	picitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("图像保存路径"))));
	picitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("设置保存路径"))));
	picitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("打开图像路径"))));
	picitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("保存当前设置"))));
	m_RootItems->addChildren(picitems);
	QCheckBox *m_saveImgRes_good = new QCheckBox;
	m_saveImgRes_good->setText(tr("保存已匹配图"));
	m_saveImgRes_good->setObjectName("m_saveImgRes_good");
	connect(m_saveImgRes_good, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_saveImgRes_good->setChecked(DetectState::instance()->saveCutGood == (int)true);

	QCheckBox *m_saveImgRes_bad = new QCheckBox;
	m_saveImgRes_bad->setText(tr("保存无匹配图"));
	m_saveImgRes_bad->setObjectName("m_saveImgRes_bad");
	connect(m_saveImgRes_bad, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_saveImgRes_bad->setChecked(DetectState::instance()->saveCutBad == (int)true);

	QCheckBox *m_saveImgSrc_good = new QCheckBox;
	m_saveImgSrc_good->setText(tr("保存已匹配图"));
	m_saveImgSrc_good->setObjectName("m_saveImgSrc_good");
	connect(m_saveImgSrc_good, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_saveImgSrc_good->setChecked(DetectState::instance()->saveGood == (int)true);

	QCheckBox *m_saveImgSrc_bad = new QCheckBox;
	m_saveImgSrc_bad->setText(tr("保存无匹配图"));
	m_saveImgSrc_bad->setObjectName("m_saveImgSrc_bad");
	connect(m_saveImgSrc_bad, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_saveImgSrc_bad->setChecked(DetectState::instance()->saveBad == (int)true);

	QCheckBox *m_ResAll2A = new QCheckBox;
	m_ResAll2A->setText(tr("轮毂全去A通道"));
	m_ResAll2A->setObjectName("m_ResAll2A");
	connect(m_ResAll2A, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_ResAll2A->setChecked(DetectState::instance()->m_bObjAll2A == (int)true);

	m_pLbShowPath = new QLabel;
	m_pLbShowPath->setText(DetectState::instance()->m_SaveImgDirPath);

	QPushButton *pbSetSavePath = new QPushButton(tr("设置保存路径"));
	pbSetSavePath->setObjectName("pbSetSavePath");
	connect(pbSetSavePath, SIGNAL(clicked()), this, SLOT(onOpenDataPath()));

	QPushButton *pbOpenImgPath = new QPushButton(tr("打开图像路径"));
	pbOpenImgPath->setObjectName("pbOpenImgPath");
	connect(pbOpenImgPath, SIGNAL(clicked()), this, SLOT(onOpenDataPath()));

	QPushButton* pSavePara = new QPushButton(tr("保存参数"));
	pSavePara->setObjectName("pSavePara");
	connect(pSavePara, SIGNAL(clicked()), this, SLOT(onTreeWidgetButton()));

	pTreewidget->setItemWidget(picitems.at(0), 1, m_saveImgRes_good);
	pTreewidget->setItemWidget(picitems.at(1), 1, m_saveImgRes_bad);
	pTreewidget->setItemWidget(picitems.at(2), 1, m_saveImgSrc_good);
	pTreewidget->setItemWidget(picitems.at(3), 1, m_saveImgSrc_bad);
	pTreewidget->setItemWidget(picitems.at(4), 1, m_ResAll2A);
	pTreewidget->setItemWidget(picitems.at(5), 1, m_pLbShowPath);
	pTreewidget->setItemWidget(picitems.at(6), 1, pbSetSavePath);
	pTreewidget->setItemWidget(picitems.at(7), 1, pbOpenImgPath);
	pTreewidget->setItemWidget(picitems.at(8), 1, pSavePara);

	m_listObj.append(m_saveImgRes_bad);
	m_listObj.append(m_saveImgRes_good);
	m_listObj.append(m_saveImgSrc_bad);
	m_listObj.append(m_saveImgSrc_good);
	m_listObj.append(m_ResAll2A);
	m_listObj.append(m_pLbShowPath);
	m_listObj.append(pbSetSavePath);
	m_listObj.append(pbOpenImgPath);
	m_listObj.append(pSavePara);

	picitems.at(0)->setSizeHint(1, QSize(100, 40));
	picitems.at(1)->setSizeHint(1, QSize(100, 30));
	picitems.at(2)->setSizeHint(1, QSize(100, 30));
	picitems.at(3)->setSizeHint(1, QSize(100, 30));
	picitems.at(4)->setSizeHint(1, QSize(100, 30));
	picitems.at(5)->setSizeHint(1, QSize(100, 30));
	picitems.at(6)->setSizeHint(1, QSize(100, 40));
	picitems.at(7)->setSizeHint(1, QSize(100, 40));
	picitems.at(8)->setSizeHint(1, QSize(100, 40));
}

void QSystemSettingDlg::addPLCRoot(QTreeWidget *pTreewidget, QString strName)
{
	QTreeWidgetItem *m_PLCItems = new QTreeWidgetItem(pTreewidget, QStringList(tr("PLC相关设置")));
	m_TreeItemMap.insert(strName, m_PLCItems);
	m_PLCItems->setSizeHint(1, QSize(100, 30));
	PLCitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("保存设置"))));
	PLCitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("传感器触发滤波(ms)"))));
	PLCitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("相机触发延时(ms)"))));
	PLCitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("相机触发脉宽(ms)"))));
	PLCitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("光源熄灭延时时间(ms)"))));
	PLCitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("传感器触发类型"))));
	PLCitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("保持结果时长(ms)"))));
	PLCitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("连接超时次数"))));
	PLCitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("超时是否显示信息"))));
	PLCitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("是否自动重启服务器"))));
	PLCitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("是否保存超时日志"))));
	m_PLCItems->addChildren(PLCitems);
	QPushButton *savePLCpara = new QPushButton(tr("发送并保存"));
	m_PLCTrigerFilter = new QSpinBox();
	m_PLCTrigerFilter->setMinimum(1);
	m_PLCTrigerFilter->setMaximum(65536);
	m_PLCTrigerFilter->setValue(DetectState::instance()->m_PLC_TrigerFilter);
	m_PLCCameraDelay = new QSpinBox();
	m_PLCCameraDelay->setMinimum(1);
	m_PLCCameraDelay->setMaximum(65536);
	m_PLCCameraDelay->setValue(DetectState::instance()->m_PLC_CamTrigDelay);
	m_PLCCameraPulse = new QSpinBox();
	m_PLCCameraPulse->setMinimum(1);
	m_PLCCameraPulse->setMaximum(65536);
	m_PLCCameraPulse->setValue(DetectState::instance()->m_PLC_CamTrigPulse);
	m_PLCLightDelay = new QSpinBox();
	m_PLCLightDelay->setMinimum(1);
	m_PLCLightDelay->setMaximum(65536);
	m_PLCLightDelay->setValue(DetectState::instance()->m_PLC_LightDelay);
	m_PLCResHoldTime = new QSpinBox();
	m_PLCResHoldTime->setMinimum(1);
	m_PLCResHoldTime->setMaximum(65536);
	m_PLCResHoldTime->setValue(DetectState::instance()->m_PLC_ResHoldTime);

	m_PLCTrigerType = new QComboBox();
	QStringList strList;
	strList.append(DEVELOP_PLC_TRIGER_DOWM);
	strList.append(DEVELOP_PLC_TRIGER_UP);
	m_PLCTrigerType->addItems(strList);
	if (DetectState::instance()->m_PLC_TrigerType == 0)
		m_PLCTrigerType->setCurrentText(DEVELOP_PLC_TRIGER_DOWM);
	else
		m_PLCTrigerType->setCurrentText(DEVELOP_PLC_TRIGER_UP);

	savePLCpara->setObjectName("savePLCpara");
	connect(savePLCpara, SIGNAL(clicked()), this, SLOT(onSavePLCPara()));

	m_PLC_RestartSeverCount = new QSpinBox();
	m_PLC_RestartSeverCount->setMinimum(1);
	m_PLC_RestartSeverCount->setMaximum(65536);
	m_PLC_RestartSeverCount->setToolTip(tr("超时提醒n次后自动重启服务"));
	m_PLC_RestartSeverCount->setValue(DetectState::instance()->m_PLC_RestartSeverCount);

	QCheckBox *m_PLC_ShowTimerOutMsg = new QCheckBox;
	m_PLC_ShowTimerOutMsg->setText(tr("是否显示提示"));
	m_PLC_ShowTimerOutMsg->setText(tr("勾选后通信超时时会显示提醒信息"));
	m_PLC_ShowTimerOutMsg->setObjectName("m_PLC_ShowTimerOutMsg");
	connect(m_PLC_ShowTimerOutMsg, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_PLC_ShowTimerOutMsg->setChecked(DetectState::instance()->m_PLC_ShowTimerOutMsg == (int)true);

	QCheckBox *m_PLC_IsResServer = new QCheckBox;
	m_PLC_IsResServer->setText(tr("是否自动重启服务器"));
	m_PLC_IsResServer->setToolTip(tr("勾选后通信超时次数达到后，系统将自动重启服务，PLC会自动重新连接"));
	m_PLC_IsResServer->setObjectName("m_PLC_IsResServer");
	connect(m_PLC_IsResServer, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_PLC_IsResServer->setChecked(DetectState::instance()->m_PLC_IsResServer == (int)true);

	QCheckBox *m_PLC_SaveMsgInLog = new QCheckBox;
	m_PLC_SaveMsgInLog->setText(tr("保存信息到系统日志"));
	m_PLC_SaveMsgInLog->setToolTip(tr("勾选后表示超时信息将自动保存到系统日志中，便于查询"));
	m_PLC_SaveMsgInLog->setObjectName("m_PLC_SaveMsgInLog");
	connect(m_PLC_SaveMsgInLog, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_PLC_SaveMsgInLog->setChecked(DetectState::instance()->m_PLC_SaveMsgInLog == (int)true);

	PLCitems.at(0)->setSizeHint(1, QSize(100, 40));
	PLCitems.at(1)->setSizeHint(1, QSize(100, 40));
	PLCitems.at(2)->setSizeHint(1, QSize(100, 40));
	PLCitems.at(3)->setSizeHint(1, QSize(100, 40));
	PLCitems.at(4)->setSizeHint(1, QSize(100, 40));
	PLCitems.at(5)->setSizeHint(1, QSize(100, 40));
	PLCitems.at(6)->setSizeHint(1, QSize(100, 40));
	PLCitems.at(7)->setSizeHint(1, QSize(100, 40));
	PLCitems.at(8)->setSizeHint(1, QSize(100, 40));
	PLCitems.at(9)->setSizeHint(1, QSize(100, 40));
	PLCitems.at(10)->setSizeHint(1, QSize(100, 40));
	pTreewidget->setItemWidget(PLCitems.at(0), 1, savePLCpara);
	pTreewidget->setItemWidget(PLCitems.at(1), 1, m_PLCTrigerFilter);
	pTreewidget->setItemWidget(PLCitems.at(2), 1, m_PLCCameraDelay);
	pTreewidget->setItemWidget(PLCitems.at(3), 1, m_PLCCameraPulse);
	pTreewidget->setItemWidget(PLCitems.at(4), 1, m_PLCLightDelay);
	pTreewidget->setItemWidget(PLCitems.at(5), 1, m_PLCTrigerType);
	pTreewidget->setItemWidget(PLCitems.at(6), 1, m_PLCResHoldTime);
	pTreewidget->setItemWidget(PLCitems.at(7), 1, m_PLC_RestartSeverCount);
	pTreewidget->setItemWidget(PLCitems.at(8), 1, m_PLC_ShowTimerOutMsg);
	pTreewidget->setItemWidget(PLCitems.at(9), 1, m_PLC_IsResServer);
	pTreewidget->setItemWidget(PLCitems.at(10), 1, m_PLC_SaveMsgInLog);
	m_listObj.append(savePLCpara);
	m_listObj.append(m_PLCTrigerFilter);
	m_listObj.append(m_PLCCameraDelay);
	m_listObj.append(m_PLCCameraPulse);
	m_listObj.append(m_PLCLightDelay);
	m_listObj.append(m_PLCTrigerType);
	m_listObj.append(m_PLC_RestartSeverCount);
	m_listObj.append(m_PLC_ShowTimerOutMsg);
	m_listObj.append(m_PLC_IsResServer);
	m_listObj.append(m_PLC_SaveMsgInLog);
	m_listObj.append(m_PLCResHoldTime);
}
void QSystemSettingDlg::addLightRoot(QTreeWidget *pTreewidget, QString strName)
{
	QTreeWidgetItem *m_LightItems = new QTreeWidgetItem(pTreewidget, QStringList(tr("报警灯测试")));
	m_TreeItemMap.insert(strName, m_LightItems);
	m_LightItems->setSizeHint(1, QSize(100, 30));
	lightitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("红灯"))));
	lightitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("绿灯"))));
	lightitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("黄灯"))));
	lightitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("蜂鸣"))));
	m_LightItems->addChildren(lightitems);
	QPushButton *redLight = new QPushButton(tr("红灯闪一下"));
	QPushButton *grenLight = new QPushButton(tr("绿灯闪一下"));
	QPushButton *yellLight = new QPushButton(tr("黄灯闪一下"));
	QPushButton *beeLight = new QPushButton(tr("蜂鸣响一下"));
	redLight->setObjectName("redLight");
	grenLight->setObjectName("grenLight");
	yellLight->setObjectName("yellLight");
	beeLight->setObjectName("beeLight");
	connect(redLight, SIGNAL(clicked()), this, SLOT(onLightTest()));
	connect(grenLight, SIGNAL(clicked()), this, SLOT(onLightTest()));
	connect(yellLight, SIGNAL(clicked()), this, SLOT(onLightTest()));
	connect(beeLight, SIGNAL(clicked()), this, SLOT(onLightTest()));

	lightitems.at(0)->setSizeHint(1, QSize(100, 40));
	lightitems.at(1)->setSizeHint(1, QSize(100, 40));
	lightitems.at(2)->setSizeHint(1, QSize(100, 40));
	lightitems.at(3)->setSizeHint(1, QSize(100, 40));
	pTreewidget->setItemWidget(lightitems.at(0), 1, redLight);
	pTreewidget->setItemWidget(lightitems.at(1), 1, grenLight);
	pTreewidget->setItemWidget(lightitems.at(2), 1, yellLight);
	pTreewidget->setItemWidget(lightitems.at(3), 1, beeLight);
	m_listObj.append(redLight);
	m_listObj.append(grenLight);
	m_listObj.append(yellLight);
	m_listObj.append(beeLight);
}

void QSystemSettingDlg::addSuperRoot(class QTreeWidget *pTreewidget, QString strName)
{
	QTreeWidgetItem *m_DevelopItems = new QTreeWidgetItem(pTreewidget, QStringList(tr("开发者使用")));
	m_TreeItemMap.insert(strName, m_DevelopItems);
	m_DevelopItems->setSizeHint(1, QSize(100, 30));

	developitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("保存设置"))));
	developitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("相机模式"))));
	developitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("虚拟相机触发时间"))));
	developitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("系统模式"))));
	developitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("相机触发模式"))));
	developitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("串口发送心跳包"))));
	developitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("网络发送心跳包"))));
	developitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("串口发送通道结果"))));
	developitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("网络发送检测结果"))));
	developitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("网络发送通道结果"))));
	developitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("光栅使用标志"))));
	developitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("保存高度厚度数据"))));
	developitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("通道分配"))));
	developitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("启动时是否检测"))));
	developitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("显示厚度数据"))));
	developitems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(tr("显示厚度采样数据"))));
	m_DevelopItems->addChildren(developitems);

	m_pCameraTrgType = new QComboBox();
	QStringList m_strList;
	m_strList.append(QString(DEVELOP_DETECT_CAMERE_VIRSUAL));
	m_strList.append(QString(DEVELOP_DETECT_CAMERE_TRUE));
	m_pCameraTrgType->addItems(m_strList);
	m_pCameraTrgTimes = new QSpinBox();
	m_pCameraTrgTimes->setMaximum(99999);
	m_pDebugModel = new QComboBox();
	QStringList debug_strlist;
	debug_strlist.append(QString(DEVELOP_DETECT_DEBUG_NOUSER));
	debug_strlist.append(QString(DEVELOP_DETECT_DEBUG_USER));
	m_pDebugModel->addItems(debug_strlist);
	m_pSystype = new QComboBox();
	QStringList sysStrList;
	sysStrList.append(QString(DEVELOP_DETECT_CAM_OUTTRIGER));
	sysStrList.append(QString(DEVELOP_DETECT_CAM_SOFTER));
	m_pSystype->addItems(sysStrList);

	QCheckBox *m_AutoSendTick2COM = new QCheckBox;
	m_AutoSendTick2COM->setText(tr("串口发送心跳包"));
	m_AutoSendTick2COM->setObjectName("m_AutoSendTick2COM");
	connect(m_AutoSendTick2COM, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_AutoSendTick2COM->setChecked(DetectState::instance()->m_AutoSendTick2COM == (int)true);

	QCheckBox *m_AutoSendTick2Net = new QCheckBox;
	m_AutoSendTick2Net->setText(tr("网络发送心跳包"));
	m_AutoSendTick2Net->setObjectName("m_AutoSendTick2Net");
	connect(m_AutoSendTick2Net, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_AutoSendTick2Net->setChecked(DetectState::instance()->m_AutoSendTick2Net == (int)true);

	QCheckBox *m_SendChannelRes2COM = new QCheckBox;
	m_SendChannelRes2COM->setText(tr("串口发送通道结果"));
	m_SendChannelRes2COM->setObjectName("m_SendChannelRes2COM");
	connect(m_SendChannelRes2COM, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_SendChannelRes2COM->setChecked(DetectState::instance()->m_SendChannelRes2COM == (int)true);

	QCheckBox *m_SendDetectStr2Net = new QCheckBox;
	m_SendDetectStr2Net->setText(tr("网络发送检测结果"));
	m_SendDetectStr2Net->setObjectName("m_SendDetectStr2Net");
	connect(m_SendDetectStr2Net, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_SendDetectStr2Net->setChecked(DetectState::instance()->m_SendDetectStr2Net == (int)true);

	QCheckBox *m_SendChannelRes2Net = new QCheckBox;
	m_SendChannelRes2Net->setText(tr("网络发送通道结果"));
	m_SendChannelRes2Net->setObjectName("m_SendChannelRes2Net");
	connect(m_SendChannelRes2Net, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_SendChannelRes2Net->setChecked(DetectState::instance()->m_SendChannelRes2Net == (int)true);

	QCheckBox *m_UseRaster = new QCheckBox;
	m_UseRaster->setText(tr("使用光栅获取厚度"));
	m_UseRaster->setObjectName("m_UseRaster");
	connect(m_UseRaster, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_UseRaster->setChecked(DetectState::instance()->m_IsUseRaster == 1);

	QCheckBox *m_SaveD2HCsv = new QCheckBox;
	m_SaveD2HCsv->setText(tr("保存数据用于测试"));
	m_SaveD2HCsv->setObjectName("m_SaveD2HCsv");
	connect(m_SaveD2HCsv, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_SaveD2HCsv->setChecked(DetectState::instance()->m_SaveD2HCsv == 1);

	QCheckBox *m_IsUseChannel = new QCheckBox;
	m_IsUseChannel->setText(tr("是否使用通道分配"));
	m_IsUseChannel->setObjectName("m_IsUseChannel");
	connect(m_IsUseChannel, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_IsUseChannel->setChecked(DetectState::instance()->m_IsUseChannel == 1);

	QCheckBox *m_StartAndDetect = new QCheckBox;
	m_StartAndDetect->setText(tr("是否启动就开始检测"));
	m_StartAndDetect->setObjectName("m_StartAndDetect");
	connect(m_StartAndDetect, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_StartAndDetect->setChecked(DetectState::instance()->m_StartAndDetect == 1);

	QCheckBox *m_showThressValue = new QCheckBox;
	m_showThressValue->setText(tr("是否显示"));
	m_showThressValue->setObjectName("m_showThressValue");
	connect(m_showThressValue, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_showThressValue->setChecked(DetectState::instance()->m_showThressValue == 1);

	QCheckBox *m_showThressList = new QCheckBox;
	m_showThressList->setText(tr("是否显示"));
	m_showThressList->setObjectName("m_showThressList");
	connect(m_showThressList, SIGNAL(stateChanged(int)), this, SLOT(onCheckstateChanged(int)));
	m_showThressList->setChecked(DetectState::instance()->m_showThressList == 1);

	QPushButton *m_DebugSave = new QPushButton(tr("保存"));
	m_DebugSave->setObjectName("m_DebugSave");
	connect(m_DebugSave, SIGNAL(clicked()), this, SLOT(onTreeWidgetButton()));

	pTreewidget->setItemWidget(developitems.at(0), 1, m_DebugSave);
	pTreewidget->setItemWidget(developitems.at(1), 1, m_pCameraTrgType);
	pTreewidget->setItemWidget(developitems.at(2), 1, m_pCameraTrgTimes);
	pTreewidget->setItemWidget(developitems.at(3), 1, m_pDebugModel);
	pTreewidget->setItemWidget(developitems.at(4), 1, m_pSystype);
	pTreewidget->setItemWidget(developitems.at(5), 1, m_AutoSendTick2COM);
	pTreewidget->setItemWidget(developitems.at(6), 1, m_AutoSendTick2Net);
	pTreewidget->setItemWidget(developitems.at(7), 1, m_SendChannelRes2COM);
	pTreewidget->setItemWidget(developitems.at(8), 1, m_SendDetectStr2Net);
	pTreewidget->setItemWidget(developitems.at(9), 1, m_SendChannelRes2Net);
	pTreewidget->setItemWidget(developitems.at(10), 1, m_UseRaster);
	pTreewidget->setItemWidget(developitems.at(11), 1, m_SaveD2HCsv);
	pTreewidget->setItemWidget(developitems.at(12), 1, m_IsUseChannel);
	pTreewidget->setItemWidget(developitems.at(13), 1, m_StartAndDetect);
	pTreewidget->setItemWidget(developitems.at(14), 1, m_showThressValue);
	pTreewidget->setItemWidget(developitems.at(15), 1, m_showThressList);

	m_listObj.append(m_DebugSave);
	m_listObj.append(m_pCameraTrgType);
	m_listObj.append(m_pCameraTrgTimes);
	m_listObj.append(m_pDebugModel);
	m_listObj.append(m_pSystype);
	m_listObj.append(m_AutoSendTick2COM);
	m_listObj.append(m_AutoSendTick2Net);
	m_listObj.append(m_SendChannelRes2COM);
	m_listObj.append(m_SendDetectStr2Net);
	m_listObj.append(m_SendChannelRes2Net);
	m_listObj.append(m_UseRaster);
	m_listObj.append(m_SaveD2HCsv);
	m_listObj.append(m_IsUseChannel);
	m_listObj.append(m_StartAndDetect);
	m_listObj.append(m_showThressValue);
	m_listObj.append(m_showThressList);

	developitems.at(0)->setSizeHint(1, QSize(100, 30));
	developitems.at(1)->setSizeHint(1, QSize(100, 30));
	developitems.at(2)->setSizeHint(1, QSize(100, 30));
	developitems.at(3)->setSizeHint(1, QSize(100, 30));
	developitems.at(4)->setSizeHint(1, QSize(100, 30));
	developitems.at(5)->setSizeHint(1, QSize(100, 30));
	developitems.at(6)->setSizeHint(1, QSize(100, 30));
	developitems.at(7)->setSizeHint(1, QSize(100, 30));
	developitems.at(8)->setSizeHint(1, QSize(100, 30));
	developitems.at(9)->setSizeHint(1, QSize(100, 30));
	developitems.at(10)->setSizeHint(1, QSize(100, 30));
	developitems.at(11)->setSizeHint(1, QSize(100, 30));
	developitems.at(12)->setSizeHint(1, QSize(100, 30));
	developitems.at(13)->setSizeHint(1, QSize(100, 30));
	developitems.at(14)->setSizeHint(1, QSize(100, 30));
	developitems.at(15)->setSizeHint(1, QSize(100, 30));
	InitDebugTree();
}

void QSystemSettingDlg::HidPLCUI(bool nflag)
{
	ui.treeWidget->setItemHidden(PLCitems.at(7), nflag);
	ui.treeWidget->setItemHidden(PLCitems.at(8), nflag);
	ui.treeWidget->setItemHidden(PLCitems.at(9), nflag);
	ui.treeWidget->setItemHidden(PLCitems.at(10), nflag);
}

void QSystemSettingDlg::HidDevelopUI(bool nflag)
{
	ui.treeWidget->setItemHidden(developitems.at(0), nflag);
	ui.treeWidget->setItemHidden(developitems.at(1), nflag);
	ui.treeWidget->setItemHidden(developitems.at(2), nflag);
	ui.treeWidget->setItemHidden(developitems.at(3), nflag);
	ui.treeWidget->setItemHidden(developitems.at(4), nflag);
	ui.treeWidget->setItemHidden(developitems.at(5), nflag);
	ui.treeWidget->setItemHidden(developitems.at(6), nflag);
	ui.treeWidget->setItemHidden(developitems.at(7), nflag);
	ui.treeWidget->setItemHidden(developitems.at(8), nflag);
	ui.treeWidget->setItemHidden(developitems.at(9), nflag);
	ui.treeWidget->setItemHidden(developitems.at(10), nflag);
	ui.treeWidget->setItemHidden(developitems.at(11), nflag);
	ui.treeWidget->setItemHidden(developitems.at(12), nflag);
	ui.treeWidget->setItemHidden(developitems.at(13), nflag);
	ui.treeWidget->setItemHidden(developitems.at(14), nflag);
	ui.treeWidget->setItemHidden(developitems.at(15), nflag);
}

void QSystemSettingDlg::InitDebugTree(void)
{
	if (m_pCameraTrgType)
	{
		if (DetectState::instance()->m_Virtual_Camera == 1)
			m_pCameraTrgType->setCurrentText(DEVELOP_DETECT_CAMERE_VIRSUAL);
		else
			m_pCameraTrgType->setCurrentText(DEVELOP_DETECT_CAMERE_TRUE);
	}
	if (m_pCameraTrgTimes)
		m_pCameraTrgTimes->setValue(DetectState::instance()->m_Visural_Time);
	if (m_pDebugModel)
	{
		if (DetectState::instance()->m_Debug == 100)
			m_pDebugModel->setCurrentText(DEVELOP_DETECT_DEBUG_NOUSER);
		else
			m_pDebugModel->setCurrentText(DEVELOP_DETECT_DEBUG_USER);
	}
	if (m_pSystype)
	{
		if (DetectState::instance()->m_CameraTrigeType == 1)
			m_pSystype->setCurrentText(DEVELOP_DETECT_CAM_OUTTRIGER);
		else
			m_pSystype->setCurrentText(DEVELOP_DETECT_CAM_SOFTER);
	}
}

Q_SLOT void QSystemSettingDlg::onCheckstateChanged(int state)
{
	QString strObj = sender()->objectName();
	if (strObj == "m_saveImgRes_good") {
		DetectState::instance()->saveCutGood = int(state == 2);
	}
	else if (strObj == "m_saveImgRes_bad") {
		DetectState::instance()->saveCutBad = int(state == 2);
	}
	else if (strObj == "m_saveImgSrc_good") {
		DetectState::instance()->saveGood = int(state == 2);
	}
	else if (strObj == "m_saveImgSrc_bad") {
		DetectState::instance()->saveBad = int(state == 2);
	}
// 	else if (strObj == "m_useBackground") {
// 		DetectState::instance()->m_UseBackground = int(state == 2);
// 	}
// 	else if (strObj == "m_bEqual") {
// 		DetectState::instance()->m_bUseEqual = int(state == 2);
// 	}
// 	else if (strObj == "m_useRatio") {
// 		DetectState::instance()->m_RatioDetectType = int(state == 2);
// 	}
	else if (strObj == "m_ResAll2A") {
		DetectState::instance()->m_bObjAll2A = (state == 2 ? true : false);
	}
	else if (strObj == "m_AutoSendTick2COM") {
		DetectState::instance()->m_AutoSendTick2COM = int(state == 2);
		DetectState::instance()->saveDeteImage();
	}
	else if (strObj == "m_AutoSendTick2Net") {
		DetectState::instance()->m_AutoSendTick2Net = int(state == 2);
		DetectState::instance()->saveDeteImage();
	}
	else if (strObj == "m_SendDetectStr2Net") {
		DetectState::instance()->m_SendDetectStr2Net = int(state == 2);
		DetectState::instance()->saveDeteImage();
	}
	else if (strObj == "m_SendChannelRes2Net") {
		DetectState::instance()->m_SendChannelRes2Net = int(state == 2);
		DetectState::instance()->saveDeteImage();
	}
	else if (strObj == "m_SendChannelRes2COM") {
		DetectState::instance()->m_SendChannelRes2COM = int(state == 2);
		DetectState::instance()->saveDeteImage();
	}
	else if (strObj == "m_UseRaster") {
		DetectState::instance()->m_IsUseRaster = int(state == 2);
		DetectState::instance()->saveDeteImage();
	}
	else if (strObj == "m_SaveD2HCsv") {
		DetectState::instance()->m_SaveD2HCsv = int(state == 2);

	}
	else if (strObj == "m_IsUseChannel") {
		DetectState::instance()->m_IsUseChannel = int(state == 2);
		DetectState::instance()->saveDeteImage();
	}
	else if (strObj == "m_StartAndDetect") {
		DetectState::instance()->m_StartAndDetect = int(state == 2);
		DetectState::instance()->saveDeteImage();
	}
	else if (strObj == "m_PLC_RestartSeverCount") {
		DetectState::instance()->m_PLC_RestartSeverCount = int(state == 2);
		DetectState::instance()->savePLCPara();
	}
	else if (strObj == "m_PLC_ShowTimerOutMsg") {
		DetectState::instance()->m_PLC_ShowTimerOutMsg = int(state == 2);
		DetectState::instance()->savePLCPara();
	}
	else if (strObj == "m_PLC_IsResServer") {
		DetectState::instance()->m_PLC_IsResServer = int(state == 2);
		DetectState::instance()->savePLCPara();
	}
	else if (strObj == "m_PLC_SaveMsgInLog") {
		DetectState::instance()->m_PLC_SaveMsgInLog = int(state == 2);
		DetectState::instance()->savePLCPara();
	}
	else if (strObj == "m_showThressValue") {
		DetectState::instance()->m_showThressValue = int(state == 2);
	}
	else if (strObj == "m_showThressList") {
		DetectState::instance()->m_showThressList = int(state == 2);
	}
}

Q_SLOT void QSystemSettingDlg::onSetCurrentIndex(int nIndex)
{
	for (QMap<QString, QTreeWidgetItem*>::iterator pp = m_TreeItemMap.begin(); pp != m_TreeItemMap.end(); ++pp)
	{
		(*pp)->setExpanded(false);
	}
	QString strname = ui.listWidget->item(nIndex)->data(0).toString();
	if (m_TreeItemMap.contains(strname))
	{
		QTreeWidgetItem *p = m_TreeItemMap.value(strname);
		if (p) {
			ui.treeWidget->setCurrentItem(p, QItemSelectionModel::SelectCurrent);
			p->setExpanded(true);
		}
	}
}

Q_SLOT void QSystemSettingDlg::onSavePLCPara()
{
	{
		DetectState::instance()->m_PLC_TrigerFilter = m_PLCTrigerFilter->value();
		DetectState::instance()->m_PLC_CamTrigDelay = m_PLCCameraDelay->value();
		DetectState::instance()->m_PLC_CamTrigPulse = m_PLCCameraPulse->value();
		DetectState::instance()->m_PLC_LightDelay = m_PLCLightDelay->value();
		DetectState::instance()->m_PLC_RestartSeverCount = m_PLC_RestartSeverCount->value();
		DetectState::instance()->m_PLC_ResHoldTime = m_PLCResHoldTime->value();
		if (m_PLCTrigerType->currentText() == DEVELOP_PLC_TRIGER_DOWM)
			DetectState::instance()->m_PLC_TrigerType = 0;
		else if (m_PLCTrigerType->currentText() == DEVELOP_PLC_TRIGER_UP)
			DetectState::instance()->m_PLC_TrigerType = 1;

		DetectState::instance()->savePLCPara();
// 		QVariant nType = QVariant(WF_PLCPARA);
// 		emit(sgGenalData(nType, WF_PARASET));
// 		emit sgShowMsg(tr("数据已发送并保存"));
		emit sgChangePLCParam();
	}
	showTipInfo();
}

void QSystemSettingDlg::showTipInfo()
{
	if (m_timerID != 0)
	{
		killTimer(m_timerID);
		m_timerID = 0;
	}
	m_timerID = startTimer(1000);
	ui.label->setVisible(true);
	emit sgParamChange();
}

void QSystemSettingDlg::readSettingFile()
{
	if (m_setting) {
		QString m_str = "/CheckThread/";
		nCheckDays = m_setting->value(m_str + "days", 7).toInt();
		nCheckThreadEable = m_setting->value(m_str + "IsUse", true).toBool();
	}
}

void QSystemSettingDlg::writeSettingFile()
{
	if (m_setting) {
		QString m_str = "/CheckThread/";
		m_setting->setValue(m_str + "days", nCheckDays);
		m_setting->setValue(m_str + "IsUse", nCheckThreadEable);
	}
}
Q_SLOT void QSystemSettingDlg::onChangeBG()
{
	QFileDialog fileDialog;
	fileDialog.setWindowTitle(tr("请选择您的背景图"));
	fileDialog.setNameFilter("Picture(*.bmp *.jpg *.png)");
	fileDialog.setFileMode(QFileDialog::ExistingFiles);
	if (fileDialog.exec() == QDialog::Accepted)
	{
		QStringList backgroundFile = fileDialog.selectedFiles();
		if (backgroundFile.size() > 0)
		{
			QString DstPath = QApplication::applicationDirPath()+ "\\user\\background.png";
			QString sourcePath = backgroundFile.at(0);
			DstPath.replace("\\", "/");
			if (sourcePath == DstPath) {
				// 						//return;
				// 						//return true;
			}
			if (!QFile::exists(sourcePath)) {
				//return false;
			}
			QDir *createfile = new QDir;
			bool exist = createfile->exists(DstPath);
			if (exist) {
				//if (converFileIfExist){
				createfile->remove(DstPath);
				//}
			}
			if (!QFile::copy(sourcePath, DstPath)) {
				//return false;
			}
			//emit sgChangeBG(DstPath);
			QMessageBox infobox(QMessageBox::Information, tr("提示"), tr("背景图更新完成，请重启本软件."), QMessageBox::Yes, NULL);
			infobox.setWindowIcon(QIcon(":/image/leaper"));
			infobox.setButtonText(QMessageBox::Yes, tr("确认"));
			infobox.exec();
		}
	}
}

void QSystemSettingDlg::showEvent(QShowEvent *event)
{

}

void QSystemSettingDlg::timerEvent(QTimerEvent *event)
{
	if (event->timerId() == m_timerID)
	{
		killTimer(m_timerID);
		m_timerID = 0;
		ui.label->setVisible(false);
	}
}

void QSystemSettingDlg::changeEvent(QEvent *event)
{
	if (event->type() == QEvent::LanguageChange)
	{
		ui.retranslateUi(this);
	}
}

Q_SLOT void QSystemSettingDlg::onTreeWidgetButton()
{
	QString strObj = sender()->objectName();
	if (strObj == "m_IsModfy")
	{
		// 		m_ComScan->setDisabled(false);
		// 		m_ComBoxName->setDisabled(false);
		// 		m_ComBoxBaut->setDisabled(false);
		// 		pSaveButton->setDisabled(false);
	}
	else if (strObj == "m_ComScan")
	{
		// 		disconnect(m_ComBoxBaut,0,0,0);
		// 		disconnect(m_ComBoxName,0,0,0);
		// 		m_ComBoxName->clear();
		// 		QStringList m_NameList;
		// 		foreach(const QSerialPortInfo &info, QSerialPortInfo::availablePorts())
		// 		{
		// 			QString comportInfo = info.portName();
		// 			if (!m_NameList.contains(comportInfo))
		// 				m_NameList.append(comportInfo);
		// 		}
		// 		m_ComBoxName->addItems(m_NameList);
		// 
		// 		if (m_ComName){
		// 			m_ComBoxName->setCurrentText(m_ComName->text());
		// 		}
		// 		if (m_ComBaut){
		// 			m_ComBoxBaut->setCurrentText(m_ComBaut->text());
		// 		}
		// 		connect(m_ComBoxBaut, SIGNAL(currentIndexChanged(int)), this, SLOT(oncurrentIndexChanged(int)));
		// 		connect(m_ComBoxName, SIGNAL(currentIndexChanged(int)), this, SLOT(oncurrentIndexChanged(int)));

	}
	else if (strObj == "m_Language") {

	}
	else if (strObj == "m_DebugSave" || strObj == "pSavePara")
	{
		if (m_pCameraTrgType) {
			if (m_pCameraTrgType->currentText() == DEVELOP_DETECT_CAMERE_VIRSUAL)
				DetectState::instance()->m_Virtual_Camera = 1;
			else
				DetectState::instance()->m_Virtual_Camera = 0;
		}
		if (m_pCameraTrgTimes) {
			DetectState::instance()->m_Visural_Time = m_pCameraTrgTimes->value();
		}
		if (m_pDebugModel) {
			if (m_pDebugModel->currentText() == DEVELOP_DETECT_DEBUG_NOUSER)
				DetectState::instance()->m_Debug = 100;
			else
				DetectState::instance()->m_Debug = 1001;
		}
		if (m_pSystype) {
			if (m_pSystype->currentText() == DEVELOP_DETECT_CAM_OUTTRIGER)
				DetectState::instance()->m_CameraTrigeType = 1;
			else
				DetectState::instance()->m_CameraTrigeType = 0;
		}
// 		if (m_AlgFilterSize)
// 		{
// 			DetectState::instance()->m_filterSize = m_AlgFilterSize->value();
// 		}
// 		if (m_Algthreshold)
// 		{
// 			DetectState::instance()->m_AlgThres = m_Algthreshold->value();
// 		}
		DetectState::instance()->saveDeteImage();
		showTipInfo();
	}
}

Q_SLOT void QSystemSettingDlg::oncurrentChanged(const QString &str)
{
	QString strObjName = sender()->objectName();
	if ("m_Language" == strObjName) {

		emit sgChangeLanguage(str);
		//emit(sgGenalData("languageSeting", str));
	}
}

Q_SLOT void QSystemSettingDlg::onChangeBackground()
{
	QShowImg m_showImgDlg(this);
	m_showImgDlg.setWindowFlags(Qt::Dialog | Qt::WindowCloseButtonHint);
	m_showImgDlg.setWindowModality(Qt::ApplicationModal);
	m_showImgDlg.setAttribute(Qt::WA_ShowModal, true);
	m_showImgDlg.setWindowIcon(QIcon(":/image/leaper"));
	QString DstPath = ".\\user\\background.png";
	connect(&m_showImgDlg, SIGNAL(sgChangeImg()), this, SLOT(onChangeBG()));
	connect(this, SIGNAL(sgChangeBG(QString)), &m_showImgDlg, SLOT(setPicPath(QString)));
	m_showImgDlg.setPicPath(DstPath);
	m_showImgDlg.exec();
}

Q_SLOT void QSystemSettingDlg::onOpenDataPath()
{
	QString strObj = sender()->objectName();
	if ("pbOpenImgPath" == strObj)
	{
		QString strpath = DetectState::instance()->m_SaveImgDirPath + "/Data";
		bool bFalg = QDesktopServices::openUrl(QUrl(strpath, QUrl::TolerantMode));
		if (!bFalg)
		{
			bool bFalgs = QDesktopServices::openUrl(QUrl(DetectState::instance()->m_SaveImgDirPath, QUrl::TolerantMode));
			if (!bFalgs)
			{

			}
		}
	}
	else if ("pbSetSavePath" == strObj)
	{
		QString dir = QFileDialog::getExistingDirectory(NULL, tr("打开文件夹"), QString(), QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
		if (!dir.isEmpty())
		{
			if (m_pLbShowPath)
				m_pLbShowPath->setText(dir);
			DetectState::instance()->m_SaveImgDirPath = dir;
			if (pDiskCleanThread)
				pDiskCleanThread->SetImgStorageFolder(dir + "/Data");
		}
	}
}

Q_SLOT void QSystemSettingDlg::onLightTest()
{
	QVariant nType = QVariant(WF_LIFHT);
	QString strObj = sender()->objectName();
	if (strObj == "redLight")
	{
		//emit(sgGenalData(nType, LIGHT_REDBEE));
	}
	else if (strObj == "grenLight") {
		//emit(sgGenalData(nType, LIGHT_GREENBEE));
	}
	else if (strObj == "yellLight") {
		//emit(sgGenalData(nType, LIGHT_YELLOWBEE));
	}
	else if (strObj == "beeLight") {
		//emit(sgGenalData(nType, LIGHT_BEE));
	}
}