yanchaoyang
/
TrainCamp_yanchaoyang_Two
1
0
포크 0
코드 이슈 0 풀 리퀘스트 0 릴리즈 0 위키 활동
25개 이상의 토픽을 선택하실 수 없습니다. Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10 커밋
1 브렌치
327 KiB
 
 
브렌치: main
브랜치 태그
${ item.name }
${ searchTerm } 브랜치 생성
from 'main'
${ noResults }
TrainCamp_yanchaoyang_Two/untitled/mainwindow.cpp

609 lines
21 KiB
Raw 고유링크 Blame 히스토리 

  1. #include "mainwindow.h"

  2. #include "hmidocument.h"

  3. #include "plcdocument.h"

  4. #include <QMenuBar>

  5. #include <QAction>

  6. #include <QToolButton>

  7. #include <QMimeData>

  8. #include <QDrag>

  9. #include <QTabBar>

  10. #include <QEvent>

  11. #include <QMouseEvent>

  12. #include <QDragEnterEvent>

  13. #include <QDragMoveEvent>

  14. #include <QDropEvent>

  15. #include <QDebug>

  16. #include <QVBoxLayout>

  17. #include <QFileDialog>

  18. #include <QMessageBox>

  19. #include <QTextEdit>

  20. 

  21. MainWindow::MainWindow(QWidget *parent)

  22.     : QMainWindow(parent)

  23. {

  24.     setWindowTitle("综合平台编程器");

  25.     setGeometry(500, 200, 1000, 700);

  26. 

  27.     // 初始化标签页

  28.     m_tabWidget = new QTabWidget(this);

  29.     m_tabWidget->setTabsClosable(true);

  30.     setCentralWidget(m_tabWidget);

  31.     connect(m_tabWidget, &QTabWidget::currentChanged, this, &MainWindow::onTabChanged);

  32.     connect(m_tabWidget, &QTabWidget::tabCloseRequested, this, &MainWindow::onCloseTab);

  33.     createMenus();// 创建菜单和工具栏

  34.     createToolbars();

  35. }

  36. 

  37. MainWindow::~MainWindow()

  38. {

  39. }

  40. 

  41. // 创建菜单栏

  42. void MainWindow::createMenus()

  43. {

  44.     // 设置菜单栏字体大小

  45.     QFont menuFont = menuBar()->font();

  46.     menuFont.setPointSize(15); // 菜单栏文字大小

  47.     menuBar()->setFont(menuFont);

  48. 

  49.     // 创建文件菜单

  50.     QMenu *fileMenu = menuBar()->addMenu("文件");

  51.     QMenu *editMenu = menuBar()->addMenu("操作");

  52. 

  53.     // 设置菜单项字体大小（适用于所有子菜单）

  54.     QFont itemFont = fileMenu->font();

  55.     itemFont.setPointSize(12); // 菜单项文字大小

  56.     fileMenu->setFont(itemFont);

  57.     editMenu->setFont(itemFont);

  58. 

  59.     // 新建HMI动作

  60.     QAction *newHmiAction = new QAction("新建HMI(&H)", this);

  61.     newHmiAction->setShortcut(tr("Ctrl+H"));

  62.     newHmiAction->setFont(itemFont); // 设置动作文字大小

  63.     connect(newHmiAction, &QAction::triggered, this, &MainWindow::onNewHMI);

  64.     fileMenu->addAction(newHmiAction);

  65. 

  66.     // 新建PLC动作

  67.     QAction *newPlcAction = new QAction("新建PLC(&P)", this);

  68.     newPlcAction->setShortcut(tr("Ctrl+P"));

  69.     newPlcAction->setFont(itemFont);

  70.     connect(newPlcAction, &QAction::triggered, this, &MainWindow::onNewPLC);

  71.     fileMenu->addAction(newPlcAction);

  72. 

  73.     // 打开动作

  74.     m_openAction = new QAction("打开(&O)", this);

  75.     m_openAction->setShortcut(QKeySequence::Open);

  76.     m_openAction->setStatusTip("打开现有文档");

  77.     m_openAction->setFont(itemFont);

  78.     connect(m_openAction, &QAction::triggered, this, &MainWindow::onOpen);

  79.     fileMenu->addAction(m_openAction);

  80. 

  81.     // 保存动作

  82.     m_saveAction = new QAction("保存(&S)", this);

  83.     m_saveAction->setShortcut(QKeySequence::Save);

  84.     m_saveAction->setStatusTip("保存当前文档");

  85.     m_saveAction->setFont(itemFont);

  86.     connect(m_saveAction, &QAction::triggered, this, &MainWindow::onSave);

  87.     fileMenu->addAction(m_saveAction);

  88. 

  89.     // 另存为动作

  90.     m_saveAsAction = new QAction("另存为(&A)", this);

  91.     m_saveAsAction->setShortcut(QKeySequence::SaveAs);

  92.     m_saveAsAction->setStatusTip("将文档另存为");

  93.     m_saveAsAction->setFont(itemFont);

  94.     connect(m_saveAsAction, &QAction::triggered, this, &MainWindow::onSaveAs);

  95.     fileMenu->addAction(m_saveAsAction);

  96. 

  97.     // 操作菜单 - 添加复制、粘贴、删除功能

  98.     QAction *copyAction = new QAction("复制(&C)", this);

  99.     copyAction->setShortcut(QKeySequence::Copy);

  100.     copyAction->setStatusTip("复制选中的项目");

  101.     copyAction->setFont(itemFont);

  102.     connect(copyAction, &QAction::triggered, this, [this]() {

  103.         if (auto hmiDoc = dynamic_cast<HMIDocument*>(m_tabWidget->currentWidget())) {

  104.             hmiDoc->copySelectedItems();

  105.         }

  106.     });

  107. 

  108.     QAction *pasteAction = new QAction("粘贴(&V)", this);

  109.     pasteAction->setShortcut(QKeySequence::Paste);

  110.     pasteAction->setStatusTip("粘贴复制的项目");

  111.     pasteAction->setFont(itemFont);

  112.     connect(pasteAction, &QAction::triggered, this, [this]() {

  113.         if (auto hmiDoc = dynamic_cast<HMIDocument*>(m_tabWidget->currentWidget())) {

  114.             hmiDoc->pasteItems();

  115.         }

  116.     });

  117. 

  118.     QAction *deleteAction = new QAction("删除(&D)", this);

  119.     deleteAction->setShortcut(QKeySequence::Delete);

  120.     deleteAction->setStatusTip("删除选中的项目");

  121.     deleteAction->setFont(itemFont);

  122.     connect(deleteAction, &QAction::triggered, this, [this]() {

  123.         if (auto hmiDoc = dynamic_cast<HMIDocument*>(m_tabWidget->currentWidget())) {

  124.             hmiDoc->deleteSelectedItems();

  125.         }

  126.     });

  127. 

  128.     // 添加到操作菜单

  129.     editMenu->addAction(copyAction);

  130.     editMenu->addAction(pasteAction);

  131.     editMenu->addAction(deleteAction);

  132. }

  133. 

  134. // 创建左侧工具栏

  135. void MainWindow::createToolbars()

  136. {

  137.     m_leftToolBar = new QToolBar("绘图工具栏", this);

  138.     addToolBar(Qt::LeftToolBarArea, m_leftToolBar);

  139.     m_leftToolBar->setAllowedAreas(Qt::LeftToolBarArea); // 仅允许在左侧

  140.     m_leftToolBar->setFixedWidth(230);

  141. }

  142. 

  143. // 更新工具栏（根据当前文档类型）

  144. void MainWindow::updateToolBar(BaseDocument *doc)

  145. {

  146.     m_leftToolBar->clear();// 清空现有工具

  147.     if (!doc) return;

  148.     if (doc->type() == BaseDocument::HMI)// HMI文档显示绘图工具

  149.     {

  150.         HMIDocument *hmiDoc = dynamic_cast<HMIDocument*>(doc);

  151.         if (!hmiDoc) return;

  152.         // 画指示灯按钮（支持拖拽）

  153.         QToolButton *ellipseBtn = new QToolButton;

  154.         ellipseBtn->setText("指示灯");

  155.         ellipseBtn->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);

  156.         ellipseBtn->setIcon(QIcon("../two/untitled/images/灯泡.png"));//可替换为实际图标

  157.         ellipseBtn->installEventFilter(this);//为按钮安装事件过滤器处理拖拽

  158.         ellipseBtn->setProperty("toolType", "指示灯");

  159.         m_leftToolBar->addWidget(ellipseBtn);

  160.         ellipseBtn->setStyleSheet(R"(

  161.             QToolButton {

  162.                 margin: 2 auto;

  163.                 background-color: #f0f0f0;

  164.                 border-radius: 10px;

  165.                 border: 1px solid #ccc;

  166.                 padding: 10px 15px;

  167.                 font-size: 25px;

  168.                 font-weight: bold;

  169.                 color: #333;

  170.             }

  171.             QToolButton:hover {

  172.                 background-color: #e0e0e0;

  173.             }

  174.         )");

  175. 

  176.         // 画按钮按钮（支持拖拽）

  177.         QToolButton *rectBtn = new QToolButton;

  178.         rectBtn->setText("按钮");

  179.         rectBtn->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);

  180.         rectBtn->setIcon(QIcon("../two/untitled/images/按钮.png"));//可替换为实际图标

  181.         rectBtn->installEventFilter(this);

  182.         rectBtn->setProperty("toolType", "按钮");

  183.         m_leftToolBar->addWidget(rectBtn);

  184.         rectBtn->setStyleSheet(R"(

  185.             QToolButton {

  186.                 margin: 2 auto;

  187.                 background-color: #f0f0f0;

  188.                 border-radius: 10px;

  189.                 border: 1px solid #ccc;

  190.                 padding: 10px 28px;

  191.                 font-size: 25px;

  192.                 font-weight: bold;

  193.                 color: #333;

  194.             }

  195.             QToolButton:hover {

  196.                 background-color: #e0e0e0;

  197.             }

  198.         )");

  199.     }

  200.     // PLC按钮工具

  201.     else if (doc->type() == BaseDocument::PLC)

  202.     {

  203.         // 常开触点按钮

  204.         QToolButton *normallyOpenBtn = new QToolButton;

  205.         normallyOpenBtn->setText("常开");

  206.         normallyOpenBtn->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);

  207.         normallyOpenBtn->setIcon(QIcon("../two/untitled/images/T-常开触点-01.png")); // 替换为实际图标

  208.         normallyOpenBtn->installEventFilter(this);

  209.         normallyOpenBtn->setProperty("toolType", "常开");

  210.         m_leftToolBar->addWidget(normallyOpenBtn);

  211.         normallyOpenBtn->setStyleSheet(R"(

  212.             QToolButton {

  213.                 margin: 2 auto;

  214.                 background-color: #f0f0f0;

  215.                 border-radius: 10px;

  216.                 border: 1px solid #ccc;

  217.                 padding: 10px 28px;

  218.                 font-size: 25px;

  219.                 font-weight: bold;

  220.                 color: #333;

  221.             }

  222.             QToolButton:hover {

  223.                 background-color: #e0e0e0;

  224.             }

  225.         )");

  226. 

  227.         // 常闭触点按钮

  228.         QToolButton *normallyClosedBtn = new QToolButton;

  229.         normallyClosedBtn->setText("常闭");

  230.         normallyClosedBtn->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);

  231.         normallyClosedBtn->setIcon(QIcon("../two/untitled/images/T-常闭触点-01-01.png")); // 替换为实际图标

  232.         normallyClosedBtn->installEventFilter(this);

  233.         normallyClosedBtn->setProperty("toolType", "常闭");

  234.         m_leftToolBar->addWidget(normallyClosedBtn);

  235.         normallyClosedBtn->setStyleSheet(R"(

  236.             QToolButton {

  237.                 margin: 2 auto;

  238.                 background-color: #f0f0f0;

  239.                 border-radius: 10px;

  240.                 border: 1px solid #ccc;

  241.                 padding: 10px 28px;

  242.                 font-size: 25px;

  243.                 font-weight: bold;

  244.                 color: #333;

  245.             }

  246.             QToolButton:hover {

  247.                 background-color: #e0e0e0;

  248.             }

  249.         )");

  250. 

  251.         // 大于按钮

  252.         QToolButton *greaterThanBtn = new QToolButton;

  253.         greaterThanBtn->setText("大于");

  254.         greaterThanBtn->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);

  255.         greaterThanBtn->setIcon(QIcon("../two/untitled/images/大于号.png")); // 替换为实际图标

  256.         greaterThanBtn->installEventFilter(this);

  257.         greaterThanBtn->setProperty("toolType", "大于");

  258.         m_leftToolBar->addWidget(greaterThanBtn);

  259.         greaterThanBtn->setStyleSheet(R"(

  260.             QToolButton {

  261.                 margin: 2 auto;

  262.                 background-color: #f0f0f0;

  263.                 border-radius: 10px;

  264.                 border: 1px solid #ccc;

  265.                 padding: 10px 28px;

  266.                 font-size: 25px;

  267.                 font-weight: bold;

  268.                 color: #333;

  269.             }

  270.             QToolButton:hover {

  271.                 background-color: #e0e0e0;

  272.             }

  273.         )");

  274. 

  275.         // 大于等于按钮

  276.         QToolButton *greaterThanEqualBtn = new QToolButton;

  277.         greaterThanEqualBtn->setText("大于等于");

  278.         greaterThanEqualBtn->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);

  279.         greaterThanEqualBtn->setIcon(QIcon("../two/untitled/images/大于等于.png")); // 替换为实际图标

  280.         greaterThanEqualBtn->installEventFilter(this);

  281.         greaterThanEqualBtn->setProperty("toolType", "大于等于");

  282.         m_leftToolBar->addWidget(greaterThanEqualBtn);

  283.         greaterThanEqualBtn->setStyleSheet(R"(

  284.             QToolButton {

  285.                 margin: 2 auto;

  286.                 background-color: #f0f0f0;

  287.                 border-radius: 10px;

  288.                 border: 1px solid #ccc;

  289.                 padding: 10px 2px;

  290.                 font-size: 25px;

  291.                 font-weight: bold;

  292.                 color: #333;

  293.             }

  294.             QToolButton:hover {

  295.                 background-color: #e0e0e0;

  296.             }

  297.         )");

  298. 

  299.         // 小于按钮

  300.         QToolButton *lessThanBtn = new QToolButton;

  301.         lessThanBtn->setText("小于");

  302.         lessThanBtn->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);

  303.         lessThanBtn->setIcon(QIcon("../two/untitled/images/小于号.png")); // 替换为实际图标

  304.         lessThanBtn->installEventFilter(this);

  305.         lessThanBtn->setProperty("toolType", "小于");

  306.         m_leftToolBar->addWidget(lessThanBtn);

  307.         lessThanBtn->setStyleSheet(R"(

  308.             QToolButton {

  309.                 margin: 2 auto;

  310.                 background-color: #f0f0f0;

  311.                 border-radius: 10px;

  312.                 border: 1px solid #ccc;

  313.                 padding: 10px 28px;

  314.                 font-size: 25px;

  315.                 font-weight: bold;

  316.                 color: #333;

  317.             }

  318.             QToolButton:hover {

  319.                 background-color: #e0e0e0;

  320.             }

  321.         )");

  322. 

  323.         // 小于等于按钮

  324.         QToolButton *lessThanEqualBtn = new QToolButton;

  325.         lessThanEqualBtn->setText("小于等于");

  326.         lessThanEqualBtn->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);

  327.         lessThanEqualBtn->setIcon(QIcon("../two/untitled/images/小于等于.png")); // 替换为实际图标

  328.         lessThanEqualBtn->installEventFilter(this);

  329.         lessThanEqualBtn->setProperty("toolType", "小于等于");

  330.         m_leftToolBar->addWidget(lessThanEqualBtn);

  331.         lessThanEqualBtn->setStyleSheet(R"(

  332.             QToolButton {

  333.                 margin: 2 auto;

  334.                 background-color: #f0f0f0;

  335.                 border-radius: 10px;

  336.                 border: 1px solid #ccc;

  337.                 padding: 10px 2px;

  338.                 font-size: 25px;

  339.                 font-weight: bold;

  340.                 color: #333;

  341.             }

  342.             QToolButton:hover {

  343.                 background-color: #e0e0e0;

  344.             }

  345.         )");

  346.         // 等于按钮

  347.         QToolButton *equalBtn = new QToolButton;

  348.         equalBtn->setText("等于");

  349.         equalBtn->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);

  350.         equalBtn->setIcon(QIcon("../two/untitled/images/等于.png")); // 替换为实际图标

  351.         equalBtn->installEventFilter(this);

  352.         equalBtn->setProperty("toolType", "等于");

  353.         m_leftToolBar->addWidget(equalBtn);

  354.         equalBtn->setStyleSheet(R"(

  355.             QToolButton {

  356.                 margin: 2 auto;

  357.                 background-color: #f0f0f0;

  358.                 border-radius: 10px;

  359.                 border: 1px solid #ccc;

  360.                 padding: 10px 28px;

  361.                 font-size: 25px;

  362.                 font-weight: bold;

  363.                 color: #333;

  364.             }

  365.             QToolButton:hover {

  366.                 background-color: #e0e0e0;

  367.             }

  368.         )");

  369.         // 线圈按钮

  370.         QToolButton *coilBtn = new QToolButton;

  371.         coilBtn->setText("线圈");

  372.         coilBtn->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);

  373.         coilBtn->setIcon(QIcon("../two/untitled/images/添加线圈.png")); // 替换为实际图标

  374.         coilBtn->installEventFilter(this);

  375.         coilBtn->setProperty("toolType", "线圈");

  376.         m_leftToolBar->addWidget(coilBtn);

  377.         coilBtn->setStyleSheet(R"(

  378.             QToolButton {

  379.                 margin: 2 auto;

  380.                 background-color: #f0f0f0;

  381.                 border-radius: 10px;

  382.                 border: 1px solid #ccc;

  383.                 padding: 10px 28px;

  384.                 font-size: 25px;

  385.                 font-weight: bold;

  386.                 color: #333;

  387.             }

  388.             QToolButton:hover {

  389.                 background-color: #e0e0e0;

  390.             }

  391.         )");

  392. 

  393.         normallyOpenBtn->installEventFilter(this);

  394.             normallyClosedBtn->installEventFilter(this);

  395.             greaterThanBtn->installEventFilter(this);

  396.             greaterThanEqualBtn->installEventFilter(this);

  397.             lessThanBtn->installEventFilter(this);

  398.             lessThanEqualBtn->installEventFilter(this);

  399.             equalBtn->installEventFilter(this);

  400.             coilBtn->installEventFilter(this);

  401.     }

  402. }

  403. 

  404. // 事件过滤器处理拖拽

  405. bool MainWindow::eventFilter(QObject *obj, QEvent *event)

  406. {

  407.     QToolButton *toolBtn = qobject_cast<QToolButton*>(obj);

  408.     if (toolBtn && event->type() == QEvent::MouseButtonPress)

  409.     {

  410.         QMouseEvent *me = static_cast<QMouseEvent*>(event);

  411.         if (me->button() == Qt::LeftButton)

  412.         {

  413.             QString toolType = toolBtn->property("toolType").toString();

  414.             if (!toolType.isEmpty())

  415.             {

  416.                 BaseDocument* currentDoc = dynamic_cast<BaseDocument*>(m_tabWidget->currentWidget());

  417.                 if (currentDoc && currentDoc->type() == BaseDocument::PLC)//PLC文档处理

  418.                 {

  419.                     PLCDocument* plcDoc = static_cast<PLCDocument*>(currentDoc);

  420.                     // 设置当前工具

  421.                     plcDoc->setCurrentTool(toolType);

  422.                     // 创建拖拽对象

  423.                     QMimeData *mime = new QMimeData;

  424.                     mime->setText(toolType);

  425.                     QDrag *drag = new QDrag(toolBtn);

  426.                     drag->setMimeData(mime);

  427.                     drag->exec(Qt::CopyAction);

  428.                     return true;

  429.                 }

  430.                 // HMI文档处理（原有代码）

  431.                 if (currentDoc && currentDoc->type() == BaseDocument::HMI)

  432.                 {

  433.                     HMIDocument* hmiDoc = static_cast<HMIDocument*>(currentDoc);

  434.                     if (toolType == "指示灯")

  435.                     {

  436.                         hmiDoc->startDrawingEllipse();//点击生成标志

  437.                     }

  438.                     else if (toolType == "按钮")

  439.                     {

  440.                         hmiDoc->startDrawingRectangle();//点击生成标志

  441.                     }

  442.                     // 新增拖拽逻辑（与PLC一致）

  443.                     QMimeData *mime = new QMimeData;

  444.                     mime->setText(toolType);//传递工具类型（"指示灯"或"按钮"）

  445.                     QDrag *drag = new QDrag(toolBtn);

  446.                     drag->setMimeData(mime);

  447.                     drag->exec(Qt::CopyAction);//启动拖拽

  448.                     return true;

  449.                 }

  450.             }

  451.         }

  452.     }

  453.     return QMainWindow::eventFilter(obj, event);

  454. }

  455. 

  456. // 新建HMI文档

  457. void MainWindow::onNewHMI()

  458. {

  459.     m_hmiCount++;

  460.     HMIDocument *doc = new HMIDocument;

  461.     doc->setTitle("HMI文档 " + QString::number(m_hmiCount));

  462.     m_tabWidget->addTab(doc, doc->title());

  463.     m_tabWidget->setCurrentWidget(doc);

  464.     updateToolBar(doc); // 更新工具栏为HMI工具

  465. }

  466. 

  467. // 新建PLC文档

  468. void MainWindow::onNewPLC()

  469. {

  470.     m_plcCount++;

  471.     PLCDocument *doc = new PLCDocument;

  472.     m_tabWidget->addTab(doc, QString("PLC文档 %1").arg(m_plcCount));

  473.     m_tabWidget->setCurrentWidget(doc);

  474.     updateToolBar(doc); // 更新工具栏为PLC工具

  475. }

  476. // 标签页切换时更新工具栏

  477. void MainWindow::onTabChanged(int idx)

  478. {

  479.     if (idx < 0)

  480.     {

  481.         updateToolBar(nullptr);

  482.         return;

  483.     }

  484.     BaseDocument *doc = dynamic_cast<BaseDocument*>(m_tabWidget->widget(idx));

  485.     updateToolBar(doc);

  486. }

  487. // 保存文档

  488. void MainWindow::onSave()

  489. {

  490.     BaseDocument *doc = dynamic_cast<BaseDocument*>(m_tabWidget->currentWidget());

  491.     if (!doc) return;

  492. 

  493.     if (doc->filePath().isEmpty()) {

  494.         saveDocumentAs(doc);

  495.     } else {

  496.         saveDocument(doc);

  497.     }

  498. }

  499. // 另存为文档

  500. void MainWindow::onSaveAs()

  501. {

  502.     BaseDocument *doc = dynamic_cast<BaseDocument*>(m_tabWidget->currentWidget());

  503.     if (doc) {

  504.         saveDocumentAs(doc);

  505.     }

  506. }

  507. // 打开文档

  508. void MainWindow::onOpen()

  509. {

  510.     QString filePath = QFileDialog::getOpenFileName(

  511.         this,

  512.         "打开文档",

  513.         "",

  514.         "HMI文档 (*.hmi);;PLC文档 (*.plc)"

  515.     );

  516. 

  517.     if (filePath.isEmpty()) return;

  518. 

  519.     QFileInfo fileInfo(filePath);

  520.     BaseDocument *doc = nullptr;

  521. 

  522.     if (fileInfo.suffix().toLower() == "hmi") {

  523.         doc = new HMIDocument;

  524.     } else if (fileInfo.suffix().toLower() == "plc") {

  525.         doc = new PLCDocument;

  526.     } else {

  527.         QMessageBox::warning(this, "打开文档", "不支持的文件格式");

  528.         return;

  529.     }

  530. 

  531.     if (doc->loadFromFile(filePath)) {

  532.         m_tabWidget->addTab(doc, doc->title());

  533.         m_tabWidget->setCurrentWidget(doc);

  534.         updateToolBar(doc);

  535.     } else {

  536.         QMessageBox::critical(this, "打开文档", "无法加载文档");

  537.         delete doc;

  538.     }

  539. }

  540. // 关闭标签页

  541. void MainWindow::onCloseTab(int index)

  542. {

  543.     BaseDocument *doc = dynamic_cast<BaseDocument*>(m_tabWidget->widget(index));

  544.     if (!doc) return;

  545. 

  546.     if (doc->isModified())

  547.     {

  548.         QMessageBox::StandardButton reply = QMessageBox::question(

  549.             this,

  550.             "保存文档",

  551.             QString("文档 '%1' 已修改，是否保存更改？").arg(doc->title()),

  552.             QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel

  553.         );

  554. 

  555.         if (reply == QMessageBox::Save) {

  556.             saveDocument(doc);

  557.         } else if (reply == QMessageBox::Cancel) {

  558.             return;

  559.         }

  560.     }

  561. 

  562.     m_tabWidget->removeTab(index);

  563.     delete doc;

  564. }

  565. // 保存文档

  566. void MainWindow::saveDocument(BaseDocument *doc)

  567. {

  568.     // 如果文件路径为空（新文件），执行“另存为”

  569.     if (doc->filePath().isEmpty())

  570.     {

  571.         // 直接调用另存为函数

  572.         saveDocumentAs(doc);

  573.     }

  574.     else

  575.     {

  576.         // 如果已有文件路径，直接保存

  577.         if (doc->saveToFile(doc->filePath()))

  578.         {

  579.             doc->setModified(false); // 清除修改状态

  580.             QMessageBox::information(this, "保存文档", "文档保存成功");

  581.         }

  582.         else

  583.         {

  584.             QMessageBox::critical(this, "保存文档", "无法保存文档");

  585.         }

  586.     }

  587. }

  588. // 另存为文档

  589. void MainWindow::saveDocumentAs(BaseDocument *doc)

  590. {

  591.     QString filePath = QFileDialog::getSaveFileName(

  592.         this,

  593.         "保存为",

  594.         doc->filePath().isEmpty() ? doc->title() : doc->filePath(),

  595.         doc->type() == BaseDocument::HMI ?"HMI文档 (*.hmi)" :"PLC文档 (*.plc)"

  596.     );

  597. 

  598.     if (filePath.isEmpty()) return;

  599.     if (doc->saveToFile(filePath))

  600.     {

  601.          doc->setModified(false); // 清除修改状态

  602.         QMessageBox::information(this, "保存文档", "文档保存成功");

  603.     }

  604.     else

  605.     {

  606.         QMessageBox::critical(this, "保存文档", "无法保存文档");

  607.     }

  608. }