#include "mainwidget.h"
#include <QPushButton>
#include <QDebug>
#include <QCoreApplication>

#include "Public.h"

#include <QPainter>
#include <QImage>
#include <QRgb>
#include <QDebug>
#include <QScrollBar>
#include <algorithm>
#include <QFontMetrics>
#include <QChar>
#include <stdlib.h>
#include <unistd.h>
#include <string>
#include "DevOp.h"
#include "Public.h"
#include "scene/picscene.h"
#include <QGraphicsItem>
#include "MyInputMethod.h"
#include <QTextBlockFormat>
#include <QTextCodec>
#include <QTextDocumentWriter>
#include <QProcess>
#include "VerBVersion.h"
#include <iostream>
#include <string>
#include "scene/PicDateItem.h"
#include "scene/PicScheduleShiftItem.h"
#include "scene/piccodeitem.h"
#include <QElapsedTimer>
#include <QScroller>

extern MyInputMethod *myInputMethod;
unsigned char test_flag,open_close;
#pragma execution_character_set("utf-8")

MainWidget::MainWidget(QWidget* parent)
    : QWidget(parent)
{
    // 加载UI文件
    ui.setupUi(this);

    // 关联成员变量到UI控件
    m_EditBtn = ui.m_EditBtn;
    m_AddBtn = ui.m_AddBtn;
    m_MainBtn = ui.m_MainBtn;
    m_ManageBtn = ui.m_ManageBtn;
    m_MsgBtn = ui.m_MsgBtn;
  //  m_TextEdit = ui.m_TextEdit;
    m_PrintDisplay = ui.widgetPrintTextDisplay;
    m_CloseBtn = ui.m_CloseBtn;
    m_StopBtn = ui.m_StopBtn;
    m_StartBtn = ui.m_StartBtn;
//    m_ToolBtn = ui.m_ToolBtn;
    m_RightBtn = ui.m_RightBtn;
    m_LeftBtn = ui.m_LeftBtn;

    m_PrintDisplay->update();

    pushButtonFlag = true;
    m_2sFlag = false;
    // 初始化信号槽连接
    init();

    m_fileManageWidget = new FileManageWidget();

//    ui.labelRunStatus->setWordWrap(true);

//    ui.sub3->installEventFilter(this);
//    ui.fra_state->installEventFilter(this);
    ui.labelTotalProductCnt->hide();
    ui.lb_counter->hide();

    changeHighLight(false);
    enablePrintButton(false);


    QWidget* viewport = ui.scrollArea->viewport();

    // 捕获鼠标左键拖动手势（桌面端）
    QScroller::grabGesture(viewport, QScroller::LeftMouseButtonGesture);
    // 如需同时支持触摸屏，可加上触屏手势
    QScroller::grabGesture(viewport, QScroller::TouchGesture);

    QScroller* scroller = QScroller::scroller(viewport);
    QScrollerProperties properties = scroller->scrollerProperties();

    // 启用惯性滚动
    properties.setScrollMetric(QScrollerProperties::DecelerationFactor, 0.7);
    // 防止过小的移动被误判为拖拽
    properties.setScrollMetric(QScrollerProperties::DragStartDistance, 0.002);

    scroller->setScrollerProperties(properties);
    scroller->grabGesture(ui.scrollArea->viewport(), QScroller::LeftMouseButtonGesture);

    connect(ui.btn_newFile, &QPushButton::clicked, this, &MainWidget::newFileAcquired);

    m_reclaimOpenBtnFlashTimer = new QTimer(this);
    connect(m_reclaimOpenBtnFlashTimer, &QTimer::timeout, this, &MainWidget::onReclaimOpenBtnFlashTimerTimeout);
    m_reclaimOpenBtnFlashTimer->setInterval(500);
}

MainWidget::~MainWidget()
{
    delete m_fileManageWidget;
}

void MainWidget::init()
{   
    airPushTimer = new QTimer(this);
    connect(airPushTimer, SIGNAL(timeout()), this, SLOT(airPushingProcess()));

    timerPowerOff = new QTimer(this);
    connect(timerPowerOff,SIGNAL(timeout()),this,SLOT(sendPowerOffCmd()));

    // 信号槽连接
    connect(m_EditBtn, &QPushButton::clicked, this, &MainWidget::buttonClickedSlot);
    connect(m_AddBtn, &QPushButton::clicked, this, &MainWidget::buttonClickedSlot);
    connect(m_CloseBtn, &QPushButton::clicked, this, &MainWidget::buttonClickedSlot);
    connect(m_MainBtn,&QPushButton::clicked,this,&MainWidget::buttonClickedSlot);
    connect(m_MsgBtn,&QPushButton::clicked,this,&MainWidget::buttonClickedSlot);

    if (!m_setNumDlg){
        m_setNumDlg = new SetNumDlg(this);
    }
    connect(m_setNumDlg, &SetNumDlg::sig_setNum, this, &MainWidget::slt_setNum);
    connect(m_setNumDlg, &SetNumDlg::sig_clearCnt, this, &MainWidget::slt_clearCnt);
}

void MainWidget::buttonClickedSlot()
{
    QPushButton* btn = qobject_cast<QPushButton*>(sender());
    if (btn == m_EditBtn)
    {
        emit sendButtonClickedSignal(1);
    }
    else if (btn == m_AddBtn)
    {
        emit sendButtonClickedSignal(2);
    }
    else if (btn == m_CloseBtn)
    {
//        emit sendButtonClickedSignal(3);
        _on_pushButtonPowerOff_pressed(true);
    }
    else if(btn == m_MainBtn){
        emit sendButtonClickedSignal(4);
    }
    else if(btn == m_MsgBtn){
        emit sendButtonClickedSignal(5);
    }
}

QStringList stringListRecive;

void MySleep(unsigned int msec);

void MySleep(unsigned int msec)
{

    QTime dieTime = QTime::currentTime().addMSecs(msec);

    while( QTime::currentTime() < dieTime )

        QCoreApplication::processEvents(QEventLoop::AllEvents, 100);

}

void MainWidget::bindTxTEdit(QTextEdit* textEdit){
    m_textEdit = textEdit;
}

void MainWidget::bindPicScene(PicScene* pPicScene){
    this->pPicScene = pPicScene;
}

void MainWidget::bindSysPara(SysPara *sysPara){
    this->sysPara = sysPara;
   // ui->textEditOption->bindSysPara(sysPara);
    m_PrintDisplay->bindSysPara(sysPara);
#ifdef _2DCODE_
//    barcode->bindSysPara(sysPara);
//    dlgqrcode->setSysPara(sysPara);
//    dlgqrcode->barCodeFlag =  this->sysPara->para.qrOption.barCodeFlag;
//    dlgqrcode->SetOption((qrOption_t*)&sysPara->para.qrOption);
#endif
#ifdef PICSCENE
  //  ui->senceEditOption->bindSysPara(sysPara);
#endif
}

void MainWidget::_on_pushButtonPowerOff_pressed(bool notice)
{
    if(!sysPara)
        return;

    // 回收槽检查
    if(sysPara->status.currReclaimTankPos != 0)
    {
        QMessageBox::StandardButton ret = QMessageBox::Ok;
        if(notice) {
            ret = QMessageBox::warning(this, tr("警告"), tr("回收槽未关，是否关闭回收槽后关机!"), QMessageBox::Ok | QMessageBox::Cancel);
        }

        if (!notice || ret == QMessageBox::Ok) {
            system((char *)((QString("mkdir %1").arg(TESTDIR)).toLatin1().data()));
            system((char *)((QString("cp %1/*.bin %2/. ").arg(PARA_ROOT_DIR).arg(TESTDIR)).toLatin1().data())); //先备份UP*
            sysPara->status.reclaimCloseCnt=10;
            //on_pushButtonStopPrint_pressed();
            on_m_StopBtn_clicked();
            on_m_LeftBtn_clicked();
            //on_pushButtonReclaimTankClose_pressed();
            sysPara->status.powerOffAppending = true;
            setReclaimCloseBtnStatus(false);
            setReclaimOpenBtnStatus(false);
        }
    }
    else {
        QMessageBox::StandardButton ret = QMessageBox::Ok;
        if(notice) {
            ret = QMessageBox::warning(this, tr("警告"), tr("是否确认关机?"), QMessageBox::Ok | QMessageBox::Cancel);
        }

        if (!notice || ret == QMessageBox::Ok){
            sysPara->status.powerOffAppending = true;
            checkForPowerOff();
        }
    }
}


/*
 *  关机前务必保存参数
 * */
void MainWidget::checkForPowerOff(){
    if(sysPara->status.powerOffAppending){
        if(!sysPara->status.selfCheckDone)
            sysPara->status.selfCheckDone = true;
        this->setDisabled(true);
        emit setDisableAll();
////////关机时提高转速和回收泵压力，粘度泵和循环阀/////
        quint16 gearPumpValue_backup = sysPara->para.gearPumpValue;
        int reclaimPumpPWMWidth_backup = sysPara->para.reclaimPumpPWMWidth;;
        if(!(sysPara->status.statWarn & WARN_STATUS_INK_WARN))
        {
            if(!TEST_MODE && sysPara->para.flagOfReclaimPumEnable){
                for(int i=25;i>21;i--)
                {
                    if(i == 25){
                        sysPara->status.isPumpValveControledByHand = true;		//停止自动
                        sysPara->devOp->controlInkValve(true);
                        sysPara->devOp->controlInkValvePWM(true);
                        sysPara->devOp->controlReclaimPump(true,true);
                        sysPara->devOp->controlViscosityPump(true);
                        sysPara->devOp->controlCycleValve(true);
                        sysPara->para.gearPumpValue = 0;
                        sysPara->devOp->WriteMoterPump();
                    }
                    if(i == 22){
                        sysPara->devOp->controlInkValve(false);
                        sysPara->devOp->controlInkValvePWM(false);
                    }
                    this->setRunStatus(tr("正在准备关机,请等待%1秒...").arg(i*2));
                    MySleep(2000);
                }
            }
            sysPara->devOp->controlReclaimTankOpen(true);
            sysPara->status.isPumpValveControledByHand = true;		//停止自动
            if(sysPara->para.gearPumpEnable ){
                if(!sysPara->para.flagOfReclaimPumEnable){
                    sysPara->para.gearPumpValue = 360;
                    sysPara->devOp->WriteMoterPump();
                }
                else{
                    sysPara->devOp->controlReclaimPump(true,false);
                    sysPara->para.gearPumpValue = 0;
                    sysPara->devOp->WriteMoterPump();
                }
            }
            else{
                sysPara->para.reclaimPumpPWMWidth = 95;
                sysPara->devOp->controlReclaimPump(true,true);
            }

            if(!sysPara->devOp->isViscosityPumpOpen())
                sysPara->devOp->controlViscosityPump(true);
            sysPara->devOp->controlCycleValve(true);
            sysPara->devOp->controlInkValve(false);		//关供墨
            sysPara->devOp->controlInkValvePWM(false);		//关供墨

            if(!TEST_MODE){
                for(int i=14;i>7;i--)
                {
                    if(i==13)
                        sysPara->devOp->controlReclaimTankOpen(false);
                    this->setRunStatus(tr("正在准备关机,请等待%1秒...").arg(i*3));
                    MySleep(3000);
                }
            }

            if(!sysPara->status.lostCommuFlag){
                sysPara->para.calandar_and_dat.cnt1CurrValue = QString::number(sysPara->status.calandar_and_dat.cnt1CurrValue,16).toInt();
                sysPara->para.calandar_and_dat.cnt2CurrValue = QString::number(sysPara->status.calandar_and_dat.cnt2CurrValue,16).toInt();
                sysPara->para.Counter3.cnt3CurrValue = QString::number(sysPara->status.Status_Counter3.cnt3CurrValue,16).toInt();

                updateTotalCnt(0);
                sysPara->saveParaToFile();					// 关机前将相关配置保存
            }
            sysPara->status.powerOffAppending = false;
            if(!TEST_MODE){
                for(int i=7;i>0;i--)
                {
                    if(i == 3)
                         sysPara->devOp->controlReclaimTankClose(true);
                    if(i == 2){
                        sysPara->devOp->controlViscosityPump(false);
                        sysPara->devOp->controlCycleValve(false);
                        sysPara->devOp->controlReclaimPump(false,false);
                        sysPara->para.gearPumpValue = 0;
                        sysPara->devOp->WriteMoterPump();
                    }
                    this->setRunStatus(tr("正在准备关机,请等待%1秒...").arg(i*3));
                    MySleep(3000);
                }
            }
        }
        emit CloseJd();
        sysPara->para.gearPumpValue=gearPumpValue_backup;
        sysPara->para.reclaimPumpPWMWidth = reclaimPumpPWMWidth_backup;
        sysPara->devOp->controlCompressPump(false);
        setRunStatus(tr("准备关机..."));

        sysPara->para.totalProductCnt +=sysPara->status.totalProductCnt;
        sysPara->devOp->clearProductCnt(3 | 0x10);//总产器计数器立即清零
        sysPara->para.ReadFileErrorCnt=0;
        sysPara->para.PowerOnErrorCnt=0;
        if(sysPara->para.isCntSaveStateValue)
        {
            sysPara->para.cnt1CurrValue = QString::number(sysPara->status.calandar_and_dat.cnt1CurrValue,16).toInt();
            sysPara->para.cnt2CurrValue = QString::number(sysPara->status.calandar_and_dat.cnt2CurrValue,16).toInt();
            sysPara->para.cnt3CurrValue = QString::number(sysPara->status.Status_Counter3.cnt3CurrValue,16).toInt();
        }
        updateTotalCnt(0);
        sysPara->saveParaToFile();					// 关机前将相关配置保存
        sysPara->saveRFIDPara();
        system("sync");//缓存同步

        timerPowerOff->start(1000);
    }
}

static int numOfPowerOffCMD = 0;
void MainWidget::sendPowerOffCmd(){
    if(++numOfPowerOffCMD == 6){
        sysPara->devOp->color_flag = 2;
        setRunStatus(tr("关机失败!!!"));
        timerPowerOff->stop();
        numOfPowerOffCMD = 0;
        return;
    }
    sysPara->devOp->powerOff();
}

void MainWidget::powerOffConfirmed(){
    timerPowerOff->stop();
    QProcess process;
    process.startDetached("poweroff");
    qApp->exit(0);
}

void MainWidget::setRunStatus(QString str){

    ui.lb_nozzleState->setText(str);
}

/* 生成字模数据  */
void MainWidget::generateCharRamData()
{
    if(!sysPara->status.variNum)
        return;

    QTextEdit textEdit;
    textEdit.document()->setDocumentMargin(0);
    textEdit.setLineWrapMode(QTextEdit::NoWrap);
    int ramAddress = 0;
    int i;
    qDebug()<<"sysPara->status.variNum:"<<sysPara->status.variNum;
    for( i = 0; i < sysPara->status.variNum; i++){
        vars_t *p_var = &sysPara->status.vars[i];
        p_var->bassAddr = -1;
        if(p_var->original){				//清除原来的记录
            if(p_var->dat){
                free(p_var->dat);
            }
            p_var->original = false;
        }

        int j;

        int width;
        if(p_var->bassAddr == -1){
            if(sysPara->para.flagOfModuleDecimal || sysPara->para.flagOfModuleHide)
                width = (p_var->digitalNum)?(13*(p_var->width/p_var->digitalNum)):12;
            else
                width = (p_var->digitalNum)?(10*(p_var->width/p_var->digitalNum)):12;
            int width2 = width;//+(sysPara->status.addSpace?width:0);
            int height = p_var->height;

            textEdit.clear();
            int DPI = textEdit.logicalDpiX();
            DPI = DPI?DPI:1;	//Pixel = DPI * Point / 72

            if(sysPara->para.flagOfModuleDecimal || sysPara->para.flagOfModuleHide){
                textEdit.insertHtml(QString("<span style=\" font-family:'%1'; font-size:%2pt;  font-weight:%3;\">0123456789.m </span>")
                                    .arg(Public::getFontFamily(height,p_var->type))  // 20160812 增加横向字体 p_var->type <9 正常， p_var->type 20～28 左横  p_var->type 40～48 右横
                                    .arg(height*96/DPI).arg(p_var->bold?600:400));	//600表示加粗，400表示普通
            }else{
                textEdit.insertHtml(QString("<span style=\" font-family:'%1'; font-size:%2pt;\">0123456789</span>")
                                    //   .arg(p_var->bold?ui->textEditOption->getFamilyName(height):(Public::getFontFamily(height,p_var->type)))  // 20160812 增加横向字体 p_var->type <9 正常， p_var->type 20～28 左横  p_var->type 40～48 右横
                                    .arg(Public::getFontFamily(height,p_var->type))
                                    .arg(height*96/DPI));
            }

            QFont font = textEdit.font();
            font.setLetterSpacing(QFont::AbsoluteSpacing,p_var->letterSpace);
            textEdit.setFont(font);

            qDebug() << "Generate char, letter space: " << p_var->letterSpace << "font height: " << height;

            int imgHeight = height + 12;
            QSize size(width,imgHeight);
            QImage image(size,QImage::Format_ARGB32);
            image.fill(0x00ffffff);
            QPainter painter(&image);
            textEdit.show();				//如果不显示，似乎不会绘制

            textEdit.document()->drawContents (&painter, image.rect());		/*将text写到pic*/

            QString fileName = "/home/plg/doc/002.html";
            QTextDocumentWriter writer(fileName);
            bool success = writer.write(textEdit.document());

            textEdit.hide();
            image.save(QString::number(i) + "varRam.png");
            // 找到最下面的行
            int lastValidRow = 0;
            for(int k = imgHeight - 1; k >= 0 ; k--){
                for(int j = 0; j < width; j ++){
                    QRgb rgb = image.pixel(j,k);
                    if(rgb&0xff000000){
                        lastValidRow = k + 1;
                        break;
                    }
                }
                if(lastValidRow != 0)
                    break;
            }

            qDebug()<<"lastValidRow"<<lastValidRow;
            qDebug()<<"GetData"<<p_var->endRowPos<< p_var->startRowPos;
            int rowDiff = p_var->endRowPos - p_var->startRowPos;
            int firstValidRow = 0; // 变量的第一行所处的行地址
            int firstValidRowDiff;// 看起来和上面的参数一样
            qDebug()<<"rowDiff"<<rowDiff;

            if(lastValidRow >= rowDiff){
                firstValidRow = lastValidRow - rowDiff;
                firstValidRowDiff = firstValidRow;
            }
            else {
                firstValidRow = 0;
                firstValidRowDiff = lastValidRow > rowDiff;
            }


            firstValidRow = firstValidRow >= 0?firstValidRow:0;			//纠正

            int rowByteNum = rowDiff/8 + ((rowDiff%8)?1:0); // 一列占用字节数
            unsigned char *dat = (unsigned char *)calloc(width2,rowByteNum);
            for(int k = firstValidRow; k < lastValidRow; k++){

                for(int j = 0; j < width; j ++){
                    QRgb rgb = image.pixel(j,k);

                    int currRow = k - firstValidRowDiff;
                    if(((rgb >> 24)&0xff) > 0x80){ // 判断是否有效的像素点
                        dat[rowByteNum*(j+(sysPara->status.addSpace?j:0) )+ currRow/8] |= (1<<(currRow%8));
                    }
                    else{
                    }
                }
            }
            p_var->bassAddr = ramAddress;
            p_var->datHeight = height;

            p_var->datWidth = width2;
            p_var->rowByteNum = rowByteNum;
            p_var->dat = dat;
            p_var->original = true;
            p_var->currVal = -1;		//相当于初始化
            ramAddress += rowByteNum * width2;
        }
    }
    
}

QList<QRect> MainWidget::variableItemsUpdate()
{
    if(!pPicScene) {
        return QList<QRect>();
    }

    int totalOfProcessedDots = 0;
    int totalOfDatetimeNumber = 0;
    int nbInvaliedDatetimePreview = 0;
    int nbClipDatetimePreview = 0;

    QList<QRect> updateAreas;

    auto items = pPicScene->items();
    for(auto i : items) {
        PicTextItem* item = dynamic_cast<PicTextItem*>(i);
        if(!item)
            continue;

        if(item->sourceType() != SourceType::DATETIME && item->sourceType() != SourceType::SCHEDULE_SHIFT && item->sourceType() != SourceType::CODE)
            continue;

        if(item->sourceType() == SourceType::DATETIME) {
            auto dateTimeItem = dynamic_cast<PicDateItem*>(item);
            if(!dateTimeItem)
                continue;

            auto b = dateTimeItem->updateDatetimeStr();
            if(!b)
                continue;
        }

        if(item->sourceType() == SourceType::SCHEDULE_SHIFT) {
            auto scheduleShiftItem = dynamic_cast<PicScheduleShiftItem*>(item);
            if(!scheduleShiftItem)
                continue;

            auto b = scheduleShiftItem->updateScheduleName();
            if(!b)
                continue;
        }

        if(item->sourceType() == SourceType::CODE) {
            auto codeItem = dynamic_cast<PicCodeItem*>(item);
            if(!codeItem)
                continue;
            
            QVector<int> counterValus{QString::number(sysPara->status.calandar_and_dat.cnt1CurrValue,16).toInt(), 
                    QString::number(sysPara->status.calandar_and_dat.cnt2CurrValue,16).toInt()};
            auto b = codeItem->updateVariants(counterValus);
            if(!b)
                continue;
        }

        QImage img = item->preview();
        if(img.isNull()) {
            ++nbInvaliedDatetimePreview;
            continue;
        }

        auto sceneRect = pPicScene->sceneRect().toRect();
        auto boundingRect = pPicScene->itemsBoundingRect().toRect();
        QRect itemRect(item->pos().x() - boundingRect.x(), item->pos().y() - boundingRect.y(), img.width(), img.height());
        totalOfDatetimeNumber++;
        
        // 裁剪item位置, 确保item位于场景内
        // 如果item超出了场景范围，则裁剪img并更新itemRect，只显示场景内的部分
        QRect intersectRect = itemRect.intersected(sceneRect);
        
        if(!intersectRect.isEmpty() && intersectRect != itemRect) {
            // 计算裁剪区域在原图中的偏移
            int cropX = qMax(0, (int)(intersectRect.left() - itemRect.left()));
            int cropY = qMax(0, (int)(intersectRect.top() - itemRect.top()));
            int cropWidth = (int)intersectRect.width();
            int cropHeight = (int)intersectRect.height();
            
            // 裁剪图像
            img = img.copy(cropX, cropY, cropWidth, cropHeight);
            
            // 更新itemRect为裁剪后的区域
            itemRect = intersectRect;

            ++nbClipDatetimePreview;
        }

        totalOfProcessedDots += imageToPrintData(img, (int)itemRect.left(), (int)itemRect.top());

        updateAreas.append(itemRect);
    }

    if(updateAreas.isEmpty())
        return updateAreas;

    // 把 updateAreas 里 x 轴相交或相连的矩形合并，避免某些区域重复更新而导致的串口资源浪费
    std::sort(updateAreas.begin(), updateAreas.end(), [](const QRect &a, const QRect &b) {
        if (a.left() != b.left())
            return a.left() < b.left();
        return a.right() < b.right();
    });

    QList<QRect> mergedAreas;
    mergedAreas.append(updateAreas.first());
    for (int i = 1; i < updateAreas.size(); ++i) {
        QRect current = updateAreas.at(i);
        QRect &last = mergedAreas.last();
        if (last.right() + 1 >= current.left()) {
            int left = qMin(last.left(), current.left());
            int right = qMax(last.right(), current.right());
            int top = qMin(last.top(), current.top());
            int bottom = qMax(last.bottom(), current.bottom());
            last = QRect(QPoint(left, top), QPoint(right, bottom));
        } else {
            mergedAreas.append(current);
        }
    }

    return mergedAreas;
}

int MainWidget::imageToPrintData(QImage &image, int startX, int startY)
{
    int totalOfProcessedDots = 0;

    if(image.isNull()) 
        return 0;
    
    unsigned char *dat = sysPara->status.flagOfNo67FPGA ? 
                            sysPara->status.printDat_Normal : sysPara->status.printDat;
    
    int width = image.width();
    int height = image.height();
    int wStart = startX;
    
    for(int j = 0; j < width; j++)
    {
        unsigned char c = 0;
        int hStart = startY;
        
        c = dat[wStart * MAX_PRINT_ROW_BYTE_NUM + (hStart) / 8];
        
        for(int k = 0; k < height; k++)
        {
            QRgb rgb = image.pixel(j, k);
            if(((rgb >> 24) & 0xff) > 0x80)
            {
                c |= (1 << (hStart % 8));
            }
            else
            {
                c &= ~(1 << (hStart % 8));
            }
            
            if(hStart % 8 == 7) {
                dat[wStart * MAX_PRINT_ROW_BYTE_NUM + (hStart) / 8] = c;
                c = dat[wStart * MAX_PRINT_ROW_BYTE_NUM + (hStart + 1) / 8];
                ++totalOfProcessedDots;
            }
            hStart++;
        }
        
        dat[wStart * MAX_PRINT_ROW_BYTE_NUM + (hStart) / 8] = c;
        wStart++;
        totalOfProcessedDots++;
    }

    return totalOfProcessedDots;
}

void MainWidget::enablePrintButton(bool enable){
#ifdef QT_DEBUG
    enable = true;
#endif

#ifdef FPGA_TEST
    enable = true;
#endif

    m_StartBtn->setEnabled(enable);
    m_StopBtn->setEnabled(enable);
}

void MainWidget::updateTotalCnt(int en)
{
    // No50 USEING
    //sysPara->para.totalProductCnt += (sysPara->status.productCnt>sysPara->status.lastProductCnt)?sysPara->status.productCnt-sysPara->status.lastProductCnt:
    //                                                                                             (sysPara->status.productCnt>=0&&sysPara->status.productCnt<20)?sysPara->status.productCnt:0;
    //if(en) sysPara->para.totalProductCnt=0;

    //sysPara->para.totalProductCnt = sysPara->status.totalProductCnt;  // No51版本改进
    sysPara->status.lastProductCnt = sysPara->status.productCnt;
    ui.labelProductCnt->setText(QString::number(sysPara->status.productCnt));
//    ui.labelTotalProductCnt->setText(QString::number( sysPara->para.totalProductCnt+sysPara->status.totalProductCnt));
    // 20260410 总数栏改为预设数值栏
    if (m_setNumDlg->getIsSet() && m_setNumDlg->getNum() > 0 &&
            sysPara->status.productCnt == m_setNumDlg->getNum()) {
        LogInfo::setRunStatusText(QString("productCnt:%1  setNum:%2")
                                  .arg(sysPara->status.productCnt).arg(m_setNumDlg->getNum()));
        on_m_StopBtn_clicked();
    }
}

void MainWidget::on_m_StartBtn_clicked()
{
    if(sysPara->status.isPrinting){
        qDebug("Mainwindow:  Printing 开始打印");
    }else{
        qDebug("Mainwindow:  Non printing 开始打印");
    }
    static int fileCount = 0;
    fileCount++;
    if(fileCount > 5)
    {
        fileCount = 1;
    }

    if(sysPara){
        bool MaxCol4000;
        if(sysPara->status.flagOfNo67FPGA)
            MaxCol4000 = true;
        else
            MaxCol4000 = false;
        test_flag = 0;
        /******2020/2/29*****/
        if(sysPara->para.printTriggerMode == PRINT_TRIGGER_SYNCHRONIZER)   //同步模式下，判断喷印间隔是否设置合理
        {
            QSizeF size = m_textEdit->document()->size();
            float stroke,print_len_min;
            stroke = sysPara->para.printColDelay/sysPara->para.synPulseNumPerMm;
            print_len_min = stroke * size.width();
            if(print_len_min > sysPara->para.synTriggerPrintLenMm && !sysPara->para.charWidthSetEnable)
            {
                QMessageBox::information(this,tr("错误"),tr("喷印间隔过短,应高于%1!").arg(print_len_min));
                return;
            }
        }
        /******2020/2/29 end*****/
        #ifndef QT_DEBUG
        if(!SIMULATE_PRINTING_MODE){
            if (!sysPara->status.reclainTankReachEnd) {
                return;
            }
            if((sysPara->status.statWarn & WARN_STATUS_HDINT)){
                QMessageBox::information(this,tr("错误"),tr("喷头盖未关,请先关喷头盖!"));
                return ;
            }
            if((sysPara->status.statWarn & WARN_STATUS_INK_SWINT)){
                QMessageBox::information(this,tr("错误"),tr("墨线未开，请先开墨线开关!"));
                return ;
            }
        }
        #endif

        sysPara->devOp->highVoltageCtrl(1);
        sysPara->devOp->setHighVoltageAmplitudetoSTM32();
        sysPara->status.waitHightVolOff = 0;
//        if(!printintFlag)setRunStatus(tr("正在加高压..."));
        // 复位计数器
        if(sysPara->status.FileChangeRestCntFlag){
            if(sysPara->para.ResetAllProductCntEn)
            {
                sysPara->devOp->clearProductCnt(3 | 0x10); // [3]总产品计数器清零FPGA
                sysPara->para.totalProductCnt=0;
            }
            else if(sysPara->para.ResetProductCntEn)
            {
                sysPara->devOp->clearProductCnt(3);
            }
            sysPara->status.FileChangeRestCntFlag=0;
            sysPara->saveParaToFile();
        }
        
        if(sysPara->para.EditMode == SCENE)
            onPreviewScene();

        if(sysPara->status.currPrintCol > (MaxCol4000?MAX_PRINT_COL_NUM_Normal:MAX_PRINT_COL_NUM_Wide)){
            QMessageBox::critical(0,tr("错误"),tr("当前总列数 %1 ,支持的总列数为 %2,请减少打印串的长度").arg(sysPara->status.currPrintCol).arg((MaxCol4000?MAX_PRINT_COL_NUM_Normal:MAX_PRINT_COL_NUM_Wide)));
            return ;
        }
        if(!((sysPara->para.printTriggerMode == PRINT_TRIGGER_SYNCHRONIZER)
             ||((sysPara->para.printTriggerMode == PRINT_TRIGGER_ELEC_EYE_VOLTATE_LEVEL
                 ||sysPara->para.printTriggerMode == PRINT_TRIGGER_ELEC_EYE_EDGE)
                && sysPara->para.eleEyeTriggerSynPrintEn))
                )
        {
            int dotNumPerCol = sysPara->status.currPrintRow*(1 + sysPara->para.printRowDelay) + sysPara->para.printColDelay;
            long printTmUs = 1.0f*dotNumPerCol*(1 + sysPara->para.charBold)*sysPara->status.currPrintCol*(2*sysPara->para.divideRatio)/(FPGA_SYS_HZ/1000000);
            if((printTmUs/1000  + 3) > (sysPara->para.printDelayMs)
                    && (sysPara->para.timeTriggerPrintMode == TIME_TRIGGER_PRINT_MODE_HEAD_TO_HEAD)
                    && (sysPara->para.printTriggerMode == PRINT_TRIGGER_TIME )
                    ) // 在电眼方式下，是否需要判呢？
            {
                QMessageBox::critical(0,tr("错误"),tr("打印耗时 %1ms ,触发间隔 :%2ms ,触发间隔至少应当大于打印耗时3ms").arg(printTmUs/1000).arg(sysPara->para.printDelayMs));
                return ;
            }
        }
        sysPara->status.isPrinting=false;


        SendPrintDataToFpga(0);  // 0－－正常打印，1－－打印交替部分信息1; 2－－打印交替部分信息2,

        /*-------------------------------------------------------------------*/
//        ui->labelSynColDelay->setText("");
        sysPara->status.lastSynColDelay = -1;			//目的是为了清空原来的数据

        /*---------------------------------开关回收槽------------------------------*/
        
        setReclaimCloseBtnStatus(false);
        setReclaimOpenBtnStatus(false);

        updatePrintDisplayLabel();
        // 20170717 移动此，以观察条形码打印异常问题。
        if(!startPrintingFlag)
        {
            sysPara->devOp->printCtrl(PRINT_CTRL_START);
            printintFlag = true;
        }

        startPrintingFlag = true;
        sysPara->status.isPrinting=true;

        // 高亮切换
        changeHighLight(true);

        LogInfo::setRunStatusText("Start print...");
    }
}

void MainWidget::on_m_StopBtn_clicked()
{
    if(sysPara->status.isPrinting){
        qDebug("Mainwindow:  Printing 停止打印");
    }else{
        qDebug("Mainwindow:  Non printing 停止打印");
    }

    if(sysPara){
        if (!sysPara->status.reclainTankReachEnd && !SIMULATE_PRINTING_MODE) {
            return;
        }
//        sysPara->status.flagOfAbnormalStatus = false;
        sysPara->status.isPrinting=false;
        sysPara->devOp->printCtrl2(1);
        sysPara->devOp->printCtrl( PRINT_CTRL_STOP);//:PRINT_CTRL_STOPSYNCNT
//        LogInfo::setRunStatusText(tr("停止打印"));

        setReclaimCloseBtnStatus(sysPara->status.currReclaimTankPos != 0);
        setReclaimOpenBtnStatus(sysPara->status.currReclaimTankPos == 0);

        printintFlag = false;
        startPrintingFlag = false;
        updatePrintDisplayLabel();
        sysPara->status. waitHightVolOff = 1;
        sysPara->saveParaToFile();					// 将相关配置保存

        if(sysPara->status.RandomBackCnt>5 && (sysPara->status.RandomNum>0))
        {
            QMessageBox::StandardButton ret;
            ret = QMessageBox::warning(this, tr("提示"),
                                       tr("随机码文本将展出到U盘，请插入U盘"),
                                       QMessageBox::Ok | QMessageBox::Cancel);
            if (ret == QMessageBox::Ok){
//                LogInfo::setRunStatusText("正在导出随机码文件到U盘......");
                sysPara->devOp->RandTxtBakup(0); //备份到U盘
//                LogInfo::setRunStatusText("随机码文件导出完成.");

            }
        }
        // 高亮切换
        changeHighLight(false);

        LogInfo::setRunStatusText("Stop print...");
    }
}

unsigned char blankDat1[BLANK_COL_NUM*MAX_PRINT_ROW_BYTE_NUM]={0};
void MainWidget::SendPrintDataToFpga(unsigned char alterMode, int startCol, int size)
{
    if(!sysPara) return ;
//    fileChange=false;

    Q_UNUSED(alterMode);

    // 看清楚，最后取反，也就是说，如果不是局部更新，则写入打印设置和变量控制
    if(!(startCol >= 0 && size > 0 && size - startCol >= 1)) {
        sysPara->devOp->writeFpgaPrintPara(1);
        sysPara->devOp->writeFpgaVariCtrl();
        startCol = 0;
        size = sysPara->status.currPrintCol;
    }

    sysPara->devOp->fpgaWr(0,blankDat1,sizeof(blankDat1));//...所加的空白偏移地址
    // 交替打印处理
    unsigned char *dat;
    size_t sizeofdat;
    bool MaxCol4000;
    if(sysPara->status.flagOfNo67FPGA)
        MaxCol4000 = true;
    else
        MaxCol4000 = false;
    if(MaxCol4000){
        dat =sysPara->status.printDat_Normal;
        sizeofdat = sizeof(sysPara->status.printDat_Normal);
    }else{
        dat =sysPara->status.printDat;
        sizeofdat = sizeof(sysPara->status.printDat);
    }

    dat = dat + startCol * MAX_PRINT_ROW_BYTE_NUM;
    size = size * MAX_PRINT_ROW_BYTE_NUM;

    if(size <= 20000)
        sysPara->devOp->fpgaWr(sizeof(blankDat1), dat, size);
    else
        sysPara->devOp->fpgaWrD2(sizeof(blankDat1), dat, size);

    static QElapsedTimer bnsTimer;
    static uint64_t nbRestartCount = 0;
    ++nbRestartCount;
    if(nbRestartCount >= 10) {
        auto elapsed = bnsTimer.restart();
        qDebug() << (QString("SendPrintDataToFpga avg elapsed: %1 s").arg(elapsed / qreal(nbRestartCount) / 1000.0));
        nbRestartCount = 0;
    }
}

int MainWidget::getCurrPrintStatus()
{
    int printStatus;
    if (startPrintingFlag ) {
        if(printintFlag) {
            printStatus = 1;   // 正在打印
        }
        else {
            printStatus = 2;   // 暂停喷印
        }
    }
    else {
        printStatus = 3;      // 停止打印
    }
    return printStatus;
}

void MainWidget::setReclaimOpenBtnStatus(bool enable)
{
    #ifdef __RFID_CARD
    if(sysPara->RFIDPara.inkCardTimeOut
            || sysPara->RFIDPara.solventCardTimeOut
            || sysPara->RFIDPara.needMaintenance) {
        enable = false;
    }
    #endif

    enable = !sysPara->status.airPushing && enable;

    ui.m_RightBtn->setEnabled(enable);
}

void MainWidget::setReclaimCloseBtnStatus(bool enable)
{
    ui.m_LeftBtn->setEnabled(enable);
}

/**
 * @brief 翻转回收槽开启按钮的背景颜色
 * 每次调用在 #BCBFC4 和 #FFD700 之间交替切换
 */
void MainWidget::flashReclaimOpenBtn()
{
    m_reclaimFlashState = !m_reclaimFlashState;
    ui.lb_RightBtn->setStyleSheet(m_reclaimFlashState ? "background-color:#FFD700;" : "background-color:#BCBFC4;");
}

void MainWidget::stopFlashReclaimOpenBtn()
{
    // 如果电机运行时间为0 就不暂停
    if (sysPara == nullptr
            ||sysPara->status.curr_reclaimTankTime == 0
            ||sysPara->status.currReclaimTankPos == 0)
        return;

    LogInfo::setRunStatusText("m_reclaimOpenBtnFlashTimer stop");
    m_reclaimOpenBtnFlashTimer->stop();
    m_reclaimFlashState = true;
    flashReclaimOpenBtn();
}

void MainWidget::setReclaimStatus(bool isOpen, int rate)
{
    if (isOpen) {
        if (!sysPara->status.airPushing) {
            QString str = rate == 100? tr("喷嘴已开启"):tr("喷嘴开启中");
            ui.lb_RightBtn->setText(str);
        }
        ui.lb_LeftBtn->setText(tr("喷嘴关闭"));

    } else {
        QString str = rate == 0? tr("喷嘴已关闭"):tr("喷嘴关闭中");
        ui.lb_LeftBtn->setText(str);

        if (!sysPara->status.airPushing) {
            ui.lb_RightBtn->setText(tr("喷嘴开启"));
        }
    }
}

static int mainInkPumpCtrlStatus = 0;
static int mainInkPumpCtrlCnt = 0;
//100ms 为单位
void MainWidget::airPushingProcess()
{
    if(sysPara){
        if (sysPara->status.airPushing) {
            // 执行排气 7 秒
            
            QString labelTxt = tr("正在排气...");
            setRunStatus(labelTxt);
            ui.lb_RightBtn->setText(labelTxt);
            setReclaimOpenBtnStatus(false);
            setReclaimCloseBtnStatus(false);

            ++sysPara->status.airPushingOnTime;
            if(sysPara->status.airPushingOnTime >= 50) {
                static int delayCount = 0;
                ++delayCount;
                m_2sFlag = true;
                //sysPara->devOp->controlInkValve(false); //关供墨阀
                if(delayCount >= 40)
                {
                    m_2sFlag = false;
                }

                if(delayCount >= 60)
                {
                    delayCount = 0;
                    airPushTimer->stop();
                    sysPara->devOp->controlViscosityPump(false);
                    reclaimTanOpen();
                    //qDebug()<< "start stop";
                    sysPara->status.airPushingDone = 1;
                    sysPara->status.airPushing = 0;
                    sysPara->status.airPushingOnTime = 0;
                }
                return;
            }

            if (sysPara->status.airPushingOnTime%10 >= 5) {
                sysPara->devOp->controlCycleValve(true);
            }
            else {
                sysPara->devOp->controlCycleValve(false);
            }
            if (mainInkPumpCtrlStatus == 0) {
                if(++mainInkPumpCtrlCnt > 15) { //100ms 为单位, 时间到关闭
                    sysPara->devOp->controlMainInkPump(false);
                    sysPara->devOp->mainInkCtrl();
                    mainInkPumpCtrlStatus = 1;
                    mainInkPumpCtrlCnt = 0;
                }
            }
            else if (mainInkPumpCtrlStatus == 1) { //100ms 为单位, 时间到开启
                sysPara->devOp->controlMainInkPump(true);
                sysPara->devOp->mainInkCtrl();
                mainInkPumpCtrlStatus = 2;
            }
            else if (mainInkPumpCtrlStatus == 2) {
                if(++mainInkPumpCtrlCnt>7) {
                    sysPara->devOp->controlMainInkPump(false);
                    sysPara->devOp->mainInkCtrl();
                    mainInkPumpCtrlStatus = 3;
                    mainInkPumpCtrlCnt = 0;
                }
            }
            else if (mainInkPumpCtrlStatus == 3) {
                if(++mainInkPumpCtrlCnt>8) {
                    sysPara->devOp->controlMainInkPump(true);
                    sysPara->devOp->mainInkCtrl();
                    mainInkPumpCtrlStatus = 4;
                    mainInkPumpCtrlCnt = 0;
                }
            }
            else if (mainInkPumpCtrlStatus == 4) {
                if(++mainInkPumpCtrlCnt>8) {
                    sysPara->devOp->controlMainInkPump(false);
                    sysPara->devOp->mainInkCtrl();
                    mainInkPumpCtrlStatus = 3;
                    mainInkPumpCtrlCnt = 0;
                }
            }
        }
    }
}

void MainWidget::reclaimTanOpen()
{
    // 还原当前模式
    if (sysPara->status.airPushing) {
        sysPara->status.isPumpValveControledByHand = sysPara->status.byHandStore;
    }
    sysPara->status.isPumpValveControledByHand = false;
    sysPara->devOp->mainInkCtrl();
    sysPara->devOp->controlReclaimTankClose(false);//开回收槽之前先让关回收槽停止
    MySleep(1000);
    sysPara->devOp->controlReclaimTankOpen(!sysPara->devOp->isReclaimTankOpenEnable());
    sysPara->devOp->highVoltageCtrl(0);		/*回收槽动作的时候务必关高压*/
//    sysPara->status.reclaimTankstatus = 1;
//    setRunStatus(sysPara->devOp->isReclaimTankOpenEnable()?tr("正在打开回收槽..."):tr("停止打开"));
    setReclaimStatus(true, 0);
    if (!sysPara->para.reclaimTankTime) {
//        LogInfo::setRunStatusText(tr("警告!回收槽开关时间未设置!"));
    } else {
        
    }

    sysPara->status.currReclaimOperationCnt = 0;
    sysPara->status.reclainTankReachEnd = false;
    sysPara->status.reclainOpenAppending = true;
    sysPara->status.reclainCloseAppending = false;
    sysPara->status.reclaimBlockedCnt = 0;
    sysPara->status.canRunAirPushing = false;

    if (sysPara->status.reclainTankReachEnd)
        enablePrintButton(SIMULATE_PRINTING_MODE);
}

void MainWidget::initSheet()
{
    // 仅当前按钮生效
    QString startBtnSheet = R"(
                       QPushButton {
                       background-color: #1e8449;
                       color: #99A89B;
                       border-radius: 5px;
                       }
                       QPushButton:disabled {
                       background-color: #bdc3c7;  /* 灰色背景 */
                       color: #7f8c8d;            /* 灰色文字 */
                       border: 1px solid #95a5a6; /* 灰色边框 */
                       }
                       )";

    ui.m_StartBtn->setStyleSheet(startBtnSheet);

    QString stopBtnSheet =  R"(
                            QPushButton {
                            background-color: #D5614E;
                            color: #99A89B;
                            border-radius: 5px;
                            }
                            QPushButton:disabled {
                            background-color: #bdc3c7;  /* 灰色背景 */
                            color: #7f8c8d;            /* 灰色文字 */
                            border: 1px solid #95a5a6; /* 灰色边框 */
                            }
                            )";

    ui.m_StopBtn->setStyleSheet(stopBtnSheet);

    constexpr char* reclaimBtnNormalStyle = R"(
        QToolButton {
            padding: 16px 16px;
            border-radius: 6px;
            color: #333333;  /* 深灰文字，与蓝色图标协调 */

            /* 中性色背景，略带渐变制造立体感 */
            background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                                            stop: 0 #eefaff,
                                            stop: 1 #ceefff);
            border: 1px solid #a1a1a1;
        }

        QToolButton:hover {
            background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                                            stop: 0 #F5F7FA,
                                            stop: 1 #E8EBF0);
            border-color: #B0B6BE;
        }

        QToolButton:pressed {
            background-color: #D5D8DD;
            border-color: #A8AEB6;
        }

        QToolButton:disabled {
            color: #A0A5AB;
            background-color: #BCBFC4;
            border: 1px solid #BCBFC4;
        }
        )";


    ui.m_RightBtn->setMinimumHeight(95);
    ui.m_LeftBtn->setMinimumHeight(95);
    ui.m_LeftBtn->setFixedHeight(95);
    ui.m_RightBtn->setFixedHeight(95);
    ui.m_RightBtn->setStyleSheet(reclaimBtnNormalStyle);
    ui.m_LeftBtn->setStyleSheet(reclaimBtnNormalStyle);

    // QString lbSheet = R"(
    //                   QLabel {
    //                   border: 1px solid #95a5a6; /* 灰色边框 */
    //                   }
    //                   )";
    // ui.lb_LeftBtn->setStyleSheet(lbSheet);
    // ui.lb_RightBtn->setStyleSheet(lbSheet);
}

void MainWidget::changeHighLight(bool isStart)
{
    initSheet();
    if (isStart) {
        QString highlightStyle =
                R"(
                QPushButton {
                    background-color: #29B561;
                    color: black;
                    border-radius: 5px;
                    border: 3px solid #f39c12;
                    box-shadow: 0 0 8px rgba(231, 76, 60, 0.6);
                }

                QPushButton:disabled {
                background-color: #bdc3c7;  /* 灰色背景 */
                color: #7f8c8d;            /* 灰色文字 */
                border: 1px solid #95a5a6; /* 灰色边框 */
                }
            )";
        m_StartBtn->setStyleSheet(highlightStyle);


    } else {
        QString highlightStyle =
                R"(
                QPushButton {
                background-color: #e55f5f;
                color: black;
                border-radius: 5px;
                border: 3px solid #f39c12;
                box-shadow: 0 0 8px rgba(231, 76, 60, 0.6);
                }
                QPushButton:disabled {
                background-color: #bdc3c7;  /* 灰色背景 */
                color: #7f8c8d;            /* 灰色文字 */
                border: 1px solid #95a5a6; /* 灰色边框 */
                }
            )";
        m_StopBtn->setStyleSheet(highlightStyle);
    }
}

void MainWidget::on_m_RightBtn_clicked()
{
    if(sysPara){
        if (!sysPara->status.reclaimTankBlockedAppending) {
            if (sysPara->status.canRunAirPushing &&
                    (sysPara->status.currReclaimTankPos == 0)) { //2019/10/24 当回收槽未在顶的位置，不需要排气
                // Pos == 0 回收槽关闭的情况下才可以执行排气; 先执行排气后开回收槽
                if (!sysPara->status.airPushing) {
                    //排气：打印、暂停打印置灰
                    enablePrintButton(false);

                    sysPara->status.byHandStore = sysPara->status.isPumpValveControledByHand;
                    sysPara->status.isPumpValveControledByHand = true;
                    sysPara->devOp->mainInkCtrl();
                    sysPara->devOp->controlCycleValve(true);
                    sysPara->devOp->controlViscosityPump(false);//关粘度泵
                    sysPara->devOp->controlMainInkPump(true);//主墨泵敞开
                    sysPara->devOp->mainInkCtrl();
                    sysPara->devOp->controlReclaimPump(true, false); // 回收泵开
                    sysPara->devOp->controlInkValve(true); //墨水阀
                    sysPara->devOp->controlInkValvePWM(true); //墨水阀
                    //qDebug()<< "start airpushings";

                    sysPara->status.airPushing = 1;
                    sysPara->status.airPushingDone = 0;
                    sysPara->status.airPushingOnTime = 0;

                    airPushTimer->start(100); // 100ms
                }
            }
            else {
                reclaimTanOpen();
            }
        }
        else if(sysPara->status.reclaimTankBlockedAppending) {
            sysPara->status.reclaimTankBlockedAppending = false;
            QMessageBox::StandardButton ret;
            ret = QMessageBox::warning(this, tr("警告"),
                                       tr("回收槽之前发生阻塞或回收槽时间设置错误，是否强制将当前位置设为到顶位置?"),
                                       QMessageBox::Ok | QMessageBox::Cancel);
            if (ret == QMessageBox::Ok){
                sysPara->para.reclaimTankTime = sysPara->status.currReclaimTankPos/10;
//                onReclainTankPositionChanged(sysPara->para.reclaimTankTime * 10);
            }
        }

        // 喷嘴开启中
        if (m_reclaimOpenBtnFlashTimer && !m_reclaimOpenBtnFlashTimer->isActive()){
            ui.lb_RightBtn->setText(tr("正在排气..."));
            m_reclaimFlashState = true;
            m_reclaimOpenBtnFlashTimer->start();
            LogInfo::setRunStatusText("m_reclaimOpenBtnFlashTimer start");
        }
    }
}

void MainWidget::on_m_LeftBtn_clicked()
{
    if(sysPara){
        if(sysPara->status.reclaimTankBlockedAppending){
            sysPara->status.reclaimTankBlockedAppending = false;
            QMessageBox::StandardButton ret;
            ret = QMessageBox::warning(this, tr("警告"),
                                       tr("回收槽之前发生阻塞或回收槽时间设置错误，是否强制将当前位置设为到顶位置?"),
                                       QMessageBox::Ok | QMessageBox::Cancel);
            if (ret == QMessageBox::Ok){
                sysPara->status.currReclaimTankPos = 0;
//                onReclainTankPositionChanged(0);
            }
        }

        sysPara->devOp->controlReclaimTankClose(!sysPara->devOp->isReclaimTankCloseEnable());
        enablePrintButton(SIMULATE_PRINTING_MODE);
        sysPara->devOp->highVoltageCtrl(0);
//        sysPara->status.reclaimTankstatus = 2;
//        setRunStatus(sysPara->devOp->isReclaimTankCloseEnable()?tr("正在关闭回收槽..."):tr("停止关闭"));
        setReclaimStatus(false, 100);
        if(!sysPara->para.reclaimTankTime){
//            LogInfo::setRunStatusText(tr("警告!回收槽开关时间未设置!"));
        }
        sysPara->status.currReclaimOperationCnt = 0;
        sysPara->status.reclainTankReachEnd = false;
        sysPara->status.reclainOpenAppending = false;
        sysPara->status.reclainCloseAppending = true;
        sysPara->status.reclaimBlockedCnt = 0;

        enablePrintButton(false);

        stopFlashReclaimOpenBtn();
    }
}

void MainWidget::on_m_ManageBtn_clicked()
{
#if defined(ARCH_X86)
    m_fileManageWidget->show();
#else
    m_fileManageWidget->showFullScreen();
#endif
}

void MainWidget::slt_setNum()
{
    // 预设值
    if(m_setNumDlg->getIsSet()) {
        unsigned int num = m_setNumDlg->getNum();
        ui.labelTotalProductCnt->setText(QString::number(num));
        ui.labelTotalProductCnt->show();
        ui.lb_counter->show();
    } else {
        ui.labelTotalProductCnt->hide();
        ui.lb_counter->hide();
    }
}

void MainWidget::slt_clearCnt()
{
    if (sysPara) {
        sysPara->devOp->clearProductCnt(1);//当前产品计数器立即清零
        ui.labelProductCnt->setText("0");
//        SendPrintDataToFpga(0);
    }
}

void MainWidget::onReclaimOpenBtnFlashTimerTimeout()
{
    flashReclaimOpenBtn();
}

static int oldSizeFpga = -1;
static int oldsizeSTM32 = -1;
static int reclaimTankDelay = 0;
void MainWidget::updateSysStatusToUI(){ //100ms
    if(sysPara){
        RefreshStatusLight();
        if(sysPara->status.lastProductCnt != sysPara->status.productCnt){			//产品计数
            updateTotalCnt(0);
        }

        if(sysPara->status.ExpiryDispUpdate >0 )
        {
            sysPara->status.ExpiryDispUpdate--;
            m_PrintDisplay->update();// 2018.5.25
        }
        /*--------------------------------------------------------------------------*/
        //if(sysPara->para.printTriggerMode == PRINT_TRIGGER_SYNCHRONIZER && printintFlag){	//同步器速度
        if((
                    (sysPara->para.printTriggerMode == PRINT_TRIGGER_SYNCHRONIZER)
                    ||(((sysPara->para.printTriggerMode == PRINT_TRIGGER_ELEC_EYE_VOLTATE_LEVEL)
                        ||(sysPara->para.printTriggerMode == PRINT_TRIGGER_ELEC_EYE_EDGE)
                        )&& sysPara->para.eleEyeTriggerSynPrintEn)
                    )
                )//&&printintFlag
        {
            if(sysPara->para.synPulseNumPerMm) {

                unsigned int tmp = ((unsigned int) sysPara->status.synPulseCntPer1s ) & 0xffffff;
                unsigned int mm = tmp /sysPara->para.synPulseNumPerMm * 60;  // 1min总脉冲/毫米脉冲数 = 1min走过的距离mm数
                int dotNum = sysPara->para.divideRatio?(FPGA_SYS_HZ/(sysPara->para.divideRatio*2)):0;// 1s时间内墨点数 （即晶振频率 64000)
                int colNum = sysPara->para.dotNumPerCol?dotNum/sysPara-> para.dotNumPerCol:0;  // 第列可用墨点数 ＝ 1s时间内墨点数/ 列需要墨点数
                int pulseNum = colNum*sysPara->para.synNumPerCol/(1<<8);	//synNumPerCol是被放大后的值

                int maxMM = 0;
                if(!sysPara->para.charWidthSetEnable)
                {
                    if(    (sysPara->status.currPrintRow != 0)
                           && (sysPara->para.printTriggerMode == PRINT_TRIGGER_SYNCHRONIZER)
                           /*&& (sysPara->para.currPrintMode == FAST_PRINT || sysPara->para.currPrintMode == STANDARD_PRINT) */){
                        maxMM = calculateMaxSpeed(pulseNum);
                        maxMM = maxMM *60;
                        if(sysPara->para.alterPrint.enable)
                        {
                            maxMM = maxMM * 2;
                        }
                    }
                    else
                    {
                        maxMM = (pulseNum/sysPara->para.synPulseNumPerMm) * 60;// 列的最大间距
                        //                    qDebug()<< "[Info] OLD COUNT mm" << maxMM;
                    }
                }
                else
                {
                    int pulsePS = getMaxSpeedCalcPara();//No67
                    maxMM = (pulsePS/sysPara->para.synPulseNumPerMm) * 60;// 列的最大间距
                }
//                ui->labelSynRate->setText(tr("%1.%2[%3.%4]米/分").arg(mm/1000).arg(mm%1000,3,10,QLatin1Char('0'))
//                                          .arg(maxMM/1000).arg(maxMM%1000,3,10,QLatin1Char('0')));
                // 20260414  0708:为防止变形，保存两位小数
                ui.lb_curSpeed->setText(tr("%1.%2").arg(mm/1000).arg(mm%1000,2,10,QLatin1Char('0')));
                ui.lb_maxSpeed->setText(tr("%1.%2").arg(maxMM/1000).arg(maxMM%1000,2,10,QLatin1Char('0')));
            }
            else {
            ui.lb_curSpeed->setText("0");
            ui.lb_maxSpeed->setText("0");
            }
//            else
//                ui->labelSynRate->setText("");
            sysPara->status.lastSynPulseCntPer1s = sysPara->status.synPulseCntPer1s;
        }
        else {
            ui.lb_curSpeed->setText("0");
            ui.lb_maxSpeed->setText("0");
        }
//        else
//            ui->labelSynRate->setText("");

        /*--------------------------------------------------------------------------*/
        if(sysPara->status.lastSynColDelay != sysPara->status.synColDelay){
            //			if(sysPara->para.printTriggerMode == PRINT_TRIGGER_SYNCHRONIZER)
            if((sysPara->para.printTriggerMode == PRINT_TRIGGER_SYNCHRONIZER)
                    ||((sysPara->para.printTriggerMode == PRINT_TRIGGER_ELEC_EYE_VOLTATE_LEVEL
                        ||sysPara->para.printTriggerMode == PRINT_TRIGGER_ELEC_EYE_EDGE)
                       && sysPara->para.eleEyeTriggerSynPrintEn))
              //  ui->labelSynColDelay->setText(tr("列延时:%1点").arg(sysPara->status.synColDelay));
            sysPara->status.lastSynColDelay = sysPara->status.synColDelay;
        }
        /*--------------------------------------------------------------------------*/
        static int i=0;
        i++;
        if(sysPara->status.stm32Verion == 0){
            if(i % 10 == 0){
                sysPara->devOp->readSTM32Version();
            }
        }
        if(sysPara->status.stm32Time == 0){
            if(i % 10 == 0){
                sysPara->devOp->readSTM32Time();
            }
        }
        if(sysPara->status.fpgaVersionNum == 0){		//因为进入系统就会进主界面，马上就会将版本号读出
            if(i % 10 == 0){
                sysPara->devOp->readFpgaVersionNum();
                sysPara->devOp->readbuilDat();
            }
//            ui->labelFpgaVersionNum->setText(QString("%1/F%2.%3.%4").arg(SOFTWARE_VER_NUM).arg(0).arg(0).arg(0) );
        }
        else{
            static bool logflag5 = true;
            unsigned int num = sysPara->status.fpgaVersionNum & 0xf000;
            if(num != 0x1000 && num != 0x6000 && num != 0x2000 && num != 0x8000 && logflag5){   //未读取到版本号
                sysPara->status.fpgaVersionNum = 0;
            }
            else if(logflag5){
//                emit readFPGAVersionReady();
                logflag5 = false;
                sysPara->devOp->writeFpgaPrintPara(true);
                QString ARM_Version;
                ARM_Version.sprintf("%d.%d.%02d%s%s", UP_PRINTER_MAJOR_VER, UP_PRINTER_MINOR_VER,UP_PRINTER_RIVISION_VER,SUB_VERSION,SUB_RFID);
//                ui->labelFpgaVersionNum->setText(QString("A%1/F%2.%3.%4").arg(ARM_Version).arg(sysPara->status.fpgaVersionNum >> 12)
//                                                 .arg((sysPara->status.fpgaVersionNum>>8) & 0x0f).arg(sysPara->status.fpgaVersionNum&0xff) );

                QString versionStr = QString("A%1/F%2.%3.%4").arg(ARM_Version).arg(sysPara->status.fpgaVersionNum >> 12)
                        .arg((sysPara->status.fpgaVersionNum>>8) & 0x0f).arg(sysPara->status.fpgaVersionNum&0xff);
                emit showVserionInfo(versionStr);
            }
        }
        static bool logflag6 = false;
        if(!logflag6){
            if(sysPara->status.fpgaVersionNum !=0 && sysPara->status.stm32Verion != 0){
                UpdateUIVersion();
                logflag6 = true;
            }
        }

        bool found_CNT1 = false;
        bool found_CNT2 = false;
        bool found_CNT3 = false;
        bool found_CNT4 = false;
        /*--------------------------------------------------------------------------*/
//        if(sysPara->status.variNum && (ui->stackedWidgetText->currentWidget() == ui->pagePrintTextDisplay)){
        if(sysPara->status.variNum){
            bool updatePrintTextDisplayFlag = false;

            for(int i = 0; i < sysPara->status.variNum; i++){
                int val = 0;
                switch(  Public::getType(sysPara->status.vars[i].type))
                {
                case CALANDAR_YEAR:val = sysPara->status.calandar_and_dat.year;break;
                case CALANDAR_MONTH:val = sysPara->status.calandar_and_dat.month;break;
                case CALANDAR_DAY:val = sysPara->status.calandar_and_dat.day;break;
                case CALANDAR_WEEK:val = sysPara->status.calandar_and_dat.week;break;
                case CALANDAR_HOUR:val = sysPara->status.calandar_and_dat.hour;break;
                case CALANDAR_MINUTE:val = sysPara->status.calandar_and_dat.minute;break;
                case CALANDAR_SECOND:val = sysPara->status.calandar_and_dat.second;break;
                case CALANDAR_CNT1:val = QString::number(sysPara->status.calandar_and_dat.cnt1CurrValue,16).toInt();found_CNT1=true;break;
                case CALANDAR_CNT2:val = QString::number(sysPara->status.calandar_and_dat.cnt2CurrValue,16).toInt();found_CNT2=true;break;
                case CALANDAR_CNT3:val = QString::number(sysPara->status.Status_Counter3.cnt3CurrValue,16).toInt();found_CNT3=true;break;
                case CALANDAR_CNT4:val = QString::number(sysPara->para.cnt4CurrValue,10).toInt();found_CNT4=true;break;
                case RANDOMNUM : val = QString::number(  sysPara->status.calandar_and_dat.RandomValue1, 16).toInt(); break;
                case CALANDAR_XDAY:val = sysPara->status.XXXDay;break;
                case EXPIRYDATE: break;
                default:qDebug() << "error,unknown variable type:" << sysPara->status.vars[i].type;
                }

                if(sysPara->status.vars[i].currVal != val)
                    //{
                    updatePrintTextDisplayFlag = true;
                sysPara->status.vars[i].currVal = val;
                //}

            }
            if(updatePrintTextDisplayFlag)			//减少不必要的刷新动作
            {
                m_PrintDisplay->updateSysStatusToUI();
            }
        }
//        emit setCNT1Select(found_CNT1);
//        emit setCNT2Select(found_CNT2);
//        emit setCNT3Select(found_CNT3);
        if(sysPara->para.isEnableGetDataButton)
        {
        //    ui->pushButtonGetData->setEnabled(true);
        }
        else
        {
        //    ui->pushButtonGetData->setEnabled(false);
        }
        if(TEST_MODE)
            enablePrintButton(true);
//        ui->label_size->setText(tr("%1/%2/%3").arg(sysPara->status.sizeFPGA).arg(sysPara->status.sizequeueFPGA).arg(sysPara->status.sizeSTM32));
        if(oldSizeFpga != sysPara->status.sizeFPGA){
            oldSizeFpga = sysPara->status.sizeFPGA;
        }
        if(oldsizeSTM32 != sysPara->status.sizeSTM32){
            oldsizeSTM32 = sysPara->status.sizeSTM32;
        }

        /*if(sysPara->status.reclaimTankstatus  == 6){
            sysPara->status.flagOfRebootEnable = true;
            reclaimTankDelay = 0;
        }

        if(sysPara->status.flagOfRebootEnable && sysPara->status.reclaimTankstatus != 0
                && sysPara->status.reclaimTankstatus != 6  && sysPara->status.reclaimTankstatus != 3){
            sysPara->status.flagOfRebootEnable = false;
        }*/

        if(sysPara->status.currReclaimTankPos <= 5)
            sysPara->status.flagOfRebootEnable = true;
        else
            sysPara->status.flagOfRebootEnable = false;
        if(sysPara->status.flagOfRebootEnable || TEST_MODE){
        //    ui->pushButton_Reboot->setEnabled(true);
        }else{
        //    ui->pushButton_Reboot->setEnabled(false);
        }
    }
}

bool MainWidget::checkRed(AlarmStatus &status)
{
    if (status.highVoltageFault == DEV_STATUS_RED) {
        m_stateStr = tr("高压故障");
        return true;
    }
    if (status.chargeFault == DEV_STATUS_RED) {
        m_stateStr = tr("相位故障");
        return true;
    }
    if (status.viscosityWarn == DEV_STATUS_RED) {
        m_stateStr = tr("粘度故障");
        return true;
    }
    if (status.recycleWarn == DEV_STATUS_RED) {
        m_stateStr = tr("回收故障");
        return true;
    }
    if (status.solveLevelWarn == DEV_STATUS_RED) {
        m_stateStr = tr("溶液液位");
        return true;
    }
    if (status.inkWaterLevel == DEV_STATUS_RED) {
        m_stateStr = tr("墨水液位");
        return true;
    }
    if (status.inkLeak == DEV_STATUS_RED) {
        m_stateStr = tr("墨水缸满");
        return true;
    }
    if (status.inkSwint == DEV_STATUS_RED) {
        m_stateStr = tr("墨线开关");
        return true;
    }
    return false;
}

bool MainWidget::checkYellow(AlarmStatus &status)
{
    if (status.highVoltageFault == DEV_STATUS_YELLOW) {
        m_stateStr = tr("高压故障");
        return true;
    }
    if (status.chargeFault == DEV_STATUS_YELLOW) {
        m_stateStr = tr("相位故障");
        return true;
    }
    if (status.viscosityWarn == DEV_STATUS_YELLOW) {
        m_stateStr = tr("粘度故障");
        return true;
    }
    if (status.recycleWarn == DEV_STATUS_YELLOW) {
        m_stateStr = tr("回收故障");
        return true;
    }
    if (status.solveLevelWarn == DEV_STATUS_YELLOW) {
        m_stateStr = tr("溶液液位");
        return true;
    }
    if (status.inkWaterLevel == DEV_STATUS_YELLOW) {
        m_stateStr = tr("墨水液位");
        return true;
    }
    if (status.inkLeak == DEV_STATUS_YELLOW) {
        m_stateStr = tr("墨水缸满");
        return true;
    }
    if (status.inkSwint == DEV_STATUS_YELLOW) {
        m_stateStr = tr("墨线开关");
        return true;
    }
    return false;
}

void MainWidget::updateGeneralState(AlarmStatus status)
{
    // 有红则红，全绿则绿，红>黄>绿
    // 检查从后往前判断，因为取最后一个状态QString
    bool isRed = checkRed(status);
    if (isRed) {
        m_stateColor = DEV_STATUS_RED;
    } else {
        bool isYellow = checkYellow(status);
        if (isYellow) {
            m_stateColor = DEV_STATUS_YELLOW;
        } else {
            m_stateColor = DEV_STATUS_GREEN;
            m_stateStr= tr("正常");
        }
    }

    if (m_stateColor == DEV_STATUS_GREEN) {
        ui.fra_state->setStyleSheet("background-color: #ccffcc;");
    } else if (m_stateColor == DEV_STATUS_RED) {
        ui.fra_state->setStyleSheet("background-color: #ff6b6b;");
    } else {
        ui.fra_state->setStyleSheet("background-color: #ffd93c;");
    }
    ui.lb_generalState->setText(m_stateStr);
}


int MainWidget::calculateMaxSpeed(int backup)
{
    float stroke;
    int valid_array;
    int rongdian = 0;
    int mm;
    int oscfreq = 0;

    //    QSizeF size = ui->textEdit->document()->size();

    switch (sysPara->para.oscillatoFreq) {
    case CRYS_64K:
        oscfreq = 64000;
        break;
    case CRYS_83K:
        oscfreq = 83000;
        break;
    case CRYS_96K:
        oscfreq = 96000;
        break;
    case CRYS_128K:
        oscfreq = 128000;
        break;
    default:
        break;
    }
    stroke = sysPara->para.printColDelay/sysPara->para.synPulseNumPerMm;

    rongdian = sysPara->status.currPrintRow * (float)sysPara->para.reducedPixelNumRatio/100;
   valid_array = sysPara->status.currPrintRow - rongdian;

    switch (sysPara->para.currPrintMode) {
    case FAST_PRINT:
        mm = (float)(stroke * oscfreq /(sysPara->status.currPrintRow +1));
        break;
    case STANDARD_PRINT:
        mm = (float)( (stroke * oscfreq) / (valid_array * 2));
        break;
    case SLOW_PRINT_ONE:
        mm = (float)( (stroke * oscfreq) / (valid_array * 3));
        break;
    case SLOW_PRINT_TWO:
        mm = (float)( (stroke * oscfreq) / (valid_array * 4));
        break;
    case SLOW_PRINT_THR:
        mm = (float)( (stroke * oscfreq) / (valid_array * 5));
        break;
    case SLOW_PRINT_FOR:
        mm = (float)( (stroke * oscfreq) / (valid_array * 6));
        break;
    case SLOW_PRINT_FIV:
        mm = (float)( (stroke * oscfreq) / (valid_array * 7));
        break;
    case SLOW_PRINT_SIX:
        mm = (float)( (stroke * oscfreq) / (valid_array * 8));
        break;
    case SLOW_PRINT_SEV:
        mm = (float)( (stroke * oscfreq) / (valid_array * 9));
        break;
    case SLOW_PRINT_EIG:
        mm = (float)( (stroke * oscfreq) / (valid_array * 10));
        break;
    case SLOW_PRINT_NIE:
        mm = (float)( (stroke * oscfreq) / (valid_array * 11));
        break;
    default:
        mm = backup/sysPara->para.synPulseNumPerMm;
        break;
    }

    return mm;

}

int MainWidget::getMaxSpeedCalcPara(){
    sysPara->para.printRowDelay = sysPara->para.currPrintMode;
    if(sysPara->status.isPrinting == false)
        sysPara->status.pixNumPerCol = sysPara->status.currPrintRow;
    else
        sysPara->status.currPrintRow = sysPara->status.pixNumPerCol;
    sysPara->para.pixNumPerCol = sysPara->status.pixNumPerCol;

    sysPara->para.reducedPixelNum = sysPara->para.reducedPixelNumRatio*sysPara->para.pixNumPerCol/100;
    int dotNumPerCol = (sysPara->para.pixNumPerCol- sysPara->para.lineEndAdjustPointCnt)*(sysPara->para.printRowDelay + 1)
            + (sysPara->para.lineEndAdjustPointCnt)*(sysPara->para.lineEndAdjustPointDelay + 1);
    dotNumPerCol = sysPara->para.pixNumPerCol?
                ((dotNumPerCol*(sysPara->para.pixNumPerCol - sysPara->para.reducedPixelNum))/sysPara->para.pixNumPerCol):1;
//    sysPara->para.dotNumPerCol += sysPara->para.printColDelay;
    dotNumPerCol =( sysPara->para.alterPrint.enable)? dotNumPerCol/2:dotNumPerCol;

    int dotNum = sysPara->para.divideRatio?(FPGA_SYS_HZ/(sysPara->para.divideRatio*2)):0;// 1s时间内墨点数 （即晶振频率 64000)
    int colNum = dotNumPerCol?dotNum/dotNumPerCol:0;  // 第列可用墨点数 ＝ 1s时间内墨点数/ 列需要墨点数
    int pulseNum = colNum*sysPara->para.synNumPerCol/(1<<8);	//synNumPerCol是被放大后的值

    return pulseNum;
}

void MainWidget::onPreviewScene()
{
    sysPara->para.EditMode = SCENE;
    pPicScene->clearSelection();

    QRect sceneRect = pPicScene->itemsBoundingRect().toRect();
    QSize size = sceneRect.size();

    if(size.isEmpty()) {
        //场景为空时，渲染空场景并刷新界面
        handleEmptySize();
        return;
    }
    QImage image(size,QImage::Format_ARGB32);
    image.fill(0x00ffffff);//填充白色
    //image.save("./printScene.jpg");//图片
    QPainter painter(&image);
    pPicScene->render(&painter,QRectF(), sceneRect);

    int coldot=0;
    if(sysPara){
        bool MaxCol4000;
        if(sysPara->status.flagOfNo67FPGA)
            MaxCol4000 = true;
        else
            MaxCol4000 = false;
        previewFlag=1;
        sysPara->status.currPrintRow = 0;
        sysPara->status.variNum = 0;
        sysPara->status.QRvariNum = 0;
        unsigned char *dat;
        if(MaxCol4000){
            dat =sysPara->status.printDat_Normal;
            memset(dat,0,sizeof(sysPara->status.printDat_Normal));
        }else{
            dat =sysPara->status.printDat;
            memset(dat,0,sizeof(sysPara->status.printDat));
        }
        //qDebug()<<"Preview:";

        {
            sysPara->status.addSpace = sysPara->para.checkSpace;

            coldot = sceneRect.width();
            if(coldot > (MaxCol4000?MAX_PRINT_COL_NUM_Normal:MAX_PRINT_COL_NUM_Wide))
                coldot = MaxCol4000?MAX_PRINT_COL_NUM_Normal:MAX_PRINT_COL_NUM_Wide;
            int maxPicHeight = MAX_PRINT_ROW_NUM + 12;
            QSize size(coldot,maxPicHeight);

            sysPara->status.currPrintRow =0;
            sysPara->status.currPrintCol = coldot + ( sysPara->status.addSpace?coldot:0) ; //checkSpace

            QImage image(size,QImage::Format_ARGB32);
            image.fill(0x00ffffff);//填充白色
            QPainter painter(&image);
            QRectF validRectF(sceneRect.x(),sceneRect.y(),coldot,maxPicHeight);
            pPicScene->render(&painter,QRectF(),validRectF);
            int firstRow = 0;
            int lastRow = firstRow + MAX_PRINT_ROW_NUM;
            int TempVarNum=0;
            int varLastRow=0;
            lastRow = (lastRow>maxPicHeight)?maxPicHeight:lastRow;

            // 接下来就是要把打印到数据data填充以及确认变量的个数，变量对应的开始列和结束行
            for(int j = 0; j < lastRow - firstRow; j++){  // Y
                for(int i = 0; i < coldot; i++){  //
                    QRgb rgb = image.pixel(i,j + firstRow);
                    if(rgb&0x80000000){		//判断alpha
                        if((rgb & 0xf0f0ff) == 0xf0f000){				//处理变量， 查找左下角，因为同一行的左下角是对齐的 看起来这个颜色是黄色

                            bool foundvar=0;
                            if(j>0){
                                QRgb r_rgb = image.pixel(i,j + firstRow+1);
                                if((r_rgb & 0xf0f0ff) != 0xf0f000 ){foundvar =1;}
                                //QRgb r_rgb = image.pixel(i,j + firstRow-1);if((r_rgb & 0xf0f0ff) == 0xf0f000 )foundvar =0;
                            }
                            if(foundvar){
                                if(sysPara->status.variNum < MAX_VARI_NUM){
                                    sysPara->status.vars[sysPara->status.variNum].startColPos = i+(sysPara->status.addSpace?i:0);
                                    sysPara->status.vars[sysPara->status.variNum].endRowPos = j;
                                    //if(varLastRow<j+1) varLastRow=j+1;
                                    //sysPara->status.variNum ++;TempVarNum++;
                                    //i+=5;//scene 每一行可能都包含变量
                                    //qDebug()<<"VARr:"<<TempVarNum<<i<<j;
                                }
                                else TempVarNum++;
                                //dat[MAX_PRINT_ROW_BYTE_NUM*i + j/8] |= 1 << (j%8);			//画黑点
                            }
                        }

                        else  if( ((rgb & 0xfffff0) == 0x00ff10) || ((rgb & 0xfffff0) == 0x00ff20)  ||((rgb & 0xfffff0) == 0x00ff30)  ){
                            // 0xff00ff01(DMT)  0xff00ff02(QR)  0xff00ff03(BAR)
                            //qDebug()<<"FLAG:"<<i<<j+1<<QString().sprintf("%08X", rgb);
                            if(sysPara->status.QRvariNum>=4)continue;
                            if((rgb & 0x00ffff0) == 0x00ff10) { //MDT
                                sysPara->print.QRvars[sysPara->status.QRvariNum].type=MDT;
                                sysPara->print.QRvars[sysPara->status.QRvariNum].countEn=1;
                                sysPara->print.QRvars[sysPara->status.QRvariNum].Counter=sysPara->status.productCnt;
                                sysPara->print.QRvars[sysPara->status.QRvariNum].startColPos=i+(sysPara->status.addSpace?i:0);
                                sysPara->print.QRvars[sysPara->status.QRvariNum].endRowPos=j+1;
                                if(varLastRow<j+1) varLastRow=j+1;
                                sysPara->status.QRvariNum++;
                            }
                            else if((rgb & 0x00ffff0) == 0x00ff20) { //QR
                                sysPara->print.QRvars[sysPara->status.QRvariNum].type=QR;
                                sysPara->print.QRvars[sysPara->status.QRvariNum].countEn=1;
                                sysPara->print.QRvars[sysPara->status.QRvariNum].Counter=sysPara->status.productCnt;
                                sysPara->print.QRvars[sysPara->status.QRvariNum].startColPos=i+(sysPara->status.addSpace?i:0);
                                sysPara->print.QRvars[sysPara->status.QRvariNum].endRowPos=j+1;
                                if(varLastRow<j+1) varLastRow=j+1;
                                sysPara->status.QRvariNum++;
                            }
                            else if((rgb & 0x00fffff0) == 0x00ff30) { //BAR
                                sysPara->print.QRvars[sysPara->status.QRvariNum].type=BAR;
                                sysPara->print.QRvars[sysPara->status.QRvariNum].countEn=1;
                                sysPara->print.QRvars[sysPara->status.QRvariNum].Counter=sysPara->status.productCnt;

                                sysPara->print.QRvars[sysPara->status.QRvariNum].startColPos=i+(sysPara->status.addSpace?i:0);

                                sysPara->print.QRvars[sysPara->status.QRvariNum].endRowPos=j+1;

                                if(varLastRow<j+1) varLastRow=j+1;
                                sysPara->status.QRvariNum++;

                            }
                            if(sysPara->status.QRvariNum>=4)sysPara->status.QRvariNum=4;

                        }
                        else if((rgb & 0x00ffffff)==EXPIRY_VARI_RECONISE)
                        {   // 有效期变量 : 处理变量， 查找左下角，因为同一行的左下角是对齐的
                            bool foundExVar=0;
                            if(j>0){
                                QRgb r_rgb = image.pixel(i,j + firstRow+1);
                                if((r_rgb & 0x00ffffff) != EXPIRY_VARI_RECONISE ){foundExVar =1;}
                            }
                            if(foundExVar)
                            {
                                if(sysPara->status.ExpiryVarNum <2)
                                {
                                    sysPara->print.ExpiryVar.startColPos = i+(sysPara->status.addSpace?i:0);
                                    sysPara->print.ExpiryVar.endRowPos = j;
                                    if(varLastRow<j+1) varLastRow=j+1;
                                    sysPara->status.ExpiryVarNum ++;
                                    i+=5;
                                }
                                //else TempVarNum++;
                                //dat[MAX_PRINT_ROW_BYTE_NUM*i + j/8] |= 1 << (j%8);			//画黑点
                            }
                        }
                        else if((rgb & 0xfffff0)==0xff0cf0)
                        {   // 有效期变量 : 处理变量， 查找左下角，因为同一行的左下角是对齐的
                            bool foundExVar=0;
                            if(j>0){
                                QRgb r_rgb = image.pixel(i,j + firstRow+1);
                                if((r_rgb & 0xfffff0) != 0xff0cf0 ){foundExVar =1;}
                            }
                            if(foundExVar)
                            {
                                if(sysPara->status.ExpiryVarNum <2)
                                {
                                    sysPara->print.CurDateVar.startColPos = i+(sysPara->status.addSpace?i:0);
                                    sysPara->print.CurDateVar.endRowPos = j;
                                    if(varLastRow<j+1) varLastRow=j+1;
                                    sysPara->status.CurrDateVariNum ++;
                                    i+=5;
                                }
                                //else TempVarNum++;
                                //dat[MAX_PRINT_ROW_BYTE_NUM*i + j/8] |= 1 << (j%8);			//画黑点
                            }
                        }
                        else if((rgb & 0xffffff)==0xff00ff)
                        {   // 有效期变量 : 处理变量， 查找左下角，因为同一行的左下角是对齐的
                            {
                                if(sysPara->status.classVariNum <3) {
                                    EXPIRYVAR_t *currCLass = &sysPara->print.ClassVari ;
                                    currCLass->day = QDateTime::currentDateTime().date().day();
                                    currCLass->startColPos = i+(sysPara->status.addSpace?i:0);
                                    currCLass->endRowPos = j;
                                    if(varLastRow<j+1) varLastRow=j+1;
                                    sysPara->status.classVariNum ++;
                                    i+=5;
                                }
                            }
                        }
                        else
                        {		//Y = 0.299*R' + 0.587*G' + 0.114*B   //非变量
                        int y = (((rgb&0xff)*299 + ((rgb>>8)&0xff)*587 + ((rgb>>16)&0xff)*114))/1000;
                            if(y < 125 ){
                                dat[MAX_PRINT_ROW_BYTE_NUM*(i+(sysPara->status.addSpace?i:0)) + j/8] |= 1 << (j%8);			//画黑点
                                if((j+1) > sysPara->status.currPrintRow) {
                                    sysPara->status.currPrintRow = j+1;
                                }
                            }
                        }

                    }/*判断alpha end*/
                }
            }

            if(TempVarNum>MAX_VARI_NUM){
                setRunStatus(tr("变量数大于8个，某些变量将不起作用!!!"));
                strTitle=  tr("变量数大于8个，某些变量将不起作用!!!");
                strTitle.append("\r\n");
                strTitle.append(tr("请减少信息中的变量(或计数器)数量."));
                QMessageBox::warning(this, tr("警告"),strTitle,QMessageBox::Ok);
            }

            sysPara->status.variNum = 0;
            sysPara->status.ExpiryVarNum = 0;
            sysPara->print.ExpiryVar.startColPos = 0;
            sysPara->print.ExpiryVar.endRowPos = 0;
            sysPara->print.ExpiryVar.letterSpace =0;
            sysPara->print.CurDateVar.startColPos = 0;
            sysPara->print.CurDateVar.endRowPos = 0;
            sysPara->print.CurDateVar.letterSpace = 0;
            sysPara->status.CurrDateVariNum = 0;
            sysPara->status.QRvariNum=0;//lch add
            int myvariNum=0;
            int expiryVarNum = 0;

            QList<QGraphicsItem *> items = pPicScene->items();
            foreach (QGraphicsItem *item, items) {
                PicTextItem *picText = qgraphicsitem_cast<PicTextItem*>(item);
                bool ok;
                int textvariNum=0;

                int textColdot=0;
                textColdot = picText->boundingRect().width();
                if(textColdot > (MaxCol4000?MAX_PRINT_COL_NUM_Normal:MAX_PRINT_COL_NUM_Wide))
                    textColdot = MaxCol4000?MAX_PRINT_COL_NUM_Normal:MAX_PRINT_COL_NUM_Wide;
                int maxTextHeight = MAX_PRINT_ROW_NUM + 12;
                QSize textSize(textColdot, maxTextHeight);
                QImage textImage(textSize,QImage::Format_ARGB32);
                textImage.fill(0x00ffffff);//填充白色
                //image.fill(0x00f0f000);//填充白色
                QPainter textPainter(&textImage);
                //textImage.save("./textImage.jpg");

                //QRectF validtextRectF(picText->pos().x(),picText->pos().y(),textColdot,maxTextHeight);
                QRectF validtextRectF(picText->pos().x(),picText->pos().y(),textColdot,picText->document()->size().height());
                pPicScene->render(&textPainter,QRectF(),validtextRectF);
                //qDebug()<<"validtextRectF:"<<validtextRectF;
                //textImage.save("./textImage.bmp");
                int textFirstRow  = 0;
                //qDebug()<<"textFirstRow:"<<textFirstRow;
                int textLastRow = textFirstRow + MAX_PRINT_ROW_NUM;
                int textItemPosX;
                int textItemPosY;
                textItemPosX = picText->pos().x() - sceneRect.x();
                textItemPosY = picText->pos().y() - sceneRect.y();

                //接下来就是要把打印到数据data填充以及确认变量的个数，变量对应的开始列和结束行
                for(int j = 0; j < textLastRow - textFirstRow; j++){  // Y
                    for(int i = 0; i < textColdot; i++){  //
                        QRgb rgb = textImage.pixel(i,j + textFirstRow);
                        if((rgb&0x80000000)){		//判断alpha
                            if((rgb & 0xf0f0ff) == 0xf0f000){				//处理变量， 查找左下角，因为同一行的左下角是对齐的 看起来这个颜色是黄色

                                bool textfoundvar = 0;
                                if(j>0){
                                    QRgb r_rgb = textImage.pixel(i,j + textFirstRow+1);
                                    if((r_rgb & 0xf0f0ff) != 0xf0f000 )
                                    {
                                        textfoundvar =1;
                                    }

                                }
                                if(textfoundvar){
                                    if(sysPara->status.variNum < MAX_VARI_NUM){
                                        sysPara->status.vars[sysPara->status.variNum].startColPos = i+(sysPara->status.addSpace?i:0)+textItemPosX;
                                        sysPara->status.vars[sysPara->status.variNum].endRowPos = j+textItemPosY;
                                        //qDebug()<<"sysPara->status.variNum:"<<sysPara->status.variNum;
                                        //qDebug()<<"startColPos:"<<sysPara->status.vars[sysPara->status.variNum].startColPos;
                                        //qDebug()<<"endRowPos:"<<sysPara->status.vars[sysPara->status.variNum].endRowPos;
                                        if(varLastRow<j+1)
                                            varLastRow=j+1;
                                        sysPara->status.variNum ++;
                                        textvariNum++;
                                        i+=5;//scene 每一行可能都包含变量
                                        //qDebug()<<"VARr:"<<TempVarNum<<i<<j;
                                        //gItem = pPicScene->itemAt(i,j+firstRow);
                                        //picText_var[i]= (PicTextItem*) gItem;
                                        //picText_var_hash.insert(picText_var[i],i);
                                    }
                                    else
                                    {
                                        textvariNum++;
                                    }
                                }
                            }
                            else  if( ((rgb & 0xfffff0) == 0x00ff10) || ((rgb & 0xfffff0) == 0x00ff20)  ||((rgb & 0xfffff0) == 0x00ff30)  ){
                                // 0xff00ff01(DMT)  0xff00ff02(QR)  0xff00ff03(BAR)
                                //qDebug()<<"FLAG:"<<i<<j+1<<QString().sprintf("%08X", rgb);
                                if(sysPara->status.QRvariNum>=4)continue;
                                if((rgb & 0x00ffff0) == 0x00ff10) { //MDT
                                    sysPara->print.QRvars[sysPara->status.QRvariNum].type=MDT;
                                    sysPara->print.QRvars[sysPara->status.QRvariNum].countEn=1;
                                    sysPara->print.QRvars[sysPara->status.QRvariNum].Counter=sysPara->status.productCnt;
                                    sysPara->print.QRvars[sysPara->status.QRvariNum].startColPos=i+(sysPara->status.addSpace?i:0)+textItemPosX;
                                    sysPara->print.QRvars[sysPara->status.QRvariNum].endRowPos=j+1+textItemPosY;
                                    if(varLastRow<j+1) varLastRow=j+1;
                                    sysPara->status.QRvariNum++;
                                }
                                else if((rgb & 0x00ffff0) == 0x00ff20) { //QR
                                    sysPara->print.QRvars[sysPara->status.QRvariNum].type=QR;
                                    sysPara->print.QRvars[sysPara->status.QRvariNum].countEn=1;
                                    sysPara->print.QRvars[sysPara->status.QRvariNum].Counter=sysPara->status.productCnt;
                                    sysPara->print.QRvars[sysPara->status.QRvariNum].startColPos=i+(sysPara->status.addSpace?i:0)+textItemPosX;
                                    sysPara->print.QRvars[sysPara->status.QRvariNum].endRowPos=j+1+textItemPosY;
                                    if(varLastRow<j+1) varLastRow=j+1;
                                    sysPara->status.QRvariNum++;
                                }
                                else if((rgb & 0x00fffff0) == 0x00ff30) { //BAR
                                    sysPara->print.QRvars[sysPara->status.QRvariNum].type=BAR;
                                    sysPara->print.QRvars[sysPara->status.QRvariNum].countEn=1;
                                    sysPara->print.QRvars[sysPara->status.QRvariNum].Counter=sysPara->status.productCnt;

                                    sysPara->print.QRvars[sysPara->status.QRvariNum].startColPos=i+(sysPara->status.addSpace?i:0)+textItemPosX;

                                    sysPara->print.QRvars[sysPara->status.QRvariNum].endRowPos=j+1+textItemPosY;

                                    if(varLastRow<j+1) varLastRow=j+1;
                                    sysPara->status.QRvariNum++;

                                }
                                if(sysPara->status.QRvariNum>=4)sysPara->status.QRvariNum=4;

                            }
                            //else if((rgb & 0xfffff0)==0xff00f0)
                            else if((rgb & 0x0000ffff)==EXPIRY_VARI_RECONISE)
                            {   // 有效期变量 : 处理变量， 查找左下角，因为同一行的左下角是对齐的
                                //qDebug()<<"found EXPIRY_VARI_RECONISE";
                                bool foundExVar=0;
                                if(j>0){
                                    QRgb r_rgb = textImage.pixel(i,j + firstRow+1);
                                    if(((r_rgb & 0x0000ffff) != EXPIRY_VARI_RECONISE )){foundExVar =1;}
                                }
                                if(foundExVar)
                                {
                                    //if(sysPara->status.ExpiryVarNum <2)
                                    {
                                        //if(sysPara->print.ExpiryVar.endRowPos==0)
                                        if(sysPara->status.ExpiryVarNum == 0)
                                        {
                                            sysPara->status.ExpiryVarNum ++;
                                        }
                                        sysPara->print.ExpiryVar.startColPos = i+(sysPara->status.addSpace?i:0)+textItemPosX;
                                        sysPara->print.ExpiryVar.endRowPos = j+textItemPosY;
                                        if(varLastRow<j+1) varLastRow=j+1;

                                        i+=10;
                                        //qDebug()<<"ExpiryVar ixj:"<<i<<"x"<<j + firstRow;
                                        //qDebug()<<"qqqq textItemPosY:"<<textItemPosY;
                                        //qDebug()<<"qqqq sysPara->print.ExpiryVar.endRowPos:"<<sysPara->print.ExpiryVar.endRowPos;
                                    }
                                    //else TempVarNum++;
                                    //dat[MAX_PRINT_ROW_BYTE_NUM*i + j/8] |= 1 << (j%8);			//画黑点
                                }
                            }
                            else if((rgb & 0xfffff0)==0xff0cf0)
                            {   // 有效期变量 : 处理变量， 查找左下角，因为同一行的左下角是对齐的

                                bool foundExVar=0;
                                if(j>0){
                                    QRgb r_rgb = textImage.pixel(i,j + firstRow+1);
                                    if((r_rgb & 0xfffff0) != 0xff0cf0 ){foundExVar =1;}
                                }
                                if(foundExVar)
                                {
                                    //qDebug()<<"found CurDateVar";
                                    //if(sysPara->status.ExpiryVarNum <2)
                                    {
                                        //if(sysPara->print.CurDateVar.endRowPos==0)
                                        if(sysPara->status.CurrDateVariNum == 0)
                                        {
                                            sysPara->status.CurrDateVariNum ++;
                                            //setRunStatus(QString("CurrDateVariNum(%1)").arg(sysPara->status.CurrDateVariNum));
                                        }
                                        sysPara->print.CurDateVar.startColPos = i+(sysPara->status.addSpace?i:0)+textItemPosX;
                                        sysPara->print.CurDateVar.endRowPos = j + textItemPosY;
                                        //qDebug()<<"CurDateVar ixj:"<<i<<"x"<<j + firstRow;
                                        //qDebug()<<"sysPara->print.CurDateVar.endRowPos:"<<sysPara->print.CurDateVar.endRowPos;
                                        if(varLastRow<j+1) varLastRow=j+1;

                                        i+=10;
                                        //j++;
                                    }
                                    //else TempVarNum++;
                                    //dat[MAX_PRINT_ROW_BYTE_NUM*i + j/8] |= 1 << (j%8);			//画黑点
                                }
                            }

                            if(j > sysPara->status.currPrintRow) {
                                sysPara->status.currPrintRow = j+textItemPosY;
                            }
                        }/*判断alpha end*/
                    }
                }
                //qDebug()<<"ExpiryVarNum:"<<sysPara->status.ExpiryVarNum;
                //===================一般变量=====================
                //myvariNum = 0;
                QString textVariPattern = "<img src=\":/(\\d*)/(\\d*)/../image/digitalWidth(\\d*).bmp\" width=\"(\\d*)\" height=\"(\\d*)\" />";
                QRegExp textrx(textVariPattern);
                QString textHtml = picText->toHtml();
                int from = 0;
                //int myvariNum=0;
                while(from < textHtml.size() && from != -1){
                    from = textHtml.indexOf(textrx,from);

                    if(from != -1){//找到匹配的
                        //qDebug()<<"found variable";
                        from ++;
                        //if(myvariNum < textvariNum)
                        if(myvariNum < sysPara->status.variNum)
                        {
                            sysPara->status.vars[myvariNum].digitalNum = textrx.cap(3).toInt(&ok);//第二个匹配，数字到个数
                            sysPara->status.vars[myvariNum].bold = (sysPara->status.vars[myvariNum].digitalNum%100) == 75;
                            if(sysPara->status.vars[myvariNum].bold)
                                sysPara->status.vars[myvariNum].digitalNum = sysPara->status.vars[myvariNum].digitalNum/100;

                            sysPara->status.vars[myvariNum].type = textrx.cap(2).toInt(&ok);//第一个匹配

                            sysPara->status.vars[myvariNum].width = textrx.cap(4).toInt(&ok)*(sysPara->status.addSpace?2:1);
                            sysPara->status.vars[myvariNum].height = textrx.cap(5).toInt(&ok);
                            //qDebug()<<"myvariNum endRowPos:"<<sysPara->status.vars[myvariNum].endRowPos;
                            //qDebug()<<"myvariNum height:"<<sysPara->status.vars[myvariNum].height;
                            sysPara->status.vars[myvariNum].startRowPos = sysPara->status.vars[myvariNum].endRowPos - sysPara->status.vars[myvariNum].height+1;
                            //sysPara->status.vars[myvariNum].startRowPos = sysPara->status.vars[myvariNum].endRowPos - sysPara->status.vars[myvariNum].height;
                            //qDebug()<<"start row:"<<sysPara->status.vars[myvariNum].startRowPos;
                            if(sysPara->status.vars[myvariNum].startRowPos<0)
                                sysPara->status.vars[myvariNum].startRowPos=0;

                            int item_x_start_pos = sysPara->status.vars[myvariNum].startColPos;
                            int item_x_end_pos = item_x_start_pos + sysPara->status.vars[myvariNum].width ;
                            if(item_x_end_pos > (MaxCol4000?MAX_PRINT_COL_NUM_Normal:MAX_PRINT_COL_NUM_Wide))
                                item_x_end_pos = MaxCol4000?MAX_PRINT_COL_NUM_Normal:MAX_PRINT_COL_NUM_Wide;
                            int item_y_start_pos = sysPara->status.vars[myvariNum].startRowPos;
                            int item_y_end_pos = sysPara->status.vars[myvariNum].endRowPos+1 ;
                            if(item_y_start_pos < 0)
                                item_y_start_pos = 0;
                            for(int i = item_x_start_pos; i < item_x_end_pos; i++){
                                for(int j = item_y_start_pos; j < item_y_end_pos; j++){
                                    dat[MAX_PRINT_ROW_BYTE_NUM*(i+(sysPara->status.addSpace?0:0)) + j/8] &= ~(1 << (j%8));			//将画点取消掉
                                    dat[MAX_PRINT_ROW_BYTE_NUM*(i+(sysPara->status.addSpace?0:0)) + j/8] &= ~(1 << (j%8));
                                }
                            }
                            sysPara->status.vars[myvariNum].height = textrx.cap(5).toInt(&ok)-1;
                            if(sysPara->status.vars[myvariNum].height>16  ){
                                if(sysPara->status.vars[myvariNum].height==24)
                                    ;
                                else {
                                    if(sysPara->status.vars[myvariNum].startRowPos)
                                    {
                                        sysPara->status.vars[myvariNum].endRowPos--;
                                        sysPara->status.vars[myvariNum].startRowPos--;
                                    }
                                }
                            }

                            if(sysPara->status.vars[myvariNum].type ==  RANDOMNUM)
                            {
                                //qDebug()<<"RAND:"<<sysPara->status.vars[myvariNum].type<< sysPara->status.vars[myvariNum].digitalNum;
                                sysPara->status.RandomDigitNum = sysPara->status.vars[myvariNum].digitalNum;
                            }
                            int pixelSize = Public::derivePixelSizeFromHeight(sysPara->status.vars[myvariNum].height);

                            //qDebug()<<"MainWindows"<<sysPara->status.vars[myvariNum].height<<pixelSize;

                            sysPara->status.vars[myvariNum].letterSpace = 0;
                            if(sysPara->status.vars[myvariNum].digitalNum){			//算出letterspace
                                QFont font;
                                //font.setFamily(Public::getFontFamily(pixelSize));
                                font.setFamily(Public::getFontFamily(pixelSize,sysPara->status.vars[myvariNum].type )); // 20160812
                                //pixelSize==7? font.setFamily(ui->textEditOption->getLabelFontFamily()->text()):font.setFamily(Public::getFontFamily(pixelSize, 0));
                                font.setPixelSize(pixelSize);
                                font.setWeight(sysPara->status.vars[myvariNum].bold?QFont::Bold:QFont::Normal);
                                //font.setLetterSpacing(QFont::AbsoluteSpacing,sysPara->para.textEditCharSpace);
                                QFontMetrics fontMetrics(font);
                                int charWidth = (fontMetrics.width("0123456789"))/10 ;
                                // sysPara->status.vars[myvariNum].letterSpace = sysPara->para.textEditCharSpace;
                                sysPara->status.vars[myvariNum].letterSpace = picText->letterSpace();
                                //sysPara->status.vars[myvariNum].letterSpace =
                                //sysPara->status.vars[myvariNum].width/sysPara->status.vars[myvariNum].digitalNum/(sysPara->status.addSpace?2:1) - charWidth;
                            }
                            myvariNum++;
                        }
                    }
                }
                //==========================一般变量结束=======================
            }

            /*--------------------------------------------------------------------------*/
            generateCharRamData();
            if(sysPara->status.currPrintRow>MAX_PRINT_ROW_NUM-1)sysPara->status.currPrintRow=MAX_PRINT_ROW_NUM-1;
            bool found=0;

            lastRow = sysPara->status.currPrintRow;
            //qDebug()<<"lastRow:"<<lastRow;
            for(int j = sysPara->status.currPrintRow; j >2 ; j--){		//计算首行位置
                for(int i = 0; i < coldot; i++){
                    if(dat[MAX_PRINT_ROW_BYTE_NUM*i + j/8] & (1 << (j%8))){
                        lastRow = j+1;
                        found=1;//qDebug()<<"fOUND:"<<i<<j<<dat[MAX_PRINT_ROW_BYTE_NUM*i + j/8]<<sysPara->status.currPrintRow;
                        break;
                    }
                }
                if(found)
                    break;
            }
            if(lastRow>MAX_PRINT_ROW_NUM-1)lastRow = MAX_PRINT_ROW_NUM-1;
            if(lastRow<varLastRow)lastRow= varLastRow-1;//在场景模式下，变量的最低一行并不一定是打印的最后一行

            if(lastRow<1) lastRow =1;
            sysPara->status.currPrintRow =lastRow;

        }

        if(sysPara->status.QRvariNum) {
//            onUpdateDispQRCode(1);
        }
        int wmax = sysPara->status.currPrintRow;
        sysPara->status.currAlterPrintRow = sysPara->status.currPrintRow/2;
        if(sysPara->para.alterPrint.enable<1) sysPara->para.AlterMode=0;
        else {
            if(sysPara->para.AlterMode==0)sysPara->para.AlterMode=1;
            wmax = sysPara->status.currAlterPrintRow;
        }
        /*-------------------------------切换到显示窗口-----------------------------------*/

        qDebug()  << "currPrintCol: " << sysPara->status.currPrintCol;
        LogInfo::setRunStatusText("currPrintCol: " + QString::number(sysPara->status.currPrintCol));
        LogInfo::setRunStatusText("currPrintRow: " + QString::number(sysPara->status.currPrintRow));
        LogInfo::setRunStatusText(QString("Items bounding rect: {%1, %2}").arg(sceneRect.width()).arg(sceneRect.height()));
        
        sysPara->status.currPrintRow = sceneRect.height();
        sysPara->status.currPrintCol = sceneRect.width();
        
        auto rows = sysPara->para.AlterMode?sysPara->status.currAlterPrintRow : sysPara->status.currPrintRow;
        rows = std::max(rows, (m_PrintDisplay->parentWidget()->height() / m_PrintDisplay->currScaleRatio()));
        auto cols = sysPara->status.currPrintCol;
        cols = std::max(cols, (m_PrintDisplay->parentWidget()->width() / m_PrintDisplay->currScaleRatio()));
        m_PrintDisplay->setDisplaySize(cols, rows);
        m_PrintDisplay->update();
    }
    previewFlag=0;
}

void MainWidget::handleEmptySize()
{
    // 初始化空场景的尺寸（默认适配打印最大尺寸，避免界面空白）
    bool MaxCol4000 = sysPara->status.flagOfNo67FPGA ? true : false;
    QSize emptySize(MaxCol4000 ? MAX_PRINT_COL_NUM_Normal : MAX_PRINT_COL_NUM_Wide, MAX_PRINT_ROW_NUM);
    QImage emptyImage(emptySize, QImage::Format_ARGB32);
    emptyImage.fill(0x00ffffff); // 填充白色背景，与正常场景渲染一致
    QPainter emptyPainter(&emptyImage);
    pPicScene->render(&emptyPainter, QRectF(), QRectF(0, 0, emptySize.width(), emptySize.height()));

    // 初始化打印参数，避免空场景导致的参数异常
    previewFlag = 1;
    sysPara->status.currPrintRow = 0;
    sysPara->status.currPrintCol = emptySize.width();
    sysPara->status.variNum = 0;
    sysPara->status.QRvariNum = 0;
    sysPara->status.ExpiryVarNum = 0;
    sysPara->status.CurrDateVariNum = 0;
    sysPara->status.classVariNum = 0;

    // 清空打印数据缓冲区
    unsigned char *dat = MaxCol4000 ? sysPara->status.printDat_Normal : sysPara->status.printDat;
    memset(dat, 0, MaxCol4000 ? sizeof(sysPara->status.printDat_Normal) : sizeof(sysPara->status.printDat));

    // 刷新预览显示，显示空场景（白色背景）
    auto rows = sysPara->para.AlterMode?sysPara->status.currAlterPrintRow : sysPara->status.currPrintRow;
    rows = std::max(rows, (m_PrintDisplay->parentWidget()->height() / m_PrintDisplay->currScaleRatio()));
    m_PrintDisplay->setDisplaySize(m_PrintDisplay->parentWidget()->width() / m_PrintDisplay->currScaleRatio(), rows);
    m_PrintDisplay->update();
    previewFlag = 0;
    return;
}

void MainWidget::updatePrintDisplayLabel() 
{
    m_PrintDisplay->update();
}

void MainWidget::RefreshStatusLight(){//100ms
    if(sysPara){
        static int hdint = 0;
        static int reclainTankReachEnd = 0;
        if((!(sysPara->status.statWarn & WARN_STATUS_HDINT)) && (hdint == 0)) { //喷头盖由开变关
            // 检查回收槽是否到底，到底才能打印
            if (sysPara->status.reclainTankReachEnd) {
                sysPara->devOp->highVoltageCtrl(sysPara->para.HighVoltageAmplitude);
                enablePrintButton(true);
            } else {
                enablePrintButton(false);
            }
        }
        hdint = !(sysPara->status.statWarn & WARN_STATUS_HDINT);

        if(sysPara->status.reclainTankReachEnd && reclainTankReachEnd == 0) { //开回收槽到底
            if (!(sysPara->status.statWarn & WARN_STATUS_HDINT)) { //喷头盖是关闭的状态
                sysPara->devOp->highVoltageCtrl(sysPara->para.HighVoltageAmplitude);
            }
        }
        reclainTankReachEnd = sysPara->status.reclainTankReachEnd;

        if(sysPara->status.lastStatWarn != sysPara->status.statWarn || flagOfClearHighVltageWarnning){
            if(!(sysPara->status.statWarn & WARN_STATUS_INK_SWINT)){//墨线开关
//                ui->labelStatusInkSwint->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMGreen.PNG")));
                alarmStatus.inkSwint = DEV_STATUS_GREEN;
            }
            else {
//                ui->labelStatusInkSwint->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMRed.PNG")));
               alarmStatus.inkSwint = DEV_STATUS_RED;
            }


            if(!(sysPara->status.statWarn & WARN_STATUS_SUMP_WARN)){		//液位渗漏，高电平警告
//                ui->labelStatusInkLeak->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMGreen.PNG")));
                 alarmStatus.inkLeak = DEV_STATUS_GREEN;
            }
            else {
//                ui->labelStatusInkLeak->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMRed.PNG")));
                alarmStatus.inkLeak = DEV_STATUS_RED;
                strTitle = tr("墨水缸满报警");
                if(sysPara->devOp->isMixValveOpen()) {
                    sysPara->devOp->controlMixValve(false); //关掉混合阀
                }
            }
            if(!(sysPara->status.statWarn & WARN_STATUS_INK_WARN)){
//                ui->labelStatusInkWaterLevel->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMGreen.PNG")));
                alarmStatus.inkWaterLevel = DEV_STATUS_GREEN;
            }
            else {
//                ui->labelStatusInkWaterLevel->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMRed.PNG")));
                 alarmStatus.inkWaterLevel = DEV_STATUS_RED;
                strTitle = tr("墨水液位报警");


            }
            if(!(sysPara->status.statWarn & WARN_STATUS_SOLV_WARN)){
//                ui->labelStatusSolvLevelWarn->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMGreen.PNG")));
                 alarmStatus.solveLevelWarn = DEV_STATUS_GREEN;
            }
            else {
//                ui->labelStatusSolvLevelWarn->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMRed.PNG")));
                alarmStatus.solveLevelWarn = DEV_STATUS_RED;
                strTitle = tr("溶剂液位报警");

            }

            if(!(sysPara->status.statWarn & WARN_STATUS_RECYCLE_FAULT) ){
//                ui->labelStatusRecycleWarn->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMGreen.PNG")));
                 alarmStatus.recycleWarn = DEV_STATUS_GREEN;

            }
            else {
//                ui->labelStatusRecycleWarn->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMRed.PNG")));
                alarmStatus.recycleWarn = DEV_STATUS_RED;
            }

            //static int HVfaultCnt=0;
            if(!(sysPara->status.statWarn & WARN_STATUS_POWER_MON)){
                if(!sysPara->status.lastHighVoltageFault)
                {
                    flagOfClearHighVltageWarnning = false;
//                    ui->labelStatusHighVoltageFault->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMGreen.PNG")));
                      alarmStatus.highVoltageFault = DEV_STATUS_GREEN;
                }
                //  HVfaultCnt=0;
                //sysPara->status.HVFaultCloseEn=0;
            }
            else {
//                ui->labelStatusHighVoltageFault->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMRed.PNG")));
                 alarmStatus.highVoltageFault = DEV_STATUS_RED;
                if(startPrintingFlag && printintFlag){		//已经在打印，则暂停打印                               2013-9-15高压报警停止充电
//                    on_pushButtonPausePrint_pressed();
                    on_m_StopBtn_clicked();
                    LogInfo::setRunStatusText(tr("高压故障，暂停打印"));
                    setRunStatus(tr("高压故障，暂停打印"));

                    strTitle = tr("高压故障，暂停打印.");

                    sysPara->status.lastHighVoltageFault = true;
                }

                if((sysPara->status.currReclaimTankPos != 0) &&  sysPara->para.HVFaultCloseEn )
                {
                    //HVfaultCnt++;
                    //  高压故障关回收槽
                    if(sysPara->status.HVFaultCloseEn==0){
                        sysPara->status.reclaimTankBlockedAppending=0;
                        sysPara->status.reclaimCloseCnt=100;
//                        on_pushButtonReclaimTankClose_pressed();
                        on_m_LeftBtn_clicked();
                        sysPara->status.reclaimTankBlockedAppending=1;
                        LogInfo::setRunStatusText(tr("高压故障，关回收槽"));
                        setRunStatus(tr("高压故障，关回收槽和墨线"));
                    }
                    sysPara->status.HVFaultCloseEn=1;
                }
            }

        }

        /*-----------------------------------------------------------------------------------*/
        sysPara->status.lastStatWarn = sysPara->status.statWarn;
        if(sysPara->status.lastViscosityFault != sysPara->status.viscosityFault){
            if(sysPara->status.viscosityFault==0){
//                ui->labelStatusViscosityWarn->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMGreen.PNG")));
                 alarmStatus.viscosityWarn = DEV_STATUS_GREEN;
            }
            else {
                if(sysPara->status.viscosityFault==1){

//                    ui->labelStatusViscosityWarn->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMRed.PNG")));
                    alarmStatus.viscosityWarn = DEV_STATUS_RED;
                }
                else if(sysPara->status.viscosityFault==2) {
//                    ui->labelStatusViscosityWarn->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMYellow.PNG")));
                    alarmStatus.viscosityWarn = DEV_STATUS_YELLOW;
                }
            }
        }
        sysPara->status.lastViscosityFault = sysPara->status.viscosityFault;
        /*-----------------------------------------------------------------------------------*/
        if(!(sysPara->status.statWarn & WARN_STATUS_RECYCLE_FAULT)){                                            //20140211 nie
            if(sysPara->status.RecycleWarnCnt)
                alarmStatus.recycleWarn = DEV_STATUS_GREEN;
//                ui->labelStatusRecycleWarn->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMGreen.PNG")));
            sysPara->status.RecycleWarnCnt = 0;
            sysPara->status.lastRecycleWarn = 0;
        }
        else {
            if(!sysPara->status.lastRecycleWarn && !sysPara->status.isPumpValveControledByHand && sysPara->status.selfCheckDone)
            {
                if(sysPara->status.RecycleWarnCnt > RECYCLE_WARN_DELAY)
                {
                    sysPara->status.lastRecycleWarn = RECYCLE_WARN_DELAY;//5s
                    alarmStatus.recycleWarn = DEV_STATUS_RED;
//                    ui->labelStatusRecycleWarn->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMRed.PNG")));
                    sysPara->status.reclaimCloseCnt=100;
                    if(sysPara->para.RecycleWarnAction)
                    {
                        if((sysPara->status.currReclaimTankPos != 0) && !sysPara->devOp->isReclaimTankCloseEnable()){
//                            on_pushButtonStopPrint_pressed();
                            on_m_StopBtn_clicked();
//                            on_pushButtonReclaimTankClose_pressed();
                            on_m_LeftBtn_clicked();
                            LogInfo::setRunStatusText(tr("回收故障，关闭回收槽，关墨线"));
                            setRunStatus(tr("回收故障，关闭回收槽，关墨线"));
                        }
                    }
                    else setRunStatus(tr("回收故障."));

                }
                else
                {
                    sysPara->status.RecycleWarnCnt ++ ;
                    alarmStatus.recycleWarn = DEV_STATUS_YELLOW;
//                    ui->labelStatusRecycleWarn->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMYellow.PNG")));
                    if(sysPara->status.RecycleWarnCnt%10==9)
                        LogInfo::setRunStatusText(tr("回收异常,墨线可能偏离.(%1)").arg(sysPara->status.RecycleWarnCnt));
                }
            }
            else if(sysPara->status.lastRecycleWarn)sysPara->status.lastRecycleWarn--;
        }

//        if(startPrintingFlag ){
//            if(printintFlag)
//                setRunStatus(tr("正在喷印..."));
//            else
//                setRunStatus(tr("暂停喷印..."));
//        }

        if(sysPara->status.isPrinting && sysPara->status.selfCheckDone){
                setRunStatus(tr("正在喷印......."));
                setReclaimCloseBtnStatus(false);
                setReclaimOpenBtnStatus(false);
        }
        
        // 20160620   新增主界面显示：压力，粘度，隔膜位置，晶振电压数，相位

        alarmStatus.pressValue = QString("%1/%2").arg(sysPara->status.PRESSURE).arg(sysPara->para.pressure);
        alarmStatus.visoValue = QString("%1/%2").arg(sysPara->status.viscosity).arg(sysPara->para.viscosity);
        if(sysPara->para.gearPumpEnable)
        {
            alarmStatus.gearPumpRunSpeed = QString("%1").arg(sysPara->status.gearPumpRunSpeed);
        }

        alarmStatus.highVol = QString::number(sysPara->status.HV_DETOUT) + "/" + QString::number(sysPara->para.maxHighVoltageDAC);
        alarmStatus.dataSize = QString("%1/%2/%3").arg(sysPara->status.sizeFPGA).arg(sysPara->status.sizequeueFPGA).arg(sysPara->status.sizeSTM32);

    }
}


bool MainWidget::updatePhaseIndicatorLight(){
    if(sysPara==0) return 0;

    /*------------------------------------------喷头盖未关或回收槽未全部打开的时候不报相位故障-------------------------------------------------*/
    if((!sysPara->status.flight_tm_error && !sysPara->status.detect_phase_error) || (sysPara->status.statWarn & WARN_STATUS_HDINT) || !sysPara->status.reclainTankReachEnd){
        //故障后必须等手动按故障恢复才会继续
        if(!sysPara->para.suspendAfterPhaseFault && !sysPara->para.powerOffAfterPhaseFault){
            if(sysPara->status.lastPhaseFault){
                sysPara->status.lastPhaseFault = 0;
//                ui->labelStatusChargefault->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMGreen.PNG")));
                alarmStatus.chargeFault = DEV_STATUS_GREEN;
            }
        }
        sysPara->status.phaseErrorCnt = 0;
    }
    else {
        if(sysPara->status.phaseErrorCnt < 10)
            sysPara->status.phaseErrorCnt ++ ;
        else {
            if(!sysPara->status.lastPhaseFault){
                 alarmStatus.chargeFault = DEV_STATUS_RED;
                sysPara->status.lastPhaseFault = 1;
                if(sysPara->status.flight_tm_error)
                {
                    LogInfo::setRunStatusText(tr("相位故障:飞行时间错误!"));
                }
                if(sysPara->status.detect_phase_error)
                {
                    LogInfo::setRunStatusText(tr("相位故障:相位检测错误!"));
                }

            }
            if(sysPara->para.powerOffAfterPhaseFault ){
                if(!sysPara->status.powerOffAfterPhaseFaultAppending){
                    sysPara->status.powerOffAfterPhaseFaultAppending = 1;
                    _on_pushButtonPowerOff_pressed(false);
                    LogInfo::setRunStatusText(tr("相位故障，准备关机"));
                    setRunStatus(tr("相位故障，准备关机"));
                    strTitle = tr("相位故障，准备关机");


                }
            }
            else if(sysPara->para.suspendAfterPhaseFault){
                if(sysPara->para.stopCounterMeterAfterFault){
                    if(startPrintingFlag && printintFlag){		//已经在打印，则暂停打印
//                        on_pushButtonPausePrint_pressed();
                        on_m_StopBtn_clicked();
                        LogInfo::setRunStatusText(tr("相位故障，暂停打印"));
                        setRunStatus(tr("相位故障，暂停打印"));
                        strTitle = tr("相位故障，暂停打印");

                    }
                }
                else if(!sysPara->status.DACDisable){
                    sysPara->devOp->printCtrl(PRINT_CTRL_DAC_DISABLE);
                    sysPara->status.DACDisable = true;
                    LogInfo::setRunStatusText(tr("相位故障，屏蔽DAC输出"));
                    setRunStatus(tr("相位故障，屏蔽充电"));
                    strTitle = tr("相位故障，屏蔽充电");

                }

            }
        }
    }
    return sysPara->status.lastPhaseFault;
}


//void MainWidget::mouseDoubleClickEvent(QMouseEvent *event)
//{
//    if (event->button() != Qt::LeftButton) {
//        QWidget::mouseDoubleClickEvent(event);
//        return;
//    }

//    QPoint globalPos = event->globalPos();
//    const int expandSize = 50; // 扩大到50像素

//    // 检测函数
//    auto isInExpandedRect = [&](QWidget* widget) -> bool {
//        if (!widget) return false;
//        QRect rect = widget->geometry();
//        rect.translate(widget->parentWidget()->mapToGlobal(QPoint(0, 0)));
//        rect.adjust(-expandSize, -expandSize, expandSize, expandSize);
//        return rect.contains(globalPos);
//    };

//    if (isInExpandedRect(ui.sub3)) {
//        if (m_setNumDlg) {
//            m_setNumDlg->show();
//            event->accept();
//            return;
//        }
//    }

//    if (isInExpandedRect(ui.fra_state)) {
//        LogInfoCtrl::instance()->emitSigShow();
//        event->accept();
//        return;
//    }

//    QWidget::mouseDoubleClickEvent(event);
//}

void MainWidget::mousePressEvent(QMouseEvent *event)
    {
        if (event->button() != Qt::LeftButton) {
            QWidget::mousePressEvent(event);
            return;
        }

        QPoint currentPos = event->globalPos();
        qint64 currentTime = QDateTime::currentMSecsSinceEpoch();

        // 计算时间和距离
        qint64 timeDiff = currentTime - m_lastClickTime;
        int distance = QLineF(m_lastClickPos, currentPos).length();

        // 判断是否为双击（使用自定义阈值）
        if (timeDiff <= m_doubleClickInterval && distance <= m_doubleClickDistance) {
            // 触发双击逻辑
            handleDoubleClick(event);
            m_lastClickTime = 0; // 重置，防止三连击触发多次
            m_lastClickPos = QPoint();
            event->accept();
            return;
        }

        // 更新最后一次点击信息
        m_lastClickPos = currentPos;
        m_lastClickTime = currentTime;

        QWidget::mousePressEvent(event);
    }

void MainWidget::handleDoubleClick(QMouseEvent *event)
{
    QPoint globalPos = event->globalPos();

    // 检查目标区域
    if (isInExpandedRect(ui.sub3, globalPos, m_doubleClickDistance)) {
        if (m_setNumDlg) {
            m_setNumDlg->show();
        }
        return;
    }

    if (isInExpandedRect(ui.fra_state, globalPos, m_doubleClickDistance)) {
        LogInfoCtrl::instance()->emitSigShow();
        return;
    }
}

bool MainWidget::isInExpandedRect(QWidget* widget, const QPoint& globalPos, int expandSize)
{
    if (!widget || !widget->isVisible()) return false;
    QRect rect = widget->geometry();
    rect.translate(widget->parentWidget()->mapToGlobal(QPoint(0, 0)));
    rect.adjust(-expandSize, -expandSize, expandSize, expandSize);
    return rect.contains(globalPos);
}


void MainWidget::onLabelFaultRusumePressed(){
    if(sysPara){
        sysPara->status.flagOfSpeedAlarm = false;
        sysPara->status.mainInkPumpError = false;
        sysPara->status.mainInkPumpRunTmCnt = 0;
        sysPara->status.compressPumpError = false;
        sysPara->status.compressPumpRunTmCnt = 0;
        sysPara->devOp->resumeFault();
        ui.lb_nozzleState->clear();
        sysPara->status.beeperOnFlag = false;
        sysPara->devOp->controlBeeper(false);
        sysPara->status.heaterONTimeCnt = 0;		//加热块计数清零
//        ui->labelStatusChargefault->setPixmap(QPixmap(QString::fromUtf8(":/image/ALARMGreen.PNG")));
        alarmStatus.chargeFault = DEV_STATUS_GREEN;

        sysPara->status.DACDisable = false;
        sysPara->status.lastPhaseFault = 0;
        sysPara->status.phaseErrorCnt = 0;
        if(sysPara->status.lastHighVoltageFault && !(sysPara->status.statWarn & WARN_STATUS_POWER_MON)){
            sysPara->status.lastHighVoltageFault = false;
            flagOfClearHighVltageWarnning = true;
        }

        if(sysPara->status.gearPumpRunStopFlag && pushButtonFlag)
        {
            emit repeatInitedPid();
            sysPara->status.gearPumpRunStopFlag = false;//齿轮泵报警恢复
        }
        if((sysPara->devOp->color_flag == 2) ||(sysPara->devOp->color_flag == 1))
        {
            sysPara->devOp->color_flag = 3;
            sysPara->devOp->controlYellowLight(false);
            sysPara->devOp->controlRedLight(false);
        }
        sysPara->status.visocityValueOverflowNum = 0;

        if(sysPara->status.visocityValueOverflowNum>=MAX_ALLOW_VISICOSITY_OVERFLOW_NUM) //
            sysPara->status.viscosityFault = 0;

        sysPara->status.powerOffAfterPhaseFaultAppending = 0;
        sysPara->status.lastwarmInkPump = 0;
        sysPara->status.RecycleWarnCnt =0;
        sysPara->status.lastRecycleWarn =0 ;
        sysPara->status.powerOffAfterInkOrSOLVEmptyAppending=0;
        //sysPara->status.lastStatWarn=0;  // 机器报故障后，点击故障恢复按钮，再点击打印按钮，“正在喷印中…”字符未立即显示出来，需等待大约10秒才会出现。
        //LogInfo::setRunStatusText(tr("故障恢复"));
        sysPara->status.RecycleWarnCnt=0;
        sysPara->status.HVFaultCloseEn=0;
        if(sysPara->status.flagOfPressureFault){
            sysPara->status.flagOfPressureFault = false;
            sysPara->status.isPumpValveControledByHand = false;
            sysPara->devOp->mainInkCtrl();
            emit clearPressureFault();
        }
        if(printintFlag) {
            sysPara->devOp->highVoltageCtrl(sysPara->para.HighVoltageAmplitude);
        }
    }
}

extern int baudRateValue;
void MainWidget::UpdateUIVersion(){
    int fpgaType = sysPara->status.fpgaVersionNum>>12;
    QString fpgaVersion;
    if(sysPara->status.build_dat.builTime != 0) {
        fpgaVersion = QString::number(sysPara->status.build_dat.builTime);
    }
    else if(fpgaType == 6 || fpgaType == 8){
        fpgaVersion = "72";
    }else if(fpgaType == 1 || fpgaType == 2){
         fpgaVersion = "67";
    }

    fpgaVersion = fpgaVersion + QString("_F%1.%2.%3").arg(sysPara->status.fpgaVersionNum >> 12)
            .arg((sysPara->status.fpgaVersionNum>>8) & 0x0f).arg(sysPara->status.fpgaVersionNum&0xff);

    QString STM32Ver = QString("S:%1.%2.%3_B%4").arg((sysPara->status.stm32Verion>>16)&0x7F)
            .arg((sysPara->status.stm32Verion>>8) & 0xFF).arg(sysPara->status.stm32Verion&0xFF).arg(baudRateValue);

    QString VernonBach;
    VernonBach.sprintf("A%d.%d.%02d%s%s", UP_PRINTER_MAJOR_VER, UP_PRINTER_MINOR_VER,UP_PRINTER_RIVISION_VER,SUB_VERSION,SUB_RFID);

    QString Mac = QString::number(sysPara->status.machineMac);
    LogInfo::setRunStatusText(QString("Mac:%1").arg(Mac));
    LogInfo::showVerionInformation(Mac,VernonBach,fpgaVersion,STM32Ver);
}