code_production/app/HGProductionTool/form_maininterface.cpp

#include "form_maininterface.h"
#include "ui_form_maininterface.h"
#include <QPainter>
#include <QMessageBox>
#include <QInputDialog>
#include "base/HGBase.h"
#include "imgfmt/HGImgFmt.h"
#include "HGUIGlobal.h"
#include "HGString.h"
#include "form_texttips.h"
#include "test_base.h"
#include "hgscanner.h"
#include "mainwindow.h"
#include "dialog_excepdesc.h"
#include "huagao/hgscanner_error.h"

typedef struct
{
   const wchar_t *title;
   HGUInt entryName;
}RELA;

static const RELA Rela[] = {
    {HGPDTTOOLDB_TITLE_DIAL_SWITCH, HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH},
    {HGPDTTOOLDB_TITLE_ROCKER_SWITCH, HGPDTTOOLDB_ENTRYNAME_ROCKER_SWITCH},
    {HGPDTTOOLDB_TITLE_BOOT_STATUS, HGPDTTOOLDB_ENTRYNAME_BOOT_STATUS},
    {HGPDTTOOLDB_TITLE_LCD_DISPLAY, HGPDTTOOLDB_ENTRYNAME_LCD_DISPLAY},
    {HGPDTTOOLDB_TITLE_CLEAR_PAPER_PATH, HGPDTTOOLDB_ENTRYNAME_CLEAR_PAPER_PATH},
    {HGPDTTOOLDB_TITLE_KEY_FUNCTION, HGPDTTOOLDB_ENTRYNAME_KEY_FUNCTION},
    {HGPDTTOOLDB_TITLE_COUNTING_MODE, HGPDTTOOLDB_ENTRYNAME_COUNTING_MODE},
    {HGPDTTOOLDB_TITLE_SKEW_DETECTION, HGPDTTOOLDB_ENTRYNAME_SKEW_DETECTION},
    {HGPDTTOOLDB_TITLE_SEPARATER_MOTOR, HGPDTTOOLDB_ENTRYNAME_SEPARATER_MOTOR},
    {HGPDTTOOLDB_TITLE_CIS_ORIGINAL_IMAGE, HGPDTTOOLDB_ENTRYNAME_CIS_ORIGINAL_IMAGE},
    {HGPDTTOOLDB_TITLE_HOST_FAN, HGPDTTOOLDB_ENTRYNAME_HOST_FAN},
    {HGPDTTOOLDB_TITLE_ULTRASONIC_MODULE, HGPDTTOOLDB_ENTRYNAME_ULTRASONIC_MODULE},
    {HGPDTTOOLDB_TITLE_LED_LIGHT, HGPDTTOOLDB_ENTRYNAME_LED_LIGHT},
    {HGPDTTOOLDB_TITLE_RESET, HGPDTTOOLDB_ENTRYNAME_RESET},
    {HGPDTTOOLDB_TITLE_PAPER_FEED, HGPDTTOOLDB_ENTRYNAME_PAPER_FEED},
    {HGPDTTOOLDB_TITLE_COVER_SENSOR, HGPDTTOOLDB_ENTRYNAME_COVER_SENSOR},
    {HGPDTTOOLDB_TITLE_SCANNING_SENSOR, HGPDTTOOLDB_ENTRYNAME_SCANNING_SENSOR},
    {HGPDTTOOLDB_TITLE_CONFIGURE_SPEED_MODE, HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE},
    {HGPDTTOOLDB_TITLE_PLACE_CORRECTION_PAPER, HGPDTTOOLDB_ENTRYNAME_PLACE_CORRECTION_PAPER},
    {HGPDTTOOLDB_TITLE_AUTO_FLAT_FIELD, HGPDTTOOLDB_ENTRYNAME_AUTO_FLAT_FIELD},
    {HGPDTTOOLDB_TITLE_REBOOT_DEVICE, HGPDTTOOLDB_ENTRYNAME_REBOOT_DEVICE},
    {HGPDTTOOLDB_TITLE_IMAGE_QUALITY, HGPDTTOOLDB_ENTRYNAME_IMAGE_QUALITY},
    {HGPDTTOOLDB_TITLE_COLORCARD_IMAGEING_QUALITY, HGPDTTOOLDB_ENTRYNAME_COLORCARD_IMAGEING_QUALITY},
    {HGPDTTOOLDB_TITLE_COLORCARD_BIAS_IMAGEING_QUALITY, HGPDTTOOLDB_ENTRYNAME_COLORCARD_BIAS_IMAGEING_QUALITY},
    {HGPDTTOOLDB_TITLE_CLARITY_QUALITY, HGPDTTOOLDB_ENTRYNAME_CLARITY_QUALITY},
    {HGPDTTOOLDB_TITLE_DISTORTION, HGPDTTOOLDB_ENTRYNAME_DISTORTION},
    {HGPDTTOOLDB_TITLE_DORMANCY, HGPDTTOOLDB_ENTRYNAME_DORMANCY},
    {HGPDTTOOLDB_TITLE_SKEW_GEAR, HGPDTTOOLDB_ENTRYNAME_SKEW_GEAR},
    {HGPDTTOOLDB_TITLE_PAPER_SEPARATION_STRENGTH, HGPDTTOOLDB_ENTRYNAME_PAPER_SEPARATION_STRENGTH},
    {HGPDTTOOLDB_TITLE_MECH_PAPER_FEEDING_INCLINATION, HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION},
    {HGPDTTOOLDB_TITLE_SINGLE_PAGE_TEST_1, HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1},
    {HGPDTTOOLDB_TITLE_SINGLE_PAGE_TEST_2, HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_2},
    {HGPDTTOOLDB_TITLE_SINGLE_PAGE_TEST_3, HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_3},
    {HGPDTTOOLDB_TITLE_PRESSUER_TEST, HGPDTTOOLDB_ENTRYNAME_PRESSUER_TEST},
    {HGPDTTOOLDB_TITLE_CLEAR_ROLLER_COUNT, HGPDTTOOLDB_ENTRYNAME_CLEAR_ROLLER_COUNT}
};

Form_mainInterface::Form_mainInterface(class MainWindow *mainwnd, SANE_Handle handle, HGPdtToolDbUserMgr pdtToolDbuserMgr, HGPdtToolDbDevice pdtToolDbDevice,
                                       const QString &serialNum, const QString &devType, const QString &devName, const QString &devFwNum)
    : QWidget(mainwnd)
    , ui(new Ui::Form_mainInterface)
    , m_mainwnd(mainwnd)
    , m_hg(nullptr)
    , m_handle(handle)
    , m_pdtToolDbuserMgr(pdtToolDbuserMgr)
    , m_pdtToolDbDevice(pdtToolDbDevice)
    , m_serialNum(serialNum)
    , m_devType(devType)
    , m_devName(devName)
    , m_devFwNum(devFwNum)
    , m_isTesting(false)
{
    ui->setupUi(this);

    QFont ft;
    ft.setPointSize(15);
    this->setFont(ft);

    connect(this, SIGNAL(testResult(QString)), this, SLOT(on_testResult(QString)), Qt::QueuedConnection);
    connect(this, SIGNAL(testResultImg(void*)), this, SLOT(on_testResultImg(void*)), Qt::QueuedConnection);
    connect(this, SIGNAL(testFinish()), this, SLOT(on_testFinish()), Qt::QueuedConnection);

    QString str;
    if (m_handle)
        str = tr("Device has connected");
    else
        str = tr("Device hasnot connected");
    ui->label_sn->setText(tr("Device type:") + m_devType + tr("  SerialNum:") + m_serialNum + tr("  connect status:") + str);

    setMinimumWidth(500);
    ui->tableWidget->setMinimumWidth(400);
    ui->tableWidget->setMaximumWidth(400);
    m_textTips = new Form_textTips();
    m_view = new HGImgView();
    ui->stackedWidget->addWidget(m_textTips);
    ui->stackedWidget->addWidget(m_view);
    ui->pbtn_showImg->setToolTip(tr("load last image which uploaded last time"));

    initTableWidgetUi();

    if(!m_devType.isEmpty())
        HGPdtToolDb_SetDeviceType(m_pdtToolDbDevice, m_devType.toStdString().c_str());
    if(!m_devFwNum.isEmpty())
        HGPdtToolDb_SetDeviceVersion(m_pdtToolDbDevice, m_devFwNum.toStdString().c_str());
    if(!m_devName.isEmpty())
        HGPdtToolDb_SetDeviceName(m_pdtToolDbDevice, m_devName.toStdString().c_str());

    m_hg = new hgscanner(this, m_handle);
}

Form_mainInterface::~Form_mainInterface()
{
    delete m_hg;
    m_hg = nullptr;

    sane_close(m_handle);
    m_handle = nullptr;
    HGPdtToolDb_CloseDevice(m_pdtToolDbDevice);
    m_pdtToolDbDevice = nullptr;

    delete ui;
}

bool Form_mainInterface::isTesting()
{
    return m_isTesting;
}

QString Form_mainInterface::getSn()
{
    return m_serialNum;
}

QString Form_mainInterface::getDevName()
{
    return m_devName;
}

SANE_Handle Form_mainInterface::getDevHandle()
{
    return m_handle;
}

hgscanner *Form_mainInterface::getScanner()
{
    return m_hg;
}

void Form_mainInterface::paintEvent(QPaintEvent *event)
{
    (void)event;
    QPainter p(this);
    p.setPen(QColor("gray"));
    p.drawRect(0, 0, width() -1, height() -1);
}

void Form_mainInterface::on_testResult(QString text)
{
    QMessageBox::information(this, tr("tips"), text);
}

void Form_mainInterface::on_testResultImg(void *img)
{
    HGImage image = (HGImage)img;
    ui->stackedWidget->setCurrentWidget(m_view);
    m_view->addImage(image);
    ui->pbtn_leftRotate->setVisible(true);
    ui->pbtn_rightRotate->setVisible(true);

    HGBase_DestroyImage(image);
}

void Form_mainInterface::on_testDistortion(QString name, void *data)
{
    QString info = QString::fromStdWString((const wchar_t*)data);
    QMessageBox msg(QMessageBox::Question, name, info, 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))
    {
        func_test_go(HGPDTTOOLDB_NAME_SINGLE_PAGE_TEST_1, L"null", m_hg);
    }
}

void Form_mainInterface::on_testFinish()
{
    updateUiEnabled(true);
    m_isTesting = false;
}

void Form_mainInterface::on_pbtn_preStep_clicked()
{
    int row = ui->tableWidget->currentRow();
    if (row > 0)
    {
        ui->tableWidget->selectRow(row - 1);
    }
}

void Form_mainInterface::on_pbtn_nextStep_clicked()
{
    int row = ui->tableWidget->currentRow();
    if (row < ui->tableWidget->rowCount() - 1)
    {
        ui->tableWidget->selectRow(row + 1);
    }
}

void Form_mainInterface::on_pbtn_fail_clicked()
{
    int row = ui->tableWidget->currentRow();
    QTableWidgetItem *item = ui->tableWidget->item(row, 1);
    QString title = item->text();

    Dialog_ExcepDesc dlg(this);
    if (dlg.exec())
    {
        ui->tableWidget->setItem(row, 2, new QTableWidgetItem(getItemStatusStr(HGPDTTOOLDB_ENTRYSTATUS_NOTPASS)));
        ui->tableWidget->item(row, 2)->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
        ui->tableWidget->item(row, 2)->setBackgroundColor(QColor(255,0,0));

        QString str = dlg.getExcepDesc();
        setTestItemStatus(title, HGPDTTOOLDB_ENTRYSTATUS_NOTPASS);
        HGPdtToolDb_SetDeviceEntryExcepDesc(m_pdtToolDbDevice, getTestItem(title), str.toStdString().c_str());

        QTableWidgetItem *item2 = ui->tableWidget->item(row, 2);
        item2->setToolTip(str);
    }
}

void Form_mainInterface::on_pbtn_pass_clicked()
{
    int row = ui->tableWidget->currentRow();
    QTableWidgetItem *item = ui->tableWidget->item(row, 1);
    QString title = item->text();
    setTestItemStatus(title, HGPDTTOOLDB_ENTRYSTATUS_PASS);

    ui->tableWidget->setItem(row, 2, new QTableWidgetItem(getItemStatusStr(HGPDTTOOLDB_ENTRYSTATUS_PASS)));
    ui->tableWidget->item(row, 2)->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
    ui->tableWidget->item(row, 2)->setBackgroundColor(QColor(0,255,0));

    HGPdtToolDb_SetDeviceEntryExcepDesc(m_pdtToolDbDevice, getTestItem(title), "");

    QTableWidgetItem *item2 = ui->tableWidget->item(row, 2);
    item2->setToolTip("");

    HGImage img = nullptr;
    m_view->getImage(&img);

    if (img != nullptr)
    {
        QString fileName = getCacheFileName();
        HGResult ret = HGImgFmt_SaveImage(img, 0, 0, getStdString(fileName).c_str());
        if(ret == HGBASE_ERR_OK)
        {
            int row = ui->tableWidget->currentRow();
            QTableWidgetItem *item = ui->tableWidget->item(row, 1);
            QString title = item->text();
            HGUInt entryName = getTestItem(title);

            ret = HGPdtToolDb_UploadDeviceEntryImage(m_pdtToolDbDevice, entryName, m_mainwnd->m_ftpHost.toStdString().c_str(),
                                                     m_mainwnd->m_ftpPort, fileName.toStdString().c_str());
            QFile file(fileName);
            file.remove();
        }
    }

    on_pbtn_nextStep_clicked();
}

void Form_mainInterface::on_pbtn_stop_clicked()
{
    m_mainwnd->RemoveInterface(this);
}

void Form_mainInterface::initTableWidgetUi()
{
    ui->tableWidget->resizeRowsToContents();
    ui->tableWidget->setColumnCount(3);
    ui->tableWidget->horizontalHeader()->setDefaultSectionSize(200);
    ui->tableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
    ui->tableWidget->horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeToContents);

    QStringList header;
    header<< tr("ID") << tr("Test items") << tr("status");
    ui->tableWidget->setHorizontalHeaderLabels(header);

    QFont font = ui->tableWidget->horizontalHeader()->font();
    font.setBold(true);
    ui->tableWidget->horizontalHeader()->setFont(font);

    ui->tableWidget->horizontalHeader()->setStretchLastSection(true);
    ui->tableWidget->verticalHeader()->setDefaultSectionSize(10);
    ui->tableWidget->setFrameShape(QFrame::NoFrame);
    ui->tableWidget->setShowGrid(true);
    ui->tableWidget->verticalHeader()->setVisible(false);
    ui->tableWidget->setSelectionMode(QAbstractItemView::SingleSelection);
    ui->tableWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
    ui->tableWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
    ui->tableWidget->horizontalHeader()->setFixedHeight(30);
    ui->tableWidget->clearContents();
    ui->tableWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
    ui->tableWidget->setStyleSheet("selection-background-color:rgb(193,210,240)");

    HGChar cfgPath[512] = {0};
    HGBase_GetConfigPath(cfgPath, 512);
    HGBase_CreateDir(cfgPath);
    strcat(cfgPath, m_devType.toStdString().c_str());
    strcat(cfgPath, ".json");

    HGResult ret = HGPdtToolDb_DownloadFile(m_pdtToolDbuserMgr, m_devType.toStdString().c_str(), cfgPath);
    if(ret == HGBASE_ERR_OK)
    {
        AnalysisJson analysisJson(QString::fromStdString(cfgPath));

        std::map<HGUInt, bool> dbEntryItems;
        for (int i = HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH; i <= HGPDTTOOLDB_ENTRYNAME_SCANNING_SENSOR; ++i)
            dbEntryItems[i] = false;
        for (int i = HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE; i <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION; ++i)
            dbEntryItems[i] = false;
        for (int i = HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1; i <= HGPDTTOOLDB_ENTRYNAME_CLEAR_ROLLER_COUNT; ++i)
            dbEntryItems[i] = false;

        std::vector<AnalysisJson::json_node> list_jsonNode = analysisJson.GetNode();
        int count = list_jsonNode.size();
        ui->tableWidget->setRowCount(count);
        for(int i = 0; i < count; ++i)
        {
            AnalysisJson::json_node node = list_jsonNode[i];
            m_map_title_name.insert(node.title, node);

            ui->tableWidget->setItem(i, 0, new QTableWidgetItem(QString::number(i+1)));
            ui->tableWidget->item(i, 0)->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);

            ui->tableWidget->setItem(i, 1, new QTableWidgetItem(node.title));
            ui->tableWidget->item(i, 1)->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);

            HGUInt status = getTestItemStatus(node.title);
            QString statusStr = getItemStatusStr(status);
            ui->tableWidget->setItem(i, 2, new QTableWidgetItem(statusStr));
            ui->tableWidget->item(i, 2)->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
            if (HGPDTTOOLDB_ENTRYSTATUS_NOTPASS == status)
            {
                ui->tableWidget->item(i, 2)->setBackgroundColor(QColor(255,0,0));
            }
            else if (HGPDTTOOLDB_ENTRYSTATUS_NOTSUPP == status)
            {
                ui->tableWidget->item(i, 2)->setBackgroundColor(QColor(255,255,0));
            }
            else if (HGPDTTOOLDB_ENTRYSTATUS_PASS == status)
            {
                ui->tableWidget->item(i, 2)->setBackgroundColor(QColor(0,255,0));
            }

            HGUInt entry = getTestItem(node.title);
            std::map<HGUInt, bool>::iterator iter;
            for (iter = dbEntryItems.begin(); iter != dbEntryItems.end(); ++iter)
            {
                if (entry == iter->first)
                {
                    iter->second = true;
                    break;
                }
            }

            HGChar desc[512] = {0};
            HGPdtToolDb_GetDeviceEntryExcepDesc(m_pdtToolDbDevice, getTestItem(node.title), desc, 512);
            QTableWidgetItem *item = ui->tableWidget->item(i, 2);
            item->setToolTip(desc);
        }

        std::map<HGUInt, bool>::iterator iter;
        for (iter = dbEntryItems.begin(); iter != dbEntryItems.end(); ++iter)
        {
            if (!iter->second)
            {
                HGPdtToolDb_SetDeviceEntryStatus(m_pdtToolDbDevice, iter->first, HGPDTTOOLDB_ENTRYSTATUS_NOTSUPP);
            }
        }

        ui->tableWidget->selectRow(0);
    }
}

HGUInt Form_mainInterface::getTestItem(const QString &title)
{
    HGUInt entry = 0;
    for (int i = 0; i < sizeof(Rela) / sizeof(RELA); ++i)
    {
        if (0 == wcscmp(title.toStdWString().c_str(), Rela[i].title))
        {
            entry = Rela[i].entryName;
            break;
        }
    }

    return entry;
}

HGUInt Form_mainInterface::getTestItemStatus(const QString &title)
{
    HGUInt status = 0;
    for (int i = 0; i < sizeof(Rela) / sizeof(RELA); ++i)
    {
        if (0 == wcscmp(title.toStdWString().c_str(), Rela[i].title))
        {
            HGPdtToolDb_GetDeviceEntryStatus(m_pdtToolDbDevice, Rela[i].entryName, &status);
            break;
        }
    }

    return status;
}

bool Form_mainInterface::setTestItemStatus(const QString &title, HGUInt status)
{
    bool ret = false;
    for (int i = 0; i < sizeof(Rela) / sizeof(RELA); ++i)
    {
        if (0 == wcscmp(title.toStdWString().c_str(), Rela[i].title))
        {
            if (HGBASE_ERR_OK == HGPdtToolDb_SetDeviceEntryStatus(m_pdtToolDbDevice, Rela[i].entryName, status))
                ret = true;
            break;
        }
    }

    return ret;
}

QString Form_mainInterface::getItemStatusStr(HGUInt status)
{
    static const QString statusStr[] = {tr("not test"), tr("not pass"), tr("not support"), tr("pass") };
    return statusStr[status];
}

QString Form_mainInterface::getCachePath()
{
    HGChar cachePath[512];
    HGBase_GetTmpPath(cachePath, 512);
    strcat(cachePath, "/Cache/");

    return getStdFileName(StdStringToUtf8(cachePath).c_str());
}

QString Form_mainInterface::getCacheFileName()
{
    QString cachePath = getCachePath();
    HGBase_CreateDir(getStdString(cachePath).c_str());

    char uuid[256] = {0};
    HGBase_GetUuid(uuid, 256);
    QString suffix = ".jpg";
    QString fileName = getStdFileName(cachePath + uuid + suffix);
    return fileName;
}

void Form_mainInterface::updateUiEnabled(bool enable)
{
    ui->tableWidget->setEnabled(enable);
    ui->pbtn_preStep->setEnabled(enable);
    ui->pbtn_nextStep->setEnabled(enable);
    ui->pbtn_pass->setEnabled(enable);
    ui->pbtn_fail->setEnabled(enable);
    ui->pbtn_start->setEnabled(enable);
    ui->pbtn_showImg->setEnabled(enable);
    ui->pbtn_leftRotate->setEnabled(enable);
    ui->pbtn_rightRotate->setEnabled(enable);
    ui->pbtn_stop->setEnabled(enable);
}

void Form_mainInterface::on_tableWidget_currentItemChanged(QTableWidgetItem *current, QTableWidgetItem *previous)
{
    (void)previous;
    ui->pbtn_showImg->setVisible(false);
    ui->pbtn_leftRotate->setVisible(false);
    ui->pbtn_rightRotate->setVisible(false);
    int row = current->row();
    int count = ui->tableWidget->rowCount();
    ui->pbtn_preStep->setEnabled(row != 0);
    ui->pbtn_nextStep->setEnabled(row != count- 1);

    QTableWidgetItem *item2 = ui->tableWidget->item(row, 1);
    QString title = item2->text();

    bool man = m_map_title_name.value(title).is_man;
    ui->pbtn_start->setEnabled(!man);

    m_textTips->setViewContent(m_map_title_name.value(title).desc);
    ui->stackedWidget->setCurrentWidget(m_textTips);
    m_view->clearImage();

    HGUInt entryName = getTestItem(title);
    if (HGBASE_ERR_OK == HGPdtToolDb_CheckDeviceEntryImage(m_pdtToolDbDevice, entryName))
    {
        ui->pbtn_showImg->setVisible(true);
    }
}

void Form_mainInterface::on_pbtn_start_clicked()
{
    int row = ui->tableWidget->currentRow();
    QTableWidgetItem *item = ui->tableWidget->item(row, 1);
    QString title = item->text();
    QString name = m_map_title_name.value(title).name;
    int ret = func_test_go(name.toStdWString().c_str(), L"null", m_hg);
    if (SCANNER_ERR_OK == ret)
    {
        updateUiEnabled(false);
        m_isTesting = true;
    }
    else
    {
        updateUiEnabled(true);
        m_isTesting = false;
    }
}

void Form_mainInterface::on_pbtn_showImg_clicked()
{
    QString fileName = getCacheFileName();

    int row = ui->tableWidget->currentRow();
    QTableWidgetItem *item = ui->tableWidget->item(row, 1);
    QString title = item->text();
    HGResult ret = HGPdtToolDb_DownloadDeviceEntryImage(m_pdtToolDbDevice, getTestItem(title), m_mainwnd->m_ftpHost.toStdString().c_str(),
                                         m_mainwnd->m_ftpPort, fileName.toStdString().c_str());
    if(ret == HGBASE_ERR_OK)
    {
        ui->pbtn_leftRotate->setVisible(true);
        ui->pbtn_rightRotate->setVisible(true);
        ui->stackedWidget->setCurrentWidget(m_view);
        HGImage img;
        HGImgFmt_LoadImage(fileName.toStdString().c_str(), 0, 0, 0, 0, &img);
        m_view->addImage(img);
        QFile file(fileName);
        file.remove();
    }
    else
    {
        QMessageBox::information(this, tr("tips"), tr("no image"));
    }
}

void Form_mainInterface::on_pbtn_leftRotate_clicked()
{
    m_view->rotateLeft();
}

void Form_mainInterface::on_pbtn_rightRotate_clicked()
{
    m_view->rotateRight();
}