code_production/app/HGProductionTool/mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QVBoxLayout>
#include <QTimer>
#include "base/HGBase.h"
#include "HGUIGlobal.h"
#include "dialog_login.h"
#include "dialog_changepwd.h"
#include "dialog_accountmanage.h"
#include "dialog_uploadcfgfile.h"
#include "dialog_inputserialnum.h"

MainWindow::MainWindow(HGPdtToolDbUserMgr pdtToolDbuserMgr, const QString &ftpHost, unsigned short ftpPort, QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
    , m_pdtToolDbuserMgr(pdtToolDbuserMgr)
    , m_ftpHost(ftpHost)
    , m_ftpPort(ftpPort)
    , m_lock(nullptr)
    , m_top_splitter(nullptr)
    , m_bot_splitter(nullptr)
    , m_isLogOut(false)
{
    ui->setupUi(this);

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

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

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

    HGChar userName[128];
    HGPdtToolDb_GetUserName(m_pdtToolDbuserMgr, userName, 128);
    setWindowTitle(userName);

    showMaximized();

    SANE_Int v = 0;
    sane_init_ex(&v, sane_ex_callback, this);
}

MainWindow::~MainWindow()
{
    HGBase_EnterLock(m_lock);
    while (0 != m_top_splitter->count())
    {
        Form_mainInterface *interface = (Form_mainInterface *)m_top_splitter->widget(0);
        delete interface;
    }

    while (0 != m_bot_splitter->count())
    {
        Form_mainInterface *interface = (Form_mainInterface *)m_bot_splitter->widget(0);
        delete interface;
    }
    HGBase_LeaveLock(m_lock);

    sane_exit();

    HGPdtToolDb_DestroyUserMgr(m_pdtToolDbuserMgr);
    m_pdtToolDbuserMgr = 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 *interface = (Form_mainInterface *)m_top_splitter->widget(i);
        if (sn == interface->getSn())
        {
            return interface;
        }
    }

    for (int i = 0; i < m_bot_splitter->count(); ++i)
    {
        Form_mainInterface *interface = (Form_mainInterface *)m_bot_splitter->widget(i);
        if (sn == interface->getSn())
        {
            return interface;
        }
    }

    return nullptr;
}

Form_mainInterface *MainWindow::FindInterfaceByDevName(const QString &devName)
{
    for (int i = 0; i < m_top_splitter->count(); ++i)
    {
        Form_mainInterface *interface = (Form_mainInterface *)m_top_splitter->widget(i);
        if (devName == interface->getDevName())
        {
            return interface;
        }
    }

    for (int i = 0; i < m_bot_splitter->count(); ++i)
    {
        Form_mainInterface *interface = (Form_mainInterface *)m_bot_splitter->widget(i);
        if (devName == interface->getDevName())
        {
            return interface;
        }
    }

    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 *interface = (Form_mainInterface *)m_top_splitter->widget(i);
        if (handle == interface->getDevHandle())
        {
            form = interface;
            break;
        }
    }

    if (nullptr  == form)
    {
        for (int i = 0; i < m_bot_splitter->count(); ++i)
        {
            Form_mainInterface *interface = (Form_mainInterface *)m_bot_splitter->widget(i);
            if (handle == interface->getDevHandle())
            {
                form = interface;
                break;
            }
        }
    }

    return form;
}

bool MainWindow::AddInterface(Form_mainInterface *interface)
{
    assert(nullptr != interface);

    HGBase_EnterLock(m_lock);
    bool ret = false;
    if (m_top_splitter->count() < 2)
    {
        m_top_splitter->addWidget(interface);
        ret = true;
    }
    else if (m_bot_splitter->count() < 2)
    {
        m_bot_splitter->addWidget(interface);
        ret = true;
    }
    HGBase_LeaveLock(m_lock);

    updateSplitter();
    return ret;
}

bool MainWindow::RemoveInterface(Form_mainInterface *interface)
{
    assert(nullptr != interface);
    HGBase_EnterLock(m_lock);
    delete interface;
    HGBase_LeaveLock(m_lock);
    updateSplitter();
    return true;
}

bool MainWindow::isTesting()
{
    bool isTesting = false;
    for (int i = 0; i < m_top_splitter->count(); ++i)
    {
        Form_mainInterface *interface = (Form_mainInterface *)m_top_splitter->widget(i);
        if (interface->isTesting())
        {
            isTesting = true;
            break;
        }
    }
    if (!isTesting)
    {
        for (int i = 0; i < m_bot_splitter->count(); ++i)
        {
            Form_mainInterface *interface = (Form_mainInterface *)m_bot_splitter->widget(i);
            if (interface->isTesting())
            {
                isTesting = true;
                break;
            }
        }
    }
    return isTesting;
}

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)
    {
        HGBase_EnterLock(p->m_lock);
        Form_mainInterface* interface = p->FindInterface(hdev);
        if (nullptr != interface)
        {
            if (nullptr != interface->getScanner() && nullptr != interface->getScanner()->cb_)
                interface->getScanner()->cb_(hdev, code, data, len, interface->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)
{
    QMessageBox msg(QMessageBox::Question, tr("tips"),
                    tr("Are you sure to connect the new device"),
                    QMessageBox::Yes | QMessageBox::No, this);
    msg.setButtonText(QMessageBox::Yes, tr("yes"));
    msg.setButtonText(QMessageBox::No, tr("no"));
    msg.exec();
    if (msg.clickedButton() == msg.button(QMessageBox::Yes))
    {
        SANE_Handle devHandle = nullptr;
        sane_open(devName.toStdString().c_str(), &devHandle);

        Dialog_InputSerialNum dlg(this, getDevSn(devHandle), getDevType(devHandle));
        if (dlg.exec())
        {
            HGPdtToolDbDevice pdtToolDbDevice = nullptr;
            HGPdtToolDb_OpenDevice(m_pdtToolDbuserMgr, dlg.GetSn().toStdString().c_str(), &pdtToolDbDevice);

            Form_mainInterface *mainInterface = new Form_mainInterface(this, devHandle, m_pdtToolDbuserMgr, pdtToolDbDevice,
                                                                       dlg.GetSn(), dlg.GetDevType(), devName, getDevFwNum(devHandle));
            if (!AddInterface(mainInterface))
            {
                QMessageBox::information(this, tr("tips"), tr("cannot create more table"));
                delete mainInterface;
            }
        }
        else
        {
            sane_close(devHandle);
        }
    }
}

void MainWindow::on_sane_dev_remove(QString devName)
{
    Form_mainInterface *interface = FindInterfaceByDevName(devName);
    if (interface != nullptr)
    {
        QMessageBox::information(this, tr("tips"), tr("The device has disconnected"));
        RemoveInterface(interface);
    }
}

void MainWindow::on_update_userStatus()
{
    QString tips;
    HGUInt userStatus;
    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()
{
    Dialog_InputSerialNum dlg(this, "", "");
    if (dlg.exec())
    {
        HGPdtToolDbDevice pdtToolDbDevice = nullptr;
        HGPdtToolDb_OpenDevice(m_pdtToolDbuserMgr, dlg.GetSn().toStdString().c_str(), &pdtToolDbDevice);

        Form_mainInterface *mainInterface = new Form_mainInterface(this, nullptr, m_pdtToolDbuserMgr, pdtToolDbDevice, dlg.GetSn(), dlg.GetDevType(), nullptr, nullptr);
        if (!AddInterface(mainInterface))
        {
            QMessageBox::information(this, tr("tips"), tr("cannot create more table"));
            delete mainInterface;
        }
    }
}

void MainWindow::on_act_manage_triggered()
{
    Dialog_accountManage dlg(m_pdtToolDbuserMgr, this);
    dlg.exec();
}

void MainWindow::on_act_changePwd_triggered()
{
    Dialog_changePwd dlg(m_pdtToolDbuserMgr, 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(m_pdtToolDbuserMgr, this);
    dlg.exec();
}