711 lines
20 KiB
C++
711 lines
20 KiB
C++
#include "mainwindow.h"
|
|
#include "ui_mainwindow.h"
|
|
#include <QVBoxLayout>
|
|
#include <QTimer>
|
|
#include "base/HGBase.h"
|
|
#include "HGUIGlobal.h"
|
|
#include "app_cfg.h"
|
|
#include "dialog_login.h"
|
|
#include "dialog_changepwd.h"
|
|
#include "dialog_accountmanage.h"
|
|
#include "dialog_uploadcfgfile.h"
|
|
#include "dialog_inputserialnum.h"
|
|
#include "dialog_hgmessagebox.h"
|
|
|
|
MainWindow::MainWindow(Dialog_logIn::LogInType loginType, const QString &profileName, const QString &accountName, const QString &ftpHost, unsigned short ftpPort, QWidget *parent)
|
|
: QMainWindow(parent)
|
|
, ui(new Ui::MainWindow)
|
|
, m_ftpHost(ftpHost)
|
|
, m_ftpPort(ftpPort)
|
|
, m_lock(nullptr)
|
|
, m_testingRef(0)
|
|
, m_loginType(loginType)
|
|
, m_accountName(accountName)
|
|
, m_profileName(profileName)
|
|
, m_formBurnMode(nullptr)
|
|
, m_top_splitter(nullptr)
|
|
, m_bot_splitter(nullptr)
|
|
, m_isLogOut(false)
|
|
, m_inputSnDlg(nullptr)
|
|
{
|
|
ui->setupUi(this);
|
|
|
|
ui->act_newDevice->setVisible(false);
|
|
ui->act_close->setVisible(false);
|
|
ui->act_manage->setVisible(false);
|
|
ui->act_export->setVisible(false);
|
|
ui->act_upload->setVisible(false);
|
|
ui->act_openLog->setVisible(false);
|
|
|
|
if (m_accountName == "admin")
|
|
ui->act_openLog->setVisible(true);
|
|
|
|
ui->act_refreshDevice->setShortcut(QKeySequence("F5"));
|
|
|
|
QFont ft;
|
|
ft.setPointSize(15);
|
|
this->setFont(ft);
|
|
|
|
setWindowIcon(QIcon(":image/image_rsc/logo/logo.ico"));
|
|
|
|
HGBase_CreateLock(&m_lock);
|
|
|
|
connect(this, SIGNAL(sane_dev_arrive(QString)), this, SLOT(on_sane_dev_arrive(QString)), Qt::QueuedConnection);
|
|
connect(this, SIGNAL(sane_dev_remove(QString)), this, SLOT(on_sane_dev_remove(QString)), Qt::QueuedConnection);
|
|
|
|
if (m_loginType == Dialog_logIn::LogInType_Burn)
|
|
{
|
|
setWindowTitle(tr("production tool-burn station"));
|
|
// ui->act_newDevice->setVisible(false);
|
|
|
|
m_formBurnMode = new Form_BurnMode(this, this);
|
|
|
|
QVBoxLayout *vLayout = new QVBoxLayout;
|
|
vLayout->addWidget(m_formBurnMode);
|
|
this->centralWidget()->setLayout(vLayout);
|
|
show();
|
|
}
|
|
else
|
|
{
|
|
// ui->act_refreshDevice->setVisible(true);
|
|
|
|
m_top_splitter = new QSplitter(Qt::Horizontal);
|
|
m_bot_splitter = new QSplitter(Qt::Horizontal);
|
|
m_top_splitter->setMinimumWidth(600);
|
|
m_bot_splitter->setMinimumWidth(600);
|
|
m_top_splitter->setChildrenCollapsible(false);
|
|
m_bot_splitter->setChildrenCollapsible(false);
|
|
|
|
QVBoxLayout *vLayout = new QVBoxLayout;
|
|
vLayout->addWidget(m_top_splitter);
|
|
vLayout->addWidget(m_bot_splitter);
|
|
vLayout->setStretch(0, 0);
|
|
vLayout->setStretch(1, 0);
|
|
this->centralWidget()->setLayout(vLayout);
|
|
|
|
showMaximized();
|
|
}
|
|
|
|
QTimer *timer = new QTimer(this);
|
|
timer->start(1000);
|
|
connect(timer, SIGNAL(timeout()), this, SLOT(on_update_userStatus()));
|
|
|
|
HGUInt userType = 0;
|
|
//HGPdtToolDb_GetUserType(m_pdtToolDbuserMgr, &userType);
|
|
// if (userType == HGPDTTOOLDB_USERTYPE_NORMAL)
|
|
// {
|
|
// ui->act_manage->setVisible(false);
|
|
// ui->act_upload->setVisible(false);
|
|
// }
|
|
|
|
if (m_loginType == Dialog_logIn::LogInType_InitTest)
|
|
setWindowTitle(tr("production tool-init test station"));
|
|
else if (m_loginType == Dialog_logIn::LogInType_ImageTest)
|
|
setWindowTitle(tr("production tool-image test station"));
|
|
if (m_loginType == Dialog_logIn::LogInType_PressureTest)
|
|
setWindowTitle(tr("production tool-pressure test station"));
|
|
|
|
SANE_Int v = 0;
|
|
sane_init_ex(&v, sane_ex_callback, this);
|
|
}
|
|
|
|
MainWindow::~MainWindow()
|
|
{
|
|
HGBase_EnterLock(m_lock);
|
|
if (m_top_splitter != nullptr)
|
|
{
|
|
while (0 != m_top_splitter->count())
|
|
{
|
|
Form_mainInterface * mainInterface = (Form_mainInterface *)m_top_splitter->widget(0);
|
|
delete mainInterface;
|
|
}
|
|
}
|
|
|
|
if (m_top_splitter != nullptr)
|
|
{
|
|
while (0 != m_bot_splitter->count())
|
|
{
|
|
Form_mainInterface * mainInterface = (Form_mainInterface *)m_bot_splitter->widget(0);
|
|
delete mainInterface;
|
|
}
|
|
}
|
|
|
|
HGBase_LeaveLock(m_lock);
|
|
|
|
sane_exit();
|
|
|
|
//HGPdtToolDb_DestroyUserMgr(m_pdtToolDbuserMgr);
|
|
//m_pdtToolDbuserMgr = nullptr;
|
|
|
|
delete m_formBurnMode;
|
|
m_formBurnMode = nullptr;
|
|
|
|
HGBase_DestroyLock(m_lock);
|
|
m_lock = nullptr;
|
|
delete ui;
|
|
}
|
|
|
|
bool MainWindow::isExitApp()
|
|
{
|
|
return !m_isLogOut;
|
|
}
|
|
|
|
void MainWindow::updateSplitter()
|
|
{
|
|
if (0 != m_top_splitter->count() && 0 == m_bot_splitter->count())
|
|
{
|
|
reinterpret_cast<QVBoxLayout*>(this->centralWidget()->layout())->setStretch(0, 1);
|
|
reinterpret_cast<QVBoxLayout*>(this->centralWidget()->layout())->setStretch(1, 0);
|
|
}
|
|
else if (0 == m_top_splitter->count() && 0 != m_bot_splitter->count())
|
|
{
|
|
reinterpret_cast<QVBoxLayout*>(this->centralWidget()->layout())->setStretch(0, 0);
|
|
reinterpret_cast<QVBoxLayout*>(this->centralWidget()->layout())->setStretch(1, 1);
|
|
}
|
|
else if (0 != m_top_splitter->count() && 0 != m_bot_splitter->count())
|
|
{
|
|
reinterpret_cast<QVBoxLayout*>(this->centralWidget()->layout())->setStretch(0, 1);
|
|
reinterpret_cast<QVBoxLayout*>(this->centralWidget()->layout())->setStretch(1, 1);
|
|
}
|
|
else
|
|
{
|
|
reinterpret_cast<QVBoxLayout*>(this->centralWidget()->layout())->setStretch(0, 0);
|
|
reinterpret_cast<QVBoxLayout*>(this->centralWidget()->layout())->setStretch(1, 0);
|
|
}
|
|
}
|
|
|
|
Form_mainInterface* MainWindow::FindInterface(const QString &sn)
|
|
{
|
|
for (int i = 0; i < m_top_splitter->count(); ++i)
|
|
{
|
|
Form_mainInterface * mainInterface = (Form_mainInterface *)m_top_splitter->widget(i);
|
|
if (sn == mainInterface->getSn())
|
|
{
|
|
return mainInterface;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < m_bot_splitter->count(); ++i)
|
|
{
|
|
Form_mainInterface * mainInterface = (Form_mainInterface *)m_bot_splitter->widget(i);
|
|
if (sn == mainInterface->getSn())
|
|
{
|
|
return mainInterface;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
Form_mainInterface *MainWindow::FindInterfaceByDevName(const QString &devName)
|
|
{
|
|
for (int i = 0; i < m_top_splitter->count(); ++i)
|
|
{
|
|
Form_mainInterface * mainInterface = (Form_mainInterface *)m_top_splitter->widget(i);
|
|
if (devName == mainInterface->getDevName())
|
|
{
|
|
return mainInterface;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < m_bot_splitter->count(); ++i)
|
|
{
|
|
Form_mainInterface * mainInterface = (Form_mainInterface *)m_bot_splitter->widget(i);
|
|
if (devName == mainInterface->getDevName())
|
|
{
|
|
return mainInterface;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
Form_mainInterface* MainWindow::FindInterface(SANE_Handle handle)
|
|
{
|
|
Form_mainInterface *form = nullptr;
|
|
for (int i = 0; i < m_top_splitter->count(); ++i)
|
|
{
|
|
Form_mainInterface * mainInterface = (Form_mainInterface *)m_top_splitter->widget(i);
|
|
if (handle == mainInterface->getDevHandle())
|
|
{
|
|
form = mainInterface;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (nullptr == form)
|
|
{
|
|
for (int i = 0; i < m_bot_splitter->count(); ++i)
|
|
{
|
|
Form_mainInterface * mainInterface = (Form_mainInterface *)m_bot_splitter->widget(i);
|
|
if (handle == mainInterface->getDevHandle())
|
|
{
|
|
form = mainInterface;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return form;
|
|
}
|
|
|
|
bool MainWindow::AddInterface(Form_mainInterface * mainInterface)
|
|
{
|
|
assert(nullptr != mainInterface);
|
|
|
|
HGBase_EnterLock(m_lock);
|
|
bool ret = false;
|
|
if (m_top_splitter->count() < 2)
|
|
{
|
|
m_top_splitter->addWidget(mainInterface);
|
|
ret = true;
|
|
}
|
|
else if (m_bot_splitter->count() < 2)
|
|
{
|
|
m_bot_splitter->addWidget(mainInterface);
|
|
ret = true;
|
|
}
|
|
HGBase_LeaveLock(m_lock);
|
|
|
|
updateSplitter();
|
|
return ret;
|
|
}
|
|
|
|
bool MainWindow::RemoveInterface(Form_mainInterface * mainInterface)
|
|
{
|
|
assert(nullptr != mainInterface);
|
|
HGBase_EnterLock(m_lock);
|
|
delete mainInterface;
|
|
HGBase_LeaveLock(m_lock);
|
|
updateSplitter();
|
|
return true;
|
|
}
|
|
|
|
void MainWindow::addTestingRef()
|
|
{
|
|
++m_testingRef;
|
|
|
|
ui->act_refreshDevice->setEnabled(false);
|
|
ui->act_close->setEnabled(false);
|
|
ui->act_manage->setEnabled(false);
|
|
ui->act_logOut->setEnabled(false);
|
|
ui->act_changePwd->setEnabled(false);
|
|
ui->act_export->setEnabled(false);
|
|
ui->act_upload->setEnabled(false);
|
|
}
|
|
|
|
void MainWindow::releaseTesting()
|
|
{
|
|
--m_testingRef;
|
|
|
|
if (0 == m_testingRef)
|
|
{
|
|
ui->act_refreshDevice->setEnabled(true);
|
|
ui->act_close->setEnabled(true);
|
|
ui->act_manage->setEnabled(true);
|
|
ui->act_logOut->setEnabled(true);
|
|
ui->act_changePwd->setEnabled(true);
|
|
ui->act_export->setEnabled(true);
|
|
ui->act_upload->setEnabled(true);
|
|
}
|
|
}
|
|
|
|
bool MainWindow::isTesting()
|
|
{
|
|
return (m_testingRef != 0);
|
|
}
|
|
|
|
void MainWindow::closeEvent(QCloseEvent *event)
|
|
{
|
|
if (isTesting())
|
|
{
|
|
QMessageBox::information(this, tr("tips"), tr("Is testing, do not close!"));
|
|
event->ignore();
|
|
}
|
|
}
|
|
|
|
int MainWindow::sane_ex_callback(SANE_Handle hdev, int code, void *data, unsigned int *len, void *param)
|
|
{
|
|
MainWindow* p = (MainWindow*)param;
|
|
|
|
if (SANE_EVENT_DEVICE_ARRIVED == code)
|
|
{
|
|
SANE_Device_Ex* sane_dev = (SANE_Device_Ex*)data;
|
|
|
|
emit p->sane_dev_arrive(sane_dev->name);
|
|
}
|
|
else if (SANE_EVENT_DEVICE_LEFT == code)
|
|
{
|
|
SANE_Device* sane_dev = (SANE_Device*)data;
|
|
emit p->sane_dev_remove(sane_dev->name);
|
|
}
|
|
|
|
if (code == SANE_EVENT_IMAGE_OK || code == SANE_EVENT_SCAN_FINISHED || code == SANE_EVENT_ERROR || code == SANE_EVENT_STATUS)
|
|
{
|
|
HGBase_EnterLock(p->m_lock);
|
|
if (p->m_loginType != Dialog_logIn::LogInType_Burn)
|
|
{
|
|
Form_mainInterface* mainInterface = p->FindInterface(hdev);
|
|
if (nullptr != mainInterface)
|
|
{
|
|
if (nullptr != mainInterface->getScanner() && nullptr != mainInterface->getScanner()->cb_)
|
|
mainInterface->getScanner()->cb_(hdev, code, data, len, mainInterface->getScanner());
|
|
}
|
|
}
|
|
HGBase_LeaveLock(p->m_lock);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
std::vector<std::string> MainWindow::getDevices()
|
|
{
|
|
std::vector<std::string> name;
|
|
const SANE_Device** devs_list;
|
|
SANE_Status status = SANE_STATUS_GOOD;
|
|
if ((status = sane_get_devices(&devs_list, SANE_TRUE)) != SANE_STATUS_GOOD)
|
|
{
|
|
name.push_back("");
|
|
return name;
|
|
}
|
|
name.clear();
|
|
while (*devs_list != NULL)
|
|
{
|
|
name.push_back((*devs_list)->name);
|
|
devs_list++;
|
|
}
|
|
return name;
|
|
}
|
|
|
|
QString MainWindow::getDevSn(SANE_Handle handle)
|
|
{
|
|
std::string serialNum;
|
|
unsigned int serialNumLen = 0;
|
|
if(SANE_STATUS_NO_MEM == sane_io_control(handle, IO_CTRL_CODE_GET_SERIAL, nullptr, &serialNumLen) && serialNumLen)
|
|
{
|
|
serialNum.resize(serialNumLen);
|
|
sane_io_control(handle, IO_CTRL_CODE_GET_SERIAL, &serialNum[0], &serialNumLen);
|
|
}
|
|
return QString::fromStdString(serialNum.c_str());
|
|
}
|
|
|
|
QString MainWindow::getDevType(SANE_Handle handle)
|
|
{
|
|
std::string firmWareNum;
|
|
unsigned int firmWareNumLen = 0;
|
|
if(SANE_STATUS_NO_MEM == sane_io_control(handle, IO_CTRL_CODE_GET_HARDWARE_VERSION, nullptr, &firmWareNumLen) && firmWareNumLen)
|
|
{
|
|
firmWareNum.resize(firmWareNumLen);
|
|
sane_io_control(handle, IO_CTRL_CODE_GET_HARDWARE_VERSION, &firmWareNum[0], &firmWareNumLen);
|
|
}
|
|
|
|
QString str = QString::fromStdString(firmWareNum.c_str());
|
|
return str.left(2) + "00";
|
|
}
|
|
|
|
QString MainWindow::getDevFwNum(SANE_Handle handle)
|
|
{
|
|
std::string firmWareNum;
|
|
unsigned int firmWareNumLen = 0;
|
|
if(SANE_STATUS_NO_MEM == sane_io_control(handle, IO_CTRL_CODE_GET_HARDWARE_VERSION, nullptr, &firmWareNumLen) && firmWareNumLen)
|
|
{
|
|
firmWareNum.resize(firmWareNumLen);
|
|
sane_io_control(handle, IO_CTRL_CODE_GET_HARDWARE_VERSION, &firmWareNum[0], &firmWareNumLen);
|
|
}
|
|
|
|
return QString::fromStdString(firmWareNum.c_str());
|
|
}
|
|
|
|
void MainWindow::on_sane_dev_arrive(QString devName)
|
|
{
|
|
//// QTime curTimer = QTime::currentTime().addMSecs(5000);
|
|
//// while (QTime::currentTime() < curTimer)
|
|
//// {
|
|
//// QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
|
|
//// }
|
|
|
|
// if (m_loginType == Dialog_logIn::LogInType_Burn)
|
|
// {
|
|
// SANE_Handle devHandle = nullptr;
|
|
// sane_open(devName.toStdString().c_str(), &devHandle);
|
|
// if (nullptr != devHandle)
|
|
// {
|
|
// DeviceManager *devManager = new DeviceManager(this, m_formBurnMode, devHandle, devName);
|
|
// m_formBurnMode->addDevice(devManager);
|
|
// }
|
|
|
|
// return;
|
|
// }
|
|
|
|
// // QString str = tr("Confirm whether the device is reset");
|
|
// // Dialog_HGMessageBox dlg(str, this);
|
|
// // if (!dlg.exec())
|
|
// // {
|
|
// // return;
|
|
// // }
|
|
|
|
// SANE_Handle devHandle = nullptr;
|
|
// sane_open(devName.toStdString().c_str(), &devHandle);
|
|
|
|
// if (nullptr == devHandle)
|
|
// {
|
|
// QMessageBox::information(this, tr("tips"), tr("Open device failed"));
|
|
// return;
|
|
// }
|
|
|
|
// m_inputSnDlg = new Dialog_InputSerialNum(this, devName, m_pdtToolDbuserMgr, devHandle, getDevSn(devHandle), getDevType(devHandle));
|
|
// if (!m_inputSnDlg->exec())
|
|
// {
|
|
// sane_close(devHandle);
|
|
// return ;
|
|
// }
|
|
|
|
// HGPdtToolDbDevice pdtToolDbDevice = nullptr;
|
|
// HGPdtToolDb_OpenDevice(m_pdtToolDbuserMgr, m_inputSnDlg->GetSn().toStdString().c_str(), &pdtToolDbDevice);
|
|
|
|
// Form_mainInterface *mainInterface = new Form_mainInterface(this, m_loginType, devHandle, m_pdtToolDbuserMgr, pdtToolDbDevice,
|
|
// m_inputSnDlg->GetSn(), m_inputSnDlg->GetDevType(), devName, getDevFwNum(devHandle));
|
|
// if (!AddInterface(mainInterface))
|
|
// {
|
|
// QMessageBox::information(this, tr("tips"), tr("cannot create more table"));
|
|
// delete mainInterface;
|
|
// }
|
|
|
|
// if (m_inputSnDlg != nullptr)
|
|
// {
|
|
// delete m_inputSnDlg;
|
|
// m_inputSnDlg = nullptr;
|
|
// }
|
|
}
|
|
|
|
void MainWindow::on_sane_dev_remove(QString devName)
|
|
{
|
|
if (m_loginType == Dialog_logIn::LogInType_Burn)
|
|
{
|
|
m_formBurnMode->deleteDevice(devName);
|
|
}
|
|
else
|
|
{
|
|
if (nullptr != m_inputSnDlg)
|
|
{
|
|
m_inputSnDlg->Invalid(devName);
|
|
}
|
|
|
|
Form_mainInterface * mainInterface = FindInterfaceByDevName(devName);
|
|
if (mainInterface != nullptr)
|
|
{
|
|
mainInterface->setDevDisconnect();
|
|
if (!mainInterface->isTesting())
|
|
{
|
|
RemoveInterface(mainInterface);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void MainWindow::on_update_userStatus()
|
|
{
|
|
QString tips;
|
|
HGUInt userStatus = 0;
|
|
//HGPdtToolDb_GetUserStatus(m_pdtToolDbuserMgr, &userStatus);
|
|
|
|
// switch (userStatus)
|
|
// {
|
|
// case HGPDTTOOLDB_USERSTATUS_CONFLICT:
|
|
// tips = tr("Account login elsewhere");
|
|
// break;
|
|
// case HGPDTTOOLDB_USERSTATUS_REFUSE:
|
|
// tips = tr("You have been forced offline by the administrator account");
|
|
// break;
|
|
// case HGPDTTOOLDB_USERSTATUS_DBERROR:
|
|
// tips = tr("Data base error");
|
|
// break;
|
|
// default:
|
|
// break;
|
|
// }
|
|
|
|
// if (!tips.isEmpty())
|
|
// {
|
|
// if (!isTesting())
|
|
// {
|
|
// QMessageBox::information(this, (tr("tips")), tips);
|
|
// m_isLogOut = true;
|
|
// close();
|
|
// }
|
|
// }
|
|
}
|
|
|
|
void MainWindow::on_act_newDevice_triggered()
|
|
{
|
|
m_inputSnDlg = new Dialog_InputSerialNum(this, m_loginType, "", m_profileName, m_accountName, nullptr, "", "");
|
|
if (m_inputSnDlg->exec())
|
|
{
|
|
//HGPdtToolDbDevice pdtToolDbDevice = nullptr;
|
|
//HGPdtToolDb_OpenDevice(m_pdtToolDbuserMgr, m_inputSnDlg->GetSn().toStdString().c_str(), &pdtToolDbDevice);
|
|
|
|
Form_mainInterface *mainInterface = new Form_mainInterface(this, m_loginType, m_profileName, m_accountName, nullptr,
|
|
m_inputSnDlg->GetSn(), m_inputSnDlg->GetDevType(), nullptr, nullptr);
|
|
if (!AddInterface(mainInterface))
|
|
{
|
|
QMessageBox::information(this, tr("tips"), tr("cannot create more table"));
|
|
delete mainInterface;
|
|
}
|
|
}
|
|
|
|
delete m_inputSnDlg;
|
|
m_inputSnDlg = nullptr;
|
|
}
|
|
void MainWindow::on_act_manage_triggered()
|
|
{
|
|
Dialog_accountManage dlg(this);
|
|
dlg.exec();
|
|
}
|
|
|
|
void MainWindow::on_act_changePwd_triggered()
|
|
{
|
|
Dialog_changePwd dlg(m_accountName, this);
|
|
dlg.exec();
|
|
}
|
|
|
|
void MainWindow::on_act_export_triggered()
|
|
{
|
|
// QString filename = QFileDialog::getSaveFileName(this, tr("save"), "test.xls", tr("xls(*.xls)"));
|
|
// if (!filename.isEmpty())
|
|
// {
|
|
// if (HGBASE_ERR_OK == HGPdtToolDb_Export(m_pdtToolDbuserMgr, getStdString(filename).c_str()))
|
|
// {
|
|
// QMessageBox::information(this, tr("tips"), tr("export succeed"));
|
|
// }
|
|
// else
|
|
// {
|
|
// QMessageBox::information(this, tr("tips"), tr("export failed"));
|
|
// }
|
|
// }
|
|
}
|
|
|
|
void MainWindow::on_act_logOut_triggered()
|
|
{
|
|
if (isTesting())
|
|
{
|
|
QMessageBox::information(this, tr("tips"), tr("Is testing, do not close!"));
|
|
return;
|
|
}
|
|
m_isLogOut = true;
|
|
close();
|
|
}
|
|
|
|
|
|
void MainWindow::on_act_close_triggered()
|
|
{
|
|
if (isTesting())
|
|
{
|
|
QMessageBox::information(this, tr("tips"), tr("Is testing, do not close!"));
|
|
return;
|
|
}
|
|
|
|
close();
|
|
}
|
|
|
|
QString MainWindow::getLogInfo(HGResult ret)
|
|
{
|
|
QString str;
|
|
// if (HGPDTTOOLDB_ERR_INVALID_USER == ret)
|
|
// {
|
|
// str = tr("Illegal user");
|
|
// }
|
|
// else if (HGPDTTOOLDB_ERR_WRONG_PASSWORD == ret)
|
|
// {
|
|
// str = tr("Wrong password");
|
|
// }
|
|
// else if (HGPDTTOOLDB_ERR_DATABASE == ret)
|
|
// {
|
|
// str = tr("Database error");
|
|
// }
|
|
// else if (HGPDTTOOLDB_ERR_CONNECT == ret)
|
|
// {
|
|
// str = tr("connect error");
|
|
// }
|
|
// else
|
|
// {
|
|
// str = tr("Failed");
|
|
// }
|
|
|
|
return str;
|
|
}
|
|
|
|
void MainWindow::on_act_upload_triggered()
|
|
{
|
|
Dialog_uploadCfgFile dlg(this);
|
|
dlg.exec();
|
|
}
|
|
|
|
void MainWindow::on_act_refreshDevice_triggered()
|
|
{
|
|
std::vector<std::string> name;
|
|
name = getDevices();
|
|
|
|
if (m_loginType == Dialog_logIn::LogInType_Burn)
|
|
{
|
|
for (int i = 0; i < name.size(); ++i)
|
|
{
|
|
SANE_Handle devHandle = nullptr;
|
|
sane_open(name[i].c_str(), &devHandle);
|
|
if (nullptr != devHandle)
|
|
{
|
|
DeviceManager *devManager = new DeviceManager(this, m_formBurnMode, devHandle, m_profileName, name[i].c_str(), getDevSn(devHandle));
|
|
m_formBurnMode->addDevice(devManager);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < name.size(); ++i)
|
|
{
|
|
SANE_Handle devHandle = nullptr;
|
|
sane_open(name[i].c_str(), &devHandle);
|
|
if (nullptr != devHandle)
|
|
{
|
|
m_inputSnDlg = new Dialog_InputSerialNum(this, m_loginType, name[i].c_str(), m_profileName, m_accountName, devHandle, getDevSn(devHandle), getDevType(devHandle));
|
|
|
|
if (m_inputSnDlg->exec())
|
|
{
|
|
//HGPdtToolDbDevice pdtToolDbDevice = nullptr;
|
|
//HGPdtToolDb_OpenDevice(m_pdtToolDbuserMgr, m_inputSnDlg->GetSn().toStdString().c_str(), &pdtToolDbDevice);
|
|
|
|
Form_mainInterface *mainInterface = new Form_mainInterface(this, m_loginType, m_profileName, m_accountName, devHandle,
|
|
m_inputSnDlg->GetSn(), m_inputSnDlg->GetDevType(), name[i].c_str(), getDevFwNum(devHandle));
|
|
if (!AddInterface(mainInterface))
|
|
{
|
|
QMessageBox::information(this, tr("tips"), tr("cannot create more table"));
|
|
delete mainInterface;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sane_close(devHandle);
|
|
}
|
|
|
|
delete m_inputSnDlg;
|
|
m_inputSnDlg = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
void MainWindow::on_act_openLog_triggered()
|
|
{
|
|
HGChar logPath[512];
|
|
HGBase_GetDocumentsPath(logPath, 512);
|
|
HGChar procName[512];
|
|
HGBase_GetProcessName(procName, 512);
|
|
strcat(logPath, procName);
|
|
strcat(logPath, "/Test_Log/");
|
|
|
|
QString defaultFileName = logPath + m_accountName + ".log";
|
|
|
|
QString fileName = getCfgValue("save", "logPath", defaultFileName);
|
|
QFileInfo fileInfo(getStdFileName(fileName));
|
|
auto pathDir = fileInfo.path();
|
|
QString strFilePath = "file:///" + pathDir;
|
|
QDesktopServices::openUrl(QUrl(strFilePath));
|
|
}
|