#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    this->showMaximized();
    iniViewModel();
    qRegisterMetaType<QVector<int> >("QVector<int>");//对自定义类型注册
}

MainWindow::~MainWindow()
{
    if(m_autoPrintLoadThread.isRunning() == true)
    {
        while(m_autoPrintLoadThread.isRunning())
        {
            m_breakAutoLoadThread = 1;//暂停、取消线程的运行
        }
    }

    if(m_drawingSetDlg != NULL)
    {
        delete m_drawingSetDlg;
    }

    if(m_plotterSetDlg!= NULL)
    {
        delete m_plotterSetDlg;
    }

    if(m_historyDlg != NULL)
    {
        delete m_historyDlg;
    }

    if(m_printViewWi != NULL)
    {
        delete m_printViewWi;
    }

    if(m_sendTimer != NULL)
    {
        delete m_sendTimer;
    }

    if(m_pTimer != NULL)
    {
        delete m_pTimer;
    }

    if(m_printInfoDlg != NULL)
    {
        delete m_printInfoDlg;
    }

    if(m_preView != NULL)
    {
        delete m_preView;
        m_preView = NULL;
    }

    for(int i = 0; i < g_machineList.size(); i++)
    {
        g_machineList[i]->m_mcPrintInfo.clear();
    }

    delete ui;
}

void MainWindow::closeEvent(QCloseEvent *e)
{
    e->accept();
}

void MainWindow::reflushPreview(int row)
{
    if(row < 0)
    {
        return;
    }

    if(m_curFileRow >= g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList.size())
    {
        m_preView->cleanView();
        m_tabelViewModelFile->removeRows(0,m_tabelViewModelFile->rowCount());
        return;
    }

    if(m_curFileRow < 0)
    {
        return;
    }

    g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[m_curFileRow].m_selectBlockNum = 0;//上次查看的文件的块数选择置为0
    m_curBlockRow = -1;
    ui->tableView_fileList->selectRow(row);

    if(g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[row].m_creatBmpFlag != 1)
    {
        ui->tableView_fileList->setEnabled(false);
        ui->tableView_Connection->setEnabled(false);

        //生成绘制图
        g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[row].m_pic = creatFilePicture(g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[row]);

        //将picture保存为多个宽度为2400像素的bmp
        int num = g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[row].m_pic.width() / PIXMAPWIDTH;
        int lwidth = g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[row].m_pic.width() % PIXMAPWIDTH;
        if(lwidth != 0)
        {
            num +=1;
        }
        g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[row].m_totalBlocks = num;
        g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[row].m_leaveBlockNum = num;//剩余打印块数

        g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[row].m_creatBmpFlag = 1;
        ui->tableView_fileList->setEnabled(true);
        ui->tableView_Connection->setEnabled(true);
    }

    //刷新图形
    QPicture pic = g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[row].m_pic;
    m_preView->cleanView();
    m_preView->swithView(pic);
    m_curFilesInfo = g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[row];
}

void MainWindow::reflushMcFileInfo()
{
    ui->label_fileTotalVal->setText(QString::number(g_machineList[m_curMcIdx]->m_mcPrintInfo.m_fileNums));
    ui->label_fileTotalLenthVal->setText(QString::number(g_machineList[m_curMcIdx]->m_mcPrintInfo.m_fileTotalLength)+"mm");
}

void MainWindow::changeRowData(int move)
{ 
    int row = m_curFileRow;
    if(NULL == m_tabelViewModelFile || row < 0 || row > m_tabelViewModelFile->rowCount()-1)
    {
        return ;
    }

    if(move == 1)
    {
        //下移需要判断最后一行，不移动
        if(row == m_tabelViewModelFile->rowCount()-1)
        {
            return ;
        }
    }
    else if(move == -1)
    {
        //上移需要判断是否第一行，不移动
        if(row == 0)
        {
            return ;
        }
    }
    g_machineList[m_curMcIdx]->moveFilePrintDat(m_curFileRow,move);
    QList<QStandardItem *> listItem = m_tabelViewModelFile->takeRow(row);
    m_curFileRow = row + move;
    m_tabelViewModelFile->insertRow(m_curFileRow,listItem);
    ui->tableView_fileList->selectRow(m_curFileRow);
}

bool MainWindow::deleteDir(QString path)
{
    if (path.isEmpty())
    {
        return false;
    }
    QDir dir(path);
    if(!dir.exists())
    {
        return true;
    }
    dir.setFilter(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot); //设置过滤
    QFileInfoList fileList = dir.entryInfoList(); // 获取所有的文件信息
    foreach (QFileInfo file, fileList)
    {
        //遍历文件信息
        if (file.isFile())
        {
            // 是文件，删除
            file.dir().remove(file.fileName());
        }
        else
        {
            // 递归删除
            deleteDir(file.absoluteFilePath());
        }
    }
    return dir.rmdir(dir.absolutePath()); // 删除文件夹
}

void MainWindow::setButtonEnable(bool bl)
{
    ui->actionOpen_File->setEnabled(bl);
    ui->actionOpen_Image->setEnabled(bl);
    ui->actiontest1_plt->setEnabled(bl);
    ui->actionStart->setEnabled(bl);
    ui->actionPause->setEnabled(bl);
    ui->actionDelete->setEnabled(bl);
    ui->actionDrawing_Setting->setEnabled(bl);
    ui->actionPlotter_Setting->setEnabled(bl);
    ui->actionOpenFileIcon->setEnabled(bl);
    ui->actionOpenImageIcon->setEnabled(bl);
    ui->actionStartIcon->setEnabled(bl);
    ui->actionPauseIcon->setEnabled(bl);
    ui->actionDrawingSetIcon->setEnabled(bl);
    ui->pushButton_up->setEnabled(bl);
    ui->pushButton_down->setEnabled(bl);
    ui->pushButton_delete->setEnabled(bl);
    ui->pushButton_preview->setEnabled(bl);
}

void MainWindow::startCreatBmpAndSend(int mcIdx)
{
    int mcBegIdx, mcEndIdx;
    mcBegIdx = mcEndIdx = 0;

    //自动打印时mcIdx为-1
    //mcIdx = -1;

    if(mcIdx == -1)
    {
        mcBegIdx = 0;
        mcEndIdx = g_machineList.size();
    }
    else
    {
        mcBegIdx = mcIdx;
        mcEndIdx = mcIdx + 1;
    }

    for(int i = mcBegIdx; i < mcEndIdx; i++)
    {
        if(m_workState == WORK_PAUSE)
        {
            return;
        }
        //生成bmp块
        QDir printDir(m_printPath);//总的打印目录
        if(!printDir.exists())
        {
            printDir.mkdir(m_printPath);
        }

        QString mcFile = m_printPath + printDir.separator() + PRINTMCDIR + QString::number(g_machineList[i]->m_mcPrintInfo.m_mcNum);
        QDir mcDir(mcFile);//对应每台机器打印目录
        if(!mcDir.exists())
        {
            mcDir.mkdir(mcFile);
        }
        g_machineList[i]->creatPrintDat(m_curFileRow);
    }
}

QPicture MainWindow::creatFilePicture(McFilesInfo & mcFileInfo, s16 penWidth)
{
    //将图片画在picture上
    QPicture pic;
    QPen pen;
    if(mcFileInfo.m_fileType == TYPE_FILE)
    {
        pen.setWidth(penWidth);//设置笔号
    }
    else if(mcFileInfo.m_fileType == TYPE_IMAGE)
    {
        pen.setWidth(1);//设置笔号
    }
    pen.setColor(QColor(Qt::black));

    QPainter painter;
    painter.begin(&pic);
    painter.setPen(pen);

    if(mcFileInfo.m_fileType == TYPE_IMAGE)
    {
        painter.drawPixmap(0,0,mcFileInfo.m_pixmap);
    }
    else
    {
        CBitmapInfo bitmapInfo;
        QPainterPath painterPath;
        QRect rect = mcFileInfo.m_marker.GetRect();
        int minX = rect.left();
        int minY = rect.top();
        int maxY = rect.bottom();

        int nLineCount = mcFileInfo.m_marker.m_listPolyline.size();
        for(int i = 0; i < nLineCount; i++)
        {
            CRPPolyline polyLine = mcFileInfo.m_marker.m_listPolyline.at(i);
            int type = polyLine.m_nDrawingType;
            //        if(polyLine.m_nDrawingType == 3)//文字
            //        {
            //            CRPText text = polyLine.m_text;
            //        }

            if(type == 0)//直线
            {
                int nPointCount = polyLine.m_listPoint.size();
                for(int j = 0; j < nPointCount; j++)
                {
                    double x = (polyLine.m_listPoint.at(j).x() - minX)/(double)M_IDPMM*MMPIXELY;
                    double y = ((0 - (polyLine.m_listPoint.at(j).y() - minY))+(maxY-minY))/(double)M_IDPMM*MMPIXELY;
                    QPointF point(x,y);

                    if(j == 0)
                    {
                        painterPath.moveTo(point);
                    }
                    else
                    {
                        painterPath.lineTo(point);
                    }
                }
            }
            else if(type == 1)//位图
            {
                bitmapInfo = polyLine.m_bitmapInfo;
                int x = bitmapInfo.m_ptAbPostLU.x();
                int y = bitmapInfo.m_ptAbPostLU.y();

                int nx = (x - minX)/M_IDPMM*MMPIXELY;
                int ny = ((0 - (y - minY))+(maxY-minY))/M_IDPMM*MMPIXELY;

                bitmapInfo.m_ptAbPostLU.setX(nx);
                bitmapInfo.m_ptAbPostLU.setY(ny);
            }
        }

        if(painterPath.isEmpty())
        {
            qDebug()<<"painterPath.isEmpty";
        }

        painter.drawPath(painterPath);
        if(bitmapInfo.m_iBytes > 0)//有位图
        {
            //bitmapInfo.m_pBitmap.save("D:\\1.bmp");
            painter.drawPixmap(bitmapInfo.m_ptAbPostLU.x(),bitmapInfo.m_ptAbPostLU.y(),bitmapInfo.m_pBitmap);
        }
    }

    painter.end();
    return pic;
}

void MainWindow::refConnectUi()
{
    for(int i = 0; i < g_machineList.size(); i++)
    {
        refConnectUi(g_machineList[i], g_machineList[i]->m_mcPrintInfo.m_mcConnState, i);
    }
}

//刷新连接状态
void MainWindow::refConnectUi(Machine *pMachine, int &linkSta, int idx)
{
    if (pMachine != NULL)
    {
        if (linkSta != pMachine->isConnected() ||
                pMachine->isConnected() == Connectting)
        {
            linkSta = pMachine->isConnected();//获取连接状态
            QString strConn;
            if (linkSta == Connectting)//连接中...
            {
                strConn = tr("Connnecting...");//连接中...
            }
            else if (linkSta == Connected)//已连接
            {
                strConn = tr("Connected");//已连接
            }
            else//未连接
            {
                strConn = tr("NotConnected");//未连接
            }
            m_tabelViewModelConn->setData(m_tabelViewModelConn->index(idx, CONN_COLUMN_MCCONSTATE),strConn);
        }
    }
}

void MainWindow::refreshMcListShow()
{
    if(g_machineList.size() <= 0)
    {
        ui->menuFile_F->setEnabled(false);
        return;
    }
    for(int i = 0; i < g_machineList.size(); i++)
    {
        int row = m_tabelViewModelConn->rowCount();//当前表格的行数
        m_tabelViewModelConn->insertRow(row);//在最后一行的后面插入一行
        m_tabelViewModelConn->setData(m_tabelViewModelConn->index(row, CONN_COLUMN_MCNAME),g_machineList[i]->m_mcPrintInfo.m_mcName);
        m_tabelViewModelConn->setData(m_tabelViewModelConn->index(row,CONN_COLUMN_MCIP),g_machineList[i]->m_mcPrintInfo.m_ip);

        QString strConn = tr("NotConnected");//未连接
        m_tabelViewModelConn->setData(m_tabelViewModelConn->index(row,CONN_COLUMN_MCCONSTATE),strConn);

        QString str;
        if(g_machineList[i]->m_mcPrintInfo.m_mcWorkState == NotBusy)
        {
            str = tr("Idle");//空闲中
        }
        else if(g_machineList[i]->m_mcPrintInfo.m_mcWorkState == Busying)
        {
            str = tr("Working");//工作中
        }
        m_tabelViewModelConn->setData(m_tabelViewModelConn->index(row,CONN_COLUMN_MCWORKSTATE),str);
        QString strPro = QString::number(g_machineList[i]->m_mcPrintInfo.m_mcSendProgress) + "%";
        m_tabelViewModelConn->setData(m_tabelViewModelConn->index(row,CONN_COLUMN_MCPROGRESS),strPro);

        connect(g_machineList[i], SIGNAL(siDeleteFileFinish()),
                this, SLOT(slotDeleteFileFinish())); // 发送数据的槽
    }
    //    m_curMcIdx = 0;
    //    ui->tableView_Connection->selectRow(m_curMcIdx);
}

void MainWindow::refreshOneMcShow(int row,int idx)
{
    m_tabelViewModelConn->setData(m_tabelViewModelConn->index(row, CONN_COLUMN_MCNAME),g_machineList[idx]->m_mcPrintInfo.m_mcName);
    m_tabelViewModelConn->setData(m_tabelViewModelConn->index(row,CONN_COLUMN_MCIP),g_machineList[idx]->m_mcPrintInfo.m_ip);

    QString strConn = tr("NotConnected");//未连接
    if(g_machineList[idx]->m_mcPrintInfo.m_mcWorkState == Connectting)
    {
        strConn = tr("Connnecting...");//连接中...
    }
    else if(g_machineList[idx]->m_mcPrintInfo.m_mcWorkState == Connected)
    {
        strConn = tr("Connected");//已连接
    }
    m_tabelViewModelConn->setData(m_tabelViewModelConn->index(row,CONN_COLUMN_MCCONSTATE),strConn);

    QString str;
    if(g_machineList[idx]->m_mcPrintInfo.m_mcWorkState == NotBusy)
    {
        str = tr("Idle");//空闲中
    }
    else if(g_machineList[idx]->m_mcPrintInfo.m_mcWorkState == Busying)
    {
        str = tr("Working");//工作中
    }
    m_tabelViewModelConn->setData(m_tabelViewModelConn->index(row,CONN_COLUMN_MCWORKSTATE),str);
    QString strPro = QString::number(g_machineList[idx]->m_mcPrintInfo.m_mcSendProgress) + "%";
    m_tabelViewModelConn->setData(m_tabelViewModelConn->index(row,CONN_COLUMN_MCPROGRESS),strPro);
}

int MainWindow::refreshMcFileListShow(int idx)
{
    if(m_autoPrintLoadThread.isRunning() == true)
    {
        m_breakAutoLoadThread = 1;//暂停、取消线程的运行
        while(m_autoPrintLoadThread.isRunning() == true)
        {
            //等待线程结束
        }
    }

    m_curMcIdx = idx;
    m_tabelViewModelFile->removeRows(0,m_tabelViewModelFile->rowCount());
    m_preView->cleanView();

    QString iniName = "MachineNo" + QString::number(g_machineList[m_curMcIdx]->m_mcPrintInfo.m_mcNum) + ".ini";
    QDir apppath(qApp->applicationDirPath());
    QString iniPath = apppath.path() + apppath.separator() + iniName;
    QSettings setting(iniPath, QSettings::IniFormat); //QSettings能记录一些程序中的信息，下次再打开时可以读取出来
    QString dirPath = setting.value("AutoPrintDir/fileDir").toString();
    QDir dir(dirPath);
    //存在自动绘图目录或上次未打印完成文件时首次点击先加载文件
    if(dir.exists() && dirPath.length() != 0 && g_machineList[m_curMcIdx]->m_mcPrintInfo.m_loadFileFinishFlag < 0)
    {
        //并发线程的使用，为了避免同时加载窗体和加载文件时的窗体卡顿
        m_autoPrintLoadThread = QtConcurrent::run(this,this->slotLoadAutoPrintFiles);
        return 0;
    }
    else
    {
        g_machineList[m_curMcIdx]->m_mcPrintInfo.m_loadFileFinishFlag = 1;
        QList<McFilesInfo> filesList = g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList;
        int size = filesList.size();

        for(int i = 0; i < size; i++)
        {
            m_tabelViewModelFile->insertRow(i);//在最后一行的后面插入一行
            m_tabelViewModelFile->setData(m_tabelViewModelFile->index(i,COLUMN_FILENAME),filesList[i].m_fileName);

            QRect rect = filesList[i].m_fileRect;

            QString length = QString::number((rect.right() - rect.left())/(int)M_IDPMM)+"mm";
            m_tabelViewModelFile->setData(m_tabelViewModelFile->index(i,COLUMN_LENGTH),length);

            QString width = QString::number((rect.bottom() - rect.top())/(int)M_IDPMM)+"mm";
            m_tabelViewModelFile->setData(m_tabelViewModelFile->index(i,COLUMN_WIDTH),width);

            QString start = QString::number(filesList[i].m_startPoint)+"mm";
            m_tabelViewModelFile->setData(m_tabelViewModelFile->index(i,COLUMN_START),start);

            m_tabelViewModelFile->setData(m_tabelViewModelFile->index(i,COLUMN_PRINTEDLENGTH),"0mm");

            QString number = QString::number(filesList[i].m_printNum);
            m_tabelViewModelFile->setData(m_tabelViewModelFile->index(i,COLUMN_NUMBERS),number);

            //QString state = tr("Waitting");
            m_tabelViewModelFile->setData(m_tabelViewModelFile->index(i,COLUMN_STATE),filesList[i].m_printState);

            m_tabelViewModelFile->setData(m_tabelViewModelFile->index(i,COLUMN_FILEPATH),filesList[i].m_filePath);
        }

        reflushMcFileInfo();
        qDebug()<<"reflushMcFileInfo();";
        m_curFileRow = 0;
        ui->tableView_fileList->selectRow(m_curFileRow);//选中
        reflushPreview(m_curFileRow);
    }
    return 0;
}

void MainWindow::loadAutoPrintDirFiles()
{
    //并发线程的使用，为了避免同时加载窗体和加载文件时的窗体卡顿
    m_autoPrintLoadThread = QtConcurrent::run(this,this->slotLoadAutoPrintFiles);
}

//初始化所有窗体
void MainWindow::initAllWinForm()
{
    refreshMcListShow();

    m_curMcIdx = -1;
    m_curFileRow = -1;
    m_curPrintFileIdx = -1;
    m_curBlockRow = -1;
    m_preView = NULL;

    m_workState = PAUSE;
    m_printMode = NOAUTOPRINT;
    m_breakAutoLoadThread = 0;

    QDir apppath(qApp->applicationDirPath());
    m_printPath = apppath.path() + apppath.separator() + "print";

    m_preView = new MyGraphicsView();
    ui->verticalLayout_drawing->addWidget(m_preView);

    m_drawingSetDlg= new DrawingSetDialog();
    m_plotterSetDlg = new PlotterSetDialog();
    m_historyDlg = new HistoryDialog();
    m_printViewWi = new PrintViewWindow(this);
    connect(m_printViewWi,SIGNAL(siAddNewFile(int)),this,SLOT(slotAddNewFileToList(int)));

    m_printInfoDlg = new PrintInfoDialog();

    m_sendTimer = new QTimer(this);
    m_sendTimer->setInterval(100);    // 设置定时间隔100毫秒
    connect(m_sendTimer, SIGNAL(timeout()), this, SLOT(onSendTimer()));
    m_sendTimer->start();

    //定时器
    m_pTimer = new QTimer(this);
    m_pTimer->setInterval(1000);    // 设置定时间隔1秒
    connect(m_pTimer, SIGNAL(timeout()), this, SLOT(onOneSecondTimer()));
    m_pTimer->start();

    m_drawingSetDlg->hide();
    m_plotterSetDlg->hide();
    m_historyDlg->hide();
    m_printViewWi->hide();
    m_printInfoDlg->hide();

    //删除位图文件夹
    deleteDir(m_printPath);
    //setButtonEnable(false);
}

void MainWindow::iniViewModel()
{
    //QTabelView
    m_tabelViewModelFile = new QStandardItemModel(0, COLUMN_NUM, ui->tableView_fileList);
    QStringList header;  //QString类型的List容器
    header<<tr("FileName")<<tr("Length")<<tr("Width")
         <<tr("Start")<<tr("Printed")<<tr("Numbers")<<tr("State")<<tr("FilePath");//设置内容是文件名、长度、宽度、起始打印点、已打印长度、份数、状态、文件路径
    m_tabelViewModelFile->setHorizontalHeaderLabels(header);
    ui->tableView_fileList->setModel(m_tabelViewModelFile);
    ui->tableView_fileList->setSelectionBehavior(QAbstractItemView::SelectRows);//单击选择一行
    ui->tableView_fileList->setEditTriggers(QAbstractItemView::NoEditTriggers);//每行不可编辑
    ui->tableView_fileList->setSelectionMode(QAbstractItemView::SingleSelection);//只能选择一行
    ui->tableView_fileList->setColumnWidth(0,COLUMN_COLWIDTH+100);//设置列宽
    for(int i = 1; i < COLUMN_NUM-1; i++)
    {
        ui->tableView_fileList->setColumnWidth(i,COLUMN_COLWIDTH);//设置列宽
    }
    ui->tableView_fileList->setColumnWidth(COLUMN_NUM-1,COLUMN_COLWIDTH+200);//设置列宽
    ui->tableView_fileList->horizontalHeader()->setHighlightSections(false);//设置表头字体不变粗
    //ui->tableView_fileList->horizontalHeader()->setStyleSheet("border-bottom-width: 0.5px;border-style: outset;border-color: rgb(229,229,229);");//表头和第一行之间加分割线

    ui->tableView_fileList->setContextMenuPolicy(Qt::CustomContextMenu);//设置右击菜单
    connect(ui->tableView_fileList,SIGNAL(customContextMenuRequested(QPoint)),this,SLOT(slotFileListMenu(QPoint)));

    //建立数据模型对象空间并指定父对象
    m_tabelViewModelConn = new QStandardItemModel(0, CONN_COLUMN_NUM, ui->tableView_Connection);
    QStringList headerConn;  //QString类型的List容器
    headerConn<<tr("McName")<<tr("McIp")<<tr("McConState")<<tr("McState")<<tr("McProgress");//设置内容是机器名称、机器IP、机器连接状态、机器工作状态、机器发送进度
    m_tabelViewModelConn->setHorizontalHeaderLabels(headerConn);
    ui->tableView_Connection->setModel(m_tabelViewModelConn);
    ui->tableView_Connection->setSelectionBehavior(QAbstractItemView::SelectRows);//单击选择一行
    ui->tableView_Connection->setEditTriggers(QAbstractItemView::NoEditTriggers);//每行不可编辑
    ui->tableView_Connection->setSelectionMode(QAbstractItemView::SingleSelection);//只能选择一行
    for(int i = 0; i < CONN_COLUMN_NUM; i++)
    {
        ui->tableView_Connection->setColumnWidth(i,CONN_COLUMN_COLWIDTH);//设置列宽
    }
    ui->tableView_Connection->horizontalHeader()->setHighlightSections(false);//设置表头字体不变粗
    ui->tableView_Connection->setContextMenuPolicy(Qt::CustomContextMenu);//设置右击菜单
    connect(ui->tableView_Connection,SIGNAL(customContextMenuRequested(QPoint)),this,SLOT(slotMcListMenu(QPoint)));
}

void MainWindow::slotAddNewFileToList(int newFlag)
{
    if(newFlag == 0)//非新文件
    {
        int start = m_printViewWi->getStartPoint();
        int number = m_printViewWi->getPrintNumber();

        int oldStart = m_tabelViewModelFile->item(m_curFileRow,COLUMN_START)->text().remove("mm").toInt();
        int oldNumber = m_tabelViewModelFile->item(m_curFileRow,COLUMN_NUMBERS)->text().toInt();

        if(start != oldStart)
        {
            m_tabelViewModelFile->item(m_curFileRow,COLUMN_START)->setText(QString::number(start)+"mm");
        }
        if(number != oldNumber)
        {
            m_tabelViewModelFile->item(m_curFileRow,COLUMN_NUMBERS)->setText(QString::number(number));
        }

        m_curFilesInfo.m_printNum = number;
        m_curFilesInfo.m_startPoint = start;
        g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[m_curFileRow] = m_curFilesInfo;
    }
    else    //新文件
    {
        int row = m_tabelViewModelFile->rowCount();//当前表格的行数
        m_tabelViewModelFile->insertRow(row);//在最后一行的后面插入一行
        m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row,COLUMN_FILENAME),m_curFilesInfo.m_fileName);

        QRect rect = m_curFilesInfo.m_fileRect;

        QString length = QString::number((rect.right() - rect.left())/(int)M_IDPMM)+"mm";
        m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row,COLUMN_LENGTH),length);

        QString width = QString::number((rect.bottom() - rect.top())/(int)M_IDPMM)+"mm";
        m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row,COLUMN_WIDTH),width);

        QString start = QString::number(m_printViewWi->getStartPoint())+"mm";
        m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row,COLUMN_START),start);

        m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row,COLUMN_PRINTEDLENGTH),"0mm");

        QString number = QString::number(m_printViewWi->getPrintNumber());
        m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row,COLUMN_NUMBERS),number);

        QString state = tr("Waitting");
        m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row,COLUMN_STATE),state);

        m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row,COLUMN_FILEPATH),m_curFilesInfo.m_filePath);

        m_preView->cleanView();
        if(m_curFilesInfo.m_fileType == TYPE_FILE)
        {
            m_preView->creatView(m_curFilesInfo.m_marker);//刷新显示
        }
        else if(m_curFilesInfo.m_fileType == TYPE_IMAGE)
        {
            m_preView->creatView(m_curFilesInfo.m_pixmap);//刷新显示
        }

        //将view的图片添加到列表中
        m_curFilesInfo.m_pic = m_preView->getPicture(m_curFilesInfo.m_marker);
        m_curFilesInfo.m_creatBmpFlag = 1;
        //将picture保存为多个宽度为2400像素的bmp
        int num = m_curFilesInfo.m_pic.width() / PIXMAPWIDTH;
        int lwidth = m_curFilesInfo.m_pic.width() % PIXMAPWIDTH;
        if(lwidth != 0)
        {
            num +=1;
        }
        m_curFilesInfo.m_totalBlocks = num;
        m_curFilesInfo.m_curPrintBlock = 0;//当前打印块数
        m_curFilesInfo.m_printedBlockNum = 0;//已打印块数
        m_curFilesInfo.m_leaveBlockNum = num;//剩余打印块数
        m_curFilesInfo.m_selectBlockNum = 0;//当前选择块数

        m_curFilesInfo.m_printNum = number.toInt();
        m_curFilesInfo.m_startPoint = m_printViewWi->getStartPoint();
        m_curFilesInfo.m_printState = state;

        McPrintInfo McF;
        McF.m_fileNums = row+1;
        McF.m_fileTotalLength = (m_curFilesInfo.m_fileRect.right() - m_curFilesInfo.m_fileRect.left())/M_IDPMM;
        McF.m_filesList.append(m_curFilesInfo);
        m_curFileRow = row;

#if(0)
        //生成bmp块
        QDir printDir(m_printPath);//总的打印目录
        if(!printDir.exists())
        {
            printDir.mkdir(m_printPath);
        }

        QString mcFile = m_printPath + printDir.separator() + PRINTMCDIR + QString::number(m_curMcIdx+1);
        QDir mcDir(mcFile);//对应每台机器打印目录
        if(!mcDir.exists())
        {
            mcDir.mkdir(mcFile);
        }

        QString filePath = mcFile + mcDir.separator() + PRINTFILEDIR + QString::number(row+1);
        QDir fileDir(filePath);//对应每台机器的每个文件打印目录
        if(!fileDir.exists())
        {
            fileDir.mkdir(filePath);
        }
        filePath = filePath + mcDir.separator();

        m_creatBmpThread->setSavePath(filePath);
        if(m_curFilesInfo.m_fileType == TYPE_FILE)
        {
            m_creatBmpThread->setPicture(m_preView->getPicture(m_curFilesInfo.m_marker,PENWIDTH));
        }
        else if(m_curFilesInfo.m_fileType == TYPE_IMAGE)
        {
            m_creatBmpThread->setPicture(m_curFilesInfo.m_pixmap);
        }
        m_creatBmpThread->start();
#endif

        ui->tableView_fileList->selectRow(row);//选中

        if(g_machineList.size() <= 0)
        {
            return;
            //g_machineList.append(McF);
        }
        else
        {
            g_machineList[m_curMcIdx]->m_mcPrintInfo.m_fileNums = row+1;
            g_machineList[m_curMcIdx]->m_mcPrintInfo.m_fileTotalLength += McF.m_fileTotalLength;
            g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList.append(m_curFilesInfo);
        }
    }
    reflushMcFileInfo();
}

void MainWindow::slotFileListMenu(QPoint pos)
{
    QModelIndex index = ui->tableView_fileList->indexAt(pos);
    int row = index.row();

    if(row < 0){return;}

    QMenu* menu = new QMenu(this);//创建菜单
    QAction* action1 = new QAction(tr("Print preview"), this);//打印预览
    QAction* action2 = new QAction(tr("Number of modified print"), this);//修改打印份数
    QAction* action3 = new QAction(tr("Modify the starting print point"), this);//修改起始打印点
    QAction* action4 = new QAction(tr("View print information"), this);//查看打印信息
    QAction* action5 = new QAction(tr("Delete"), this);//删除

    connect (action1,SIGNAL(triggered()),this,SLOT(slotPrintPreview()));
    connect (action2,SIGNAL(triggered()),this,SLOT(slotPrintNumberSetDlgShow()));
    connect (action3,SIGNAL(triggered()),this,SLOT(slotStartSetDlgShow()));
    connect (action4,SIGNAL(triggered()),this,SLOT(slotViewPrintInfo()));
    connect (action5,SIGNAL(triggered()),this,SLOT(slotDeleteFile()));

    menu->addAction(action1);//将action放入菜单中
    menu->addAction(action2);//将action放入菜单中
    menu->addAction(action3);//将action放入菜单中
    menu->addAction(action4);//将action放入菜单中
    menu->addAction(action5);//将action放入菜单中
    menu->popup(ui->tableView_fileList->viewport()->mapToGlobal(pos));//将菜单显示到鼠标所在位置

    if(m_curFileRow != row)
    {
        m_curFileRow = row;
        reflushPreview(row);
    }
    m_curFileRow = row;
}

void MainWindow::slotMcListMenu(QPoint pos)
{
    QModelIndex index = ui->tableView_Connection->indexAt(pos);
    int row = index.row();

    if(row < 0){return;}

    QMenu* menu = new QMenu(this);//创建菜单
    QAction* action1 = new QAction(tr("Delete"), this);//删除
    connect (action1,SIGNAL(triggered()),this,SLOT(slotDeleteMc()));

    menu->addAction(action1);//将action放入菜单中
    menu->popup(ui->tableView_Connection->viewport()->mapToGlobal(pos));//将菜单显示到鼠标所在位置

    if(m_curMcIdx != row)
    {
        refreshMcFileListShow(row);
        ui->tableView_Connection->selectRow(m_curMcIdx);
        m_curMcIdx = row;
    }
}

void MainWindow::slotPrintPreview()
{
    m_curFilesInfo = g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[m_curFileRow];
    m_printViewWi->refreshShow(m_curFilesInfo,0);
}

void MainWindow::slotPrintNumberSetDlgShow()
{
    QString fileName = m_curFilesInfo.m_fileName;
    QString printNumber= QString::number(m_curFilesInfo.m_printNum);
    PrintNumberSetDialog numberSetDlg;
    if(numberSetDlg.exec(fileName,printNumber) == 1)
    {
        int number = numberSetDlg.getPrintNumber();
        m_curFilesInfo.m_printNum = number;
        g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[m_curFileRow] = m_curFilesInfo;
        m_tabelViewModelFile->item(m_curFileRow,COLUMN_NUMBERS)->setText(QString::number(number));
    }
}

void MainWindow::slotStartSetDlgShow()
{
    QString fileName = m_curFilesInfo.m_fileName;
    QString startPoint= QString::number(m_curFilesInfo.m_startPoint);
    QString length= QString::number(m_curFilesInfo.m_fileRect.right()-m_curFilesInfo.m_fileRect.left());
    StartSetDialog startSetDlg;
    if(startSetDlg.exec(fileName,startPoint,length) == 1)
    {
        int startPoint = startSetDlg.getStartPoint();
        m_curFilesInfo.m_startPoint = startPoint;
        g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[m_curFileRow] = m_curFilesInfo;
        m_tabelViewModelFile->item(m_curFileRow,COLUMN_START)->setText(QString::number(startPoint)+"mm");
    }
}

void MainWindow::slotViewPrintInfo()
{
    if(m_printInfoDlg != NULL)
    {
        m_printInfoDlg->setFilesInfo(g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[m_curFileRow]);
    }
}

void MainWindow::slotDeleteFile()
{
    if(m_curMcIdx < 0 || m_curMcIdx >= g_machineList.size())
    {
        return;
    }

    if(m_curFileRow < 0 || m_curFileRow >= g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList.size())
    {
        return;
    }

    if(QMessageBox::warning(this,
                            tr("Prompt"),
                            tr("Do you want to delete this drawing?"),//是否删除该项绘图?
                            QMessageBox::Ok|QMessageBox::Cancel) == QMessageBox::Ok)
    {
        //判断是否正在打印，如果正在打印时不可删除
        if(g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[m_curFileRow].m_curPrintBlock != 0)
        {
            QMessageBox::warning(this,
                                 tr("Prompt"),
                                 tr("Printing this file, it cannot be deleted!"),//正在打印此文件，不可删除！
                                 QMessageBox::Ok);
            return;
        }

        g_machineList[m_curMcIdx]->deleteFilePrintDat(m_curFileRow);
    }
}

void MainWindow::slotDeleteFileFinish()
{
    m_tabelViewModelFile->removeRow(m_curFileRow);
    m_preView->cleanView();

    reflushMcFileInfo();

    if(m_curFileRow >= g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList.size())
    {
        m_curFileRow -= 1;
    }
    ui->tableView_fileList->selectRow(m_curFileRow);
    reflushPreview(m_curFileRow);
}

void MainWindow::slotDeleteMc()
{
    if(QMessageBox::warning(this,
                            tr("Prompt"),
                            tr("After deletion, the machine cannot be controlled. Do you want to delete this machine?"),//删除后将不能控制机器，是否删除此机器？
                            QMessageBox::Ok|QMessageBox::Cancel) == QMessageBox::Ok)
    {
        if(m_curMcIdx < 0 || m_curMcIdx >= g_machineList.size())
        {
            return;
        }

        //要删除的机器为正在加载文件的机器
        if(m_autoPrintLoadThread.isRunning() == true
                && g_machineList[m_curMcIdx]->m_mcPrintInfo.m_loadFileFinishFlag != 1)
        {
            m_breakAutoLoadThread = 1;            //暂停、取消线程的运行
            while(m_autoPrintLoadThread.isRunning() == true)
            {
                //等待线程停止
            }
        }
        //清除机器数据
        for(int i = 0; i < g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList.size(); i++)
        {
            g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[i].clear();
        }
        g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList.clear();
        g_machineList[m_curMcIdx]->m_mcPrintInfo.clear();

        g_machineList.removeAt(m_curMcIdx);//从列表中删除
        m_tabelViewModelConn->removeRow(m_curMcIdx);
        m_tabelViewModelFile->removeRows(0,m_tabelViewModelFile->rowCount());
        m_preView->cleanView();
        ui->tableView_Connection->clearSelection();
        ui->label_fileTotalVal->setText("");
        ui->label_fileTotalLenthVal->setText("");

        //删除该机器的配置文件
        QDir apppath(qApp->applicationDirPath());
        QString configfile;
        configfile = apppath.path() + apppath.separator() + "config.ini";
        QSettings settings(configfile, QSettings::IniFormat);
        QString str = "MachineNo" + QString::number(m_curMcIdx+1);
        settings.remove(str);
        m_curMcIdx = -1;
        QString iniFilePath = apppath.path() + apppath.separator() + str + ".ini";
        QFile::remove(iniFilePath);
    }
}

void MainWindow::onSendTimer()
{
    //总块数或者已生成块数为0时返回
    //    if(m_totalPieces <= 0 || g_createdPieces <= 0 || m_sendPiece == m_totalPieces)
    //    {
    //        return;
    //    }

    //    if(m_workState == START)
    //    {
    //        ui->actionStart->setEnabled(false);
    //        ui->actionStartIcon->setEnabled(false);
    //    }
    //    else
    //    {
    //        ui->actionStart->setEnabled(true);
    //        ui->actionStartIcon->setEnabled(true);
    //    }

    //已生成的比发送的块数多
    //if(g_createdPieces > m_sendPiece)
    {
        //发送文件
        //        if(g_pMachine != NULL)
        //        {
        //            if(g_pDatList.size() > m_sendPiece)
        //            {
        //                g_pMachine->sendFileProc(m_sendPiece, g_pDatList[m_sendPiece]);
        //                m_sendPiece++;
        //            }
        //        }
    }

    //    if(m_sendPiece == m_totalPieces)
    //    {
    //        ui->actionStart->setEnabled(true);
    //        ui->actionStartIcon->setEnabled(true);
    //    }
}

void MainWindow::slotLoadAutoPrintFiles()
{    
    QString iniName = "MachineNo" + QString::number(g_machineList[m_curMcIdx]->m_mcPrintInfo.m_mcNum) + ".ini";
    QDir apppath(qApp->applicationDirPath());
    QString iniPath = apppath.path() + apppath.separator() + iniName;
    QSettings setting(iniPath, QSettings::IniFormat); //QSettings能记录一些程序中的信息，下次再打开时可以读取出来
    QString dirPath = setting.value("AutoPrintDir/fileDir").toString();
    QDir dir(dirPath);
    if(!dir.exists())
    {
        return;
    }

    QString state = tr("Waitting");
    QString number = "1";
    QString start = "0mm";

    QStringList filter;
    filter << QString("*.plt") << QString("*.PLT")
           << QString("*.png") << QString("*.PNG")
           << QString("*.bmp") << QString("*.BMP")
           << QString("*.jpg") << QString("*.JPG");
    QFileInfoList fileList = dir.entryInfoList(filter, QDir::Files | QDir::NoSymLinks);

    for(int i = 0; i < fileList.size(); i++)
    {
        if(m_breakAutoLoadThread == 1)
        {
            m_breakAutoLoadThread = 0;
            return;
        }
        QCoreApplication::processEvents(QEventLoop::AllEvents);

        QFileInfo fileInfo(fileList[i]);
        QString filePath = fileInfo.filePath();

        int row = m_tabelViewModelFile->rowCount();//当前表格的行数
        m_tabelViewModelFile->insertRow(row);//在最后一行的后面插入一行

        if(i < g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList.size())
        {
            if(g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[i].m_creatDataFlag == 1)
            {
                m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row, COLUMN_FILENAME),g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[i].m_fileName);
                QRect rect = g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[i].m_fileRect;
                QString length = QString::number((rect.right() - rect.left())/(int)M_IDPMM)+"mm";
                m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row, COLUMN_LENGTH),length);
                QString width = QString::number((rect.bottom() - rect.top())/(int)M_IDPMM)+"mm";
                m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row, COLUMN_WIDTH),width);
                m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row, COLUMN_START),start);
                m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row, COLUMN_PRINTEDLENGTH),"0mm");
                m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row, COLUMN_NUMBERS),number);
                m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row, COLUMN_STATE),state);
                m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row, COLUMN_FILEPATH),g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[i].m_filePath);

                continue;
            }
        }

        McFilesInfo curFilesInfo;//当前文件信息
        creatMarkerDat(curFilesInfo,filePath);

        m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row, COLUMN_FILENAME),curFilesInfo.m_fileName);
        QRect rect = curFilesInfo.m_fileRect;
        QString length = QString::number((rect.right() - rect.left())/(int)M_IDPMM)+"mm";
        m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row, COLUMN_LENGTH),length);
        QString width = QString::number((rect.bottom() - rect.top())/(int)M_IDPMM)+"mm";
        m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row, COLUMN_WIDTH),width);
        m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row, COLUMN_START),start);
        m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row, COLUMN_PRINTEDLENGTH),"0mm");
        m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row, COLUMN_NUMBERS),number);
        m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row, COLUMN_STATE),state);
        m_tabelViewModelFile->setData(m_tabelViewModelFile->index(row, COLUMN_FILEPATH),curFilesInfo.m_filePath);

        long long fileTotalLength = (curFilesInfo.m_fileRect.right() - curFilesInfo.m_fileRect.left())/M_IDPMM;

        g_machineList[m_curMcIdx]->m_mcPrintInfo.m_fileNums = i+1;
        g_machineList[m_curMcIdx]->m_mcPrintInfo.m_fileTotalLength += fileTotalLength;
        ui->label_fileTotalVal->setText(QString::number(g_machineList[m_curMcIdx]->m_mcPrintInfo.m_fileNums));
        ui->label_fileTotalLenthVal->setText(QString::number(g_machineList[m_curMcIdx]->m_mcPrintInfo.m_fileTotalLength)+"mm");
        g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList.append(curFilesInfo);
    }
    g_machineList[m_curMcIdx]->m_mcPrintInfo.m_loadFileFinishFlag = 1;
}

//1秒定时器
void MainWindow::onOneSecondTimer()
{
    refConnectUi();//刷新连接
}

void MainWindow::creatMarkerDat(McFilesInfo &curFilesInfo, QString filePath)
{
    QFileInfo fileInfo(filePath);
    curFilesInfo.m_marker.Initialize();

    if(fileInfo.suffix().toUpper() == "PLT")
    {
        ImportHPGL importHPGL;
        curFilesInfo.m_fileType = TYPE_FILE;

        //判断是否为加密文件
        if (importHPGL.IsSecretFile(filePath) == true)
        {
            // 文件路径
            QDir apppath(qApp->applicationDirPath());
            QString strSecretFile = apppath.path() + apppath.separator() + "Secret.plt";

            importHPGL.BitMapDtat(filePath,strSecretFile);
            importHPGL.IniPara();
            importHPGL.ReadSecretFile(strSecretFile,&curFilesInfo.m_marker);
        }
        else
        {
            importHPGL.IniPara();
            importHPGL.Read(filePath,&curFilesInfo.m_marker);
        }
        curFilesInfo.m_fileRect = curFilesInfo.m_marker.GetRect();
    }
    else
    {
        curFilesInfo.m_fileType = TYPE_IMAGE;
        QBitmap pixmap;
        pixmap.load(filePath);
        QRect rect;
        rect.setRect(0,0,pixmap.width()/MMPIXELY*M_IDPMM,pixmap.height()/MMPIXELY*M_IDPMM);

        curFilesInfo.m_pixmap = pixmap;
        curFilesInfo.m_fileRect = rect;
    }

    curFilesInfo.m_filePath = filePath;
    curFilesInfo.m_fileName = fileInfo.fileName();
    curFilesInfo.m_printNum = 1;
    curFilesInfo.m_startPoint = 0;
    curFilesInfo.m_printState = tr("Waitting");
    curFilesInfo.m_curPrintBlock = 0;//当前打印块数
    curFilesInfo.m_printedBlockNum = 0;//已打印块数
    curFilesInfo.m_selectBlockNum = 0;//当前选择块数
    curFilesInfo.m_creatDataFlag = 1;
}

void MainWindow::on_actionDrawing_Setting_triggered()
{
    if(m_drawingSetDlg!= NULL)
    {
        m_drawingSetDlg->exec();
    }
}

void MainWindow::on_actionPlotter_Setting_triggered()
{
    if(m_plotterSetDlg != NULL)
    {
        m_plotterSetDlg->exec();
    }
}

void MainWindow::on_actionlog_triggered()
{
    if(m_historyDlg!= NULL)
    {
        m_historyDlg->exec();
    }
}

void MainWindow::on_actionOpen_File_triggered()
{
    if(m_curMcIdx < 0 || m_curMcIdx >= g_machineList.size())
    {
        QMessageBox::warning(this,
                             tr("Prompt"),
                             tr("Please select a machine!"),        //请选择机器！
                             QMessageBox::Ok);
        return;
    }

    if(g_machineList[m_curMcIdx]->m_mcPrintInfo.m_loadFileFinishFlag < 0)
    {
        QMessageBox::warning(this,
                             tr("Prompt"),
                             tr("Loading file, please wait!"),        //正在加载文件，请等待！
                             QMessageBox::Ok);
        return;
    }

    QDir apppath(qApp->applicationDirPath());
    QString iniPath = apppath.path() + apppath.separator() + "config.ini";
    QSettings setting(iniPath, QSettings::IniFormat); //QSettings能记录一些程序中的信息，下次再打开时可以读取出来
    QString lastPath = setting.value("LastFilePath/filePath").toString(); //获取上次的打开路径

    QString filePath;

    filePath = QFileDialog::getOpenFileName(this,
                                            tr("Open File Dialog"),//打开文件对话框
                                            lastPath,
                                            tr("File(*.plt *.dxf)"));//plt 文件

    if (filePath.isNull() == 0)
    {
        QFileInfo fileInfo(filePath);
        QString fileName = fileInfo.fileName();
        QString path = filePath;
        setting.setValue("LastFilePath/filePath",path.remove(fileName)); //记录路径到QSetting中保存

        m_curFilesInfo.m_marker.Initialize();

        if(fileInfo.suffix().toUpper() == "DXF")
        {
            DxfHelper dxfHelper;
            if(dxfHelper.generateDxf(filePath))
            {
                dxfHelper.getDxfPaths(); // 获取转换出来的dxf所有类型图形的点集
                QImage img = dxfHelper.generateDXFImage(); // 获取预览图像
                img.save("D:\\1.png");
            }
        }
        if(fileInfo.suffix().toUpper() == "PLT")
        {
            ImportHPGL importHPGL;
            //判断是否为加密文件
            if (importHPGL.IsSecretFile(filePath) == true)
            {
                // 文件路径
                QDir apppath(qApp->applicationDirPath());
                QString strSecretFile = apppath.path() + apppath.separator() + "Secret.plt";

                importHPGL.BitMapDtat(filePath,strSecretFile);
                importHPGL.IniPara();
                importHPGL.ReadSecretFile(strSecretFile,&m_curFilesInfo.m_marker);
            }
            else
            {
                importHPGL.IniPara();
                importHPGL.Read(filePath,&m_curFilesInfo.m_marker);
            }
            //importHPGL.creatPolylinePainterPath();

            QFileInfo file(filePath);
            m_curFilesInfo.m_filePath = filePath;
            m_curFilesInfo.m_fileName = file.fileName();
            m_curFilesInfo.m_fileType = TYPE_FILE;
            m_curFilesInfo.m_fileRect = m_curFilesInfo.m_marker.GetRect();
            //m_curFilesInfo.m_painterPath = importHPGL.GetPolylinePainterPath();

            m_printViewWi->refreshShow(m_curFilesInfo,1);
        }
    }
    return;
}

void MainWindow::on_tableView_fileList_clicked(const QModelIndex &index)
{
    int row = index.row();
    m_curFileRow = row;
    reflushPreview(row);

    //判断是否正在打印，如果正在打印时不可删除、移动、修改打印信息
    ui->frame_fileBtn->setEnabled(true);
    if(g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[m_curFileRow].m_curPrintBlock != 0)
    {
        ui->frame_fileBtn->setEnabled(false);
    }

    if(g_machineList[m_curMcIdx]->m_mcPrintInfo.m_mcWorkState == Busying)
    {
        if((m_curFileRow+1) == m_curPrintFileIdx)
        {
            ui->pushButton_up->setEnabled(false);
        }
    }
}

void MainWindow::on_pushButton_up_clicked()
{
    changeRowData(-1);
}

void MainWindow::on_pushButton_down_clicked()
{
    changeRowData(1);
}

void MainWindow::on_pushButton_delete_clicked()
{
    slotDeleteFile();
}

void MainWindow::on_pushButton_preview_clicked()
{
    slotPrintPreview();
}

void MainWindow::on_actionOpenFileIcon_triggered()
{
    on_actionOpen_File_triggered();
}

void MainWindow::on_actionOpen_Image_triggered()
{
    if(m_curMcIdx < 0 || m_curMcIdx >= g_machineList.size())
    {
        QMessageBox::warning(this,
                             tr("Prompt"),
                             tr("Please select a machine!"),        //请选择机器！
                             QMessageBox::Ok);
        return;
    }

    if(g_machineList[m_curMcIdx]->m_mcPrintInfo.m_loadFileFinishFlag < 0)
    {
        QMessageBox::warning(this,
                             tr("Prompt"),
                             tr("Loading file, please wait!"),        //正在加载文件，请等待！
                             QMessageBox::Ok);
        return;
    }

    QDir apppath(qApp->applicationDirPath());
    QString iniPath = apppath.path() + apppath.separator() + "config.ini";
    QSettings setting(iniPath, QSettings::IniFormat); //QSettings能记录一些程序中的信息，下次再打开时可以读取出来
    QString lastPath = setting.value("LastFilePath/filePath").toString(); //获取上次的打开路径

    QString filePath;

    filePath = QFileDialog::getOpenFileName(this,
                                            tr("Open File Dialog"),//打开文件对话框
                                            lastPath,
                                            tr("Image File(*.png *.bmp *.jpg)"));//图像文件

    if (filePath.isNull() == 0)
    {
        QFileInfo fileInfo(filePath);
        QString fileName = fileInfo.fileName();
        QString path = filePath;
        setting.setValue("LastFilePath/filePath",path.remove(fileName)); //记录路径到QSetting中保存

        m_curFilesInfo.m_marker.Initialize();
        m_curFilesInfo.m_filePath = filePath;
        m_curFilesInfo.m_fileName = fileName;
        m_curFilesInfo.m_fileType = TYPE_IMAGE;

        QBitmap pixmap;
        pixmap.load(filePath);
        QRect rect;
        rect.setRect(0,0,pixmap.width()/MMPIXELY*M_IDPMM,pixmap.height()/MMPIXELY*M_IDPMM);

        m_curFilesInfo.m_pixmap = pixmap;
        m_curFilesInfo.m_fileRect = rect;
        m_printViewWi->refreshShow(m_curFilesInfo,1);
    }
}

void MainWindow::on_actionOpenImageIcon_triggered()
{
    on_actionOpen_Image_triggered();
}

void MainWindow::on_actionDelete_triggered()
{
    slotDeleteFile();
}

void MainWindow::on_actionAuto_Print_Dir_triggered()
{
    if(m_curMcIdx < 0)
    {
        QMessageBox::warning(this,
                             tr("Prompt"),
                             tr("Please select the machine you want to set the directory!"),//请选择要设置目录的机器！
                             QMessageBox::Ok);
        return;
    }

    //以机器编号命名ini文件
    QString iniName = "MachineNo" + QString::number(g_machineList[m_curMcIdx]->m_mcPrintInfo.m_mcNum) + ".ini";
    QDir apppath(qApp->applicationDirPath());
    QString iniPath = apppath.path() + apppath.separator() + iniName;
    QSettings setting(iniPath, QSettings::IniFormat); //QSettings能记录一些程序中的信息，下次再打开时可以读取出来

    // 获取文件路径
    QString fileDir = QFileDialog::getExistingDirectory(this, tr("Select Folder"));
    if (!fileDir.isEmpty())
    {
        setting.setValue("AutoPrintDir/fileDir",fileDir); //记录路径到QSetting中保存
        g_machineList[m_curMcIdx]->m_mcPrintInfo.m_loadFileFinishFlag = -1;
        for(int i = 0; i < g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList.size(); i++)
        {
            g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList[i].clear();
        }
        g_machineList[m_curMcIdx]->m_mcPrintInfo.m_filesList.clear();
        g_machineList[m_curMcIdx]->m_mcPrintInfo.m_fileTotalLength = 0;
        refreshMcFileListShow(m_curMcIdx);
    }
}

void MainWindow::on_actionStart_triggered()
{
    m_workState = START;
    startCreatBmpAndSend(m_curMcIdx);
}

void MainWindow::on_actionStartIcon_triggered()
{
    m_workState = START;
    startCreatBmpAndSend(m_curMcIdx);
}

void MainWindow::on_actionPause_triggered()
{
    m_workState = PAUSE;
}

void MainWindow::on_actionPauseIcon_triggered()
{
    m_workState = PAUSE;
}

void MainWindow::on_actionAddMachine_triggered()
{
    AddMachineDialog addMcDlg;
    if(addMcDlg.exec() == 1)
    {
        //读取配置文件是否存在同名的机器名称
        QDir apppath(qApp->applicationDirPath());
        QString configfile;
        configfile = apppath.path() + apppath.separator() + "config.ini";
        QSettings settings(configfile, QSettings::IniFormat);
        QString mcName = addMcDlg.getMcName();
        QString serverIp = addMcDlg.getMcIp();
        quint16 serverPort = 5000;

        int idx = 0;
        for(int i = 1; i <= MACHINE_NUM; i++)
        {
            QString str = "MachineNo" + QString::number(i);
            QString keyStr = str +  + "/name";
            bool bl =  settings.contains(keyStr);
            if(bl == false)
            {
                QString strName = str + "/name";
                settings.setValue(strName,mcName);
                QString strIp = str + "/ip";
                settings.setValue(strIp,serverIp);
                QString strPort = str + "/port";
                settings.setValue(strPort,serverPort);
                idx = i;
                break;
            }
        }

        if(idx == 0)
        {
            QMessageBox::warning(this,
                                 tr("Prompt"),
                                 tr("The maximum number of connections has been reached and cannot be added again!"),//已达到最大连接数量，不可再添加！
                                 QMessageBox::Ok);
            return;
        }

        //本地IP和端口
        QString localIp = settings.value("Local/ip").toString();
        quint16 localPort = settings.value("Local/port").toInt();

        Machine *pMachine = new Machine();   //建立连接
        pMachine->setIpAndPort(mcName,serverIp,serverPort,localIp,localPort);//设置IP和端口
        pMachine->startCommunication();
        McPrintInfo mcf;
        mcf.m_mcNum = idx;
        mcf.m_mcName = mcName;
        mcf.m_ip = serverIp;
        mcf.m_port = serverPort;
        mcf.m_loadFileFinishFlag = 1;
        pMachine->m_mcPrintInfo = mcf;
        g_machineList.append(pMachine);

        int row = m_tabelViewModelConn->rowCount();//当前表格的行数
        m_tabelViewModelConn->insertRow(row);//在最后一行的后面插入一行
        refreshMcFileListShow(row);
        ui->tableView_Connection->selectRow(row);
        refreshOneMcShow(row,g_machineList.size()-1);
        if(!ui->menuFile_F->isEnabled())
        {
            if(g_machineList.size() > 0)
            {
                ui->menuFile_F->setEnabled(true);
            }
        }
    }
}

void MainWindow::on_actionDeletMachine_triggered()
{
    slotDeleteMc();
}

void MainWindow::on_tableView_Connection_clicked(const QModelIndex &index)
{
    refreshMcFileListShow(index.row());
    ui->tableView_Connection->selectRow(m_curMcIdx);
}