suyu
/
suyu_two
1
0
Çatalla 0
Kod Konular 0 Değişiklik İstekleri 0 Sürümler 0 Wiki Aktivite
综合平台编程器项目的远程存储
25'ten fazla konu seçemezsiniz Konular bir harf veya rakamla başlamalı, kısa çizgiler ('-') içerebilir ve en fazla 35 karakter uzunluğunda olabilir.
96 İşleme
1 Dal
183 MiB
 
 
 
 
Ağaç: 187a499284
Dallar Biçim İmleri
${ item.name }
${ searchTerm } dalı oluştur
'187a499284'den
${ noResults }
suyu_two/app/src/ui/main_window.cpp

1697 satır
59 KiB
Ham Suçlama Geçmiş 

  1. #include "main_window.h"

  2. 

  3. #include "hmi_editor_widget.h"

  4. #include "alarm_configuration_dialog.h"

  5. #include "register_comment_dialog.h"

  6. #include "logic_editor_widget.h"

  7. #include "logic_instruction_dialog.h"

  8. #include "plc_connection_dialog.h"

  9. #include "runtime_monitor_widget.h"

  10. #include "toolbar_icon_factory.h"

  11. #include "project_workspace_controller.h"

  12. #include "property_panel_controller.h"

  13. #include "runtime_panel_controller.h"

  14. #include "services/hmi_editor_service.h"

  15. #include "services/hmi_navigation_service.h"

  16. #include "services/hmi_runtime_service.h"

  17. #include "services/alarm_editor_service.h"

  18. #include "services/alarm_service.h"

  19. #include "services/logic_editor_service.h"

  20. #include "services/project_service.h"

  21. #include "services/runtime_mode_service.h"

  22. #include "services/register_monitor_service.h"

  23. #include "services/register_comment_service.h"

  24. #include "ui_main_window.h"

  25. 

  26. #include "domain/project_limits.h"

  27. 

  28. #include <QActionGroup>

  29. #include <QAbstractSpinBox>

  30. #include <QApplication>

  31. #include <QCloseEvent>

  32. #include <QEvent>

  33. #include <QFileDialog>

  34. #include <QGraphicsScene>

  35. #include <QInputDialog>

  36. #include <QIcon>

  37. #include <QLabel>

  38. #include <QLineEdit>

  39. #include <QKeyEvent>

  40. #include <QKeySequence>

  41. #include <QMessageBox>

  42. #include <QMenu>

  43. #include <QPlainTextEdit>

  44. #include <QStatusBar>

  45. #include <QTabWidget>

  46. #include <QToolBar>

  47. #include <QToolButton>

  48. #include <QTextEdit>

  49. 

  50. namespace {

  51. 

  52. bool isTextEditingObject(QObject *object)

  53. {

  54.     QWidget *widget = qobject_cast<QWidget *>(object);

  55.     while (widget != nullptr)

  56.     {

  57.         if (qobject_cast<QLineEdit *>(widget) != nullptr

  58.             || qobject_cast<QTextEdit *>(widget) != nullptr

  59.             || qobject_cast<QPlainTextEdit *>(widget) != nullptr

  60.             || qobject_cast<QAbstractSpinBox *>(widget) != nullptr)

  61.         {

  62.             return true;

  63.         }

  64.         widget = widget->parentWidget();

  65.     }

  66.     return false;

  67. }

  68. 

  69. bool isEditorShortcut(const QKeyEvent &event)

  70. {

  71.     return event.matches(QKeySequence::Undo)

  72.         || event.matches(QKeySequence::Redo)

  73.         || (event.modifiers() == Qt::NoModifier

  74.             && (event.key() == Qt::Key_Delete || event.key() == Qt::Key_Escape));

  75. }

  76. 

  77. QString modeText(ApplicationMode mode)

  78. {

  79.     switch (mode)

  80.     {

  81.     case ApplicationMode::Editing:

  82.     {

  83.         return MainWindow::tr("编辑态");

  84.     }

  85.     case ApplicationMode::OfflineRunning:

  86.     {

  87.         return MainWindow::tr("离线运行态");

  88.     }

  89.     case ApplicationMode::OnlineRunning:

  90.     {

  91.         return MainWindow::tr("真机运行态");

  92.     }

  93.     default:

  94.     {

  95.         return MainWindow::tr("未知状态");

  96.     }

  97.     }

  98. }

  99. 

  100. QString transitionErrorText(ModeTransitionError error)

  101. {

  102.     switch (error)

  103.     {

  104.     case ModeTransitionError::MustReturnToEditing:

  105.     {

  106.         return MainWindow::tr("请先返回编辑态，再切换运行模式");

  107.     }

  108.     case ModeTransitionError::InitialPlcReadRequired:

  109.     {

  110.         return MainWindow::tr("真机运行前必须连接 PLC 并完成首次读取");

  111.     }

  112.     case ModeTransitionError::AlreadyInRequestedMode:

  113.     {

  114.         return MainWindow::tr("当前已处于所选模式");

  115.     }

  116.     case ModeTransitionError::ProjectNotReady:

  117.     {

  118.         return MainWindow::tr("工程存在未配置或未完成的 HMI/梯形图节点，暂不能进入离线运行态");

  119.     }

  120.     case ModeTransitionError::SimulationStartFailed:

  121.     {

  122.         return MainWindow::tr("离线逻辑执行器预检或启动失败");

  123.     }

  124.     case ModeTransitionError::None:

  125.     default:

  126.     {

  127.         return MainWindow::tr("模式切换失败");

  128.     }

  129.     }

  130. }

  131. 

  132. std::string toUtf8(const QString &value)

  133. {

  134.     const QByteArray bytes = value.toUtf8();

  135.     return std::string(bytes.constData(), static_cast<std::size_t>(bytes.size()));

  136. }

  137. 

  138. QString fromUtf8(const std::string &value)

  139. {

  140.     return QString::fromUtf8(value.data(), static_cast<int>(value.size()));

  141. }

  142. 

  143. QString plcStatusText(const RuntimeModeService &service)

  144. {

  145.     switch (service.plcConnectionState())

  146.     {

  147.     case PlcConnectionState::Connecting:

  148.         return MainWindow::tr("PLC 正在连接");

  149.     case PlcConnectionState::Connected:

  150.         return service.initialPlcReadCompleted()

  151.             ? MainWindow::tr("PLC 已连接，首次读取完成")

  152.             : MainWindow::tr("PLC 已连接，正在读取工程使用的 M/D 地址");

  153.     case PlcConnectionState::Recovering:

  154.         return MainWindow::tr("PLC 通信已恢复，正在重新读取工程使用的 M/D 地址");

  155.     case PlcConnectionState::Faulted:

  156.     {

  157.         const QString error = fromUtf8(service.plcError());

  158.         return error.isEmpty()

  159.             ? MainWindow::tr("PLC 通信故障")

  160.             : MainWindow::tr("PLC 通信故障：%1").arg(error);

  161.     }

  162.     case PlcConnectionState::Disconnected:

  163.     {

  164.         const QString error = fromUtf8(service.plcError());

  165.         return error.isEmpty()

  166.             ? MainWindow::tr("PLC 已断开")

  167.             : MainWindow::tr("PLC 已断开：%1").arg(error);

  168.     }

  169.     default:

  170.     {

  171.         return MainWindow::tr("PLC 已断开");

  172.     }

  173.     }

  174. }

  175. 

  176. QToolButton *addToolbarMenu(

  177.     QToolBar *toolbar,

  178.     const QString &text,

  179.     const QString &object_name,

  180.     const QIcon &icon,

  181.     const QList<QAction *> &actions)

  182. {

  183.     auto *button = new QToolButton(toolbar);

  184.     button->setObjectName(object_name);

  185.     button->setText(text);

  186.     button->setIcon(icon);

  187.     button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);

  188.     button->setPopupMode(QToolButton::InstantPopup);

  189. 

  190.     auto *menu = new QMenu(button);

  191.     menu->addActions(actions);

  192.     button->setMenu(menu);

  193.     toolbar->addWidget(button);

  194.     return button;

  195. }

  196. 

  197. } // namespace

  198. 

  199. MainWindow::MainWindow(

  200.     RuntimeModeService &runtime_mode_service,

  201.     ProjectService &project_service,

  202.     HmiEditorService &hmi_editor_service,

  203.     LogicEditorService &logic_editor_service,

  204.     HmiRuntimeService &hmi_runtime_service,

  205.     AlarmEditorService &alarm_editor_service,

  206.     AlarmService &alarm_service,

  207.     RegisterCommentService &register_comment_service,

  208.     RegisterMonitorService &register_monitor_service,

  209.     QWidget *parent)

  210.     : QMainWindow(parent),

  211.       ui_(std::make_unique<Ui::MainWindow>()),

  212.       runtime_mode_service_(runtime_mode_service),

  213.       project_service_(project_service),

  214.       hmi_editor_service_(hmi_editor_service),

  215.       logic_editor_service_(logic_editor_service),

  216.       hmi_runtime_service_(hmi_runtime_service),

  217.       alarm_editor_service_(alarm_editor_service),

  218.       alarm_service_(alarm_service),

  219.       register_comment_service_(register_comment_service),

  220.       register_monitor_service_(register_monitor_service),

  221.       owned_hmi_navigation_service_(

  222.           std::make_unique<HmiNavigationService>(project_service)),

  223.       hmi_navigation_service_(owned_hmi_navigation_service_.get())

  224. {

  225.     initializeUi();

  226. }

  227. 

  228. MainWindow::MainWindow(

  229.     RuntimeModeService &runtime_mode_service,

  230.     ProjectService &project_service,

  231.     HmiEditorService &hmi_editor_service,

  232.     LogicEditorService &logic_editor_service,

  233.     HmiRuntimeService &hmi_runtime_service,

  234.     AlarmEditorService &alarm_editor_service,

  235.     AlarmService &alarm_service,

  236.     HmiNavigationService &hmi_navigation_service,

  237.     RegisterCommentService &register_comment_service,

  238.     RegisterMonitorService &register_monitor_service,

  239.     QWidget *parent)

  240.     : QMainWindow(parent),

  241.       ui_(std::make_unique<Ui::MainWindow>()),

  242.       runtime_mode_service_(runtime_mode_service),

  243.       project_service_(project_service),

  244.       hmi_editor_service_(hmi_editor_service),

  245.       logic_editor_service_(logic_editor_service),

  246.       hmi_runtime_service_(hmi_runtime_service),

  247.       alarm_editor_service_(alarm_editor_service),

  248.       alarm_service_(alarm_service),

  249.       register_comment_service_(register_comment_service),

  250.       register_monitor_service_(register_monitor_service),

  251.       hmi_navigation_service_(&hmi_navigation_service)

  252. {

  253.     initializeUi();

  254. }

  255. 

  256. void MainWindow::initializeUi()

  257. {

  258.     ui_->setupUi(this);

  259.     qApp->installEventFilter(this);

  260.     configureAppearance();

  261.     property_panel_controller_ = std::make_unique<PropertyPanelController>(

  262.         *this,

  263.         *ui_,

  264.         project_service_,

  265.         hmi_editor_service_,

  266.         logic_editor_service_,

  267.         [this] { return current_hmi_page_id_; },

  268.         [this] { return current_logic_id_; },

  269.         selected_control_id_,

  270.         selected_logic_node_id_,

  271.         [this] { refreshProjectUi(); },

  272.         [this](const QString &action, const QString &message, bool succeeded)

  273.         {

  274.             showProjectResult(action, message, succeeded);

  275.         },

  276.         [this](const QString &message, int timeout_ms)

  277.         {

  278.             statusBar()->showMessage(message, timeout_ms);

  279.         });

  280.     configureActions();

  281.     configurePropertyEditor();

  282.     configurePlcConnection();

  283.     configureAlarms();

  284.     configureRegisterComments();

  285.     configureHmiEditor();

  286.     configureLogicEditor();

  287.     configureRuntimeMonitor();

  288.     configureProjectTree();

  289.     runtime_mode_service_.setPlcStatusChangedCallback(

  290.         [this] { schedulePlcStatusUpdate(); });

  291.     hmi_editor_service_.ensureDefaultPage();

  292.     logic_editor_service_.ensureDefaultLogic();

  293.     clearEditorHistories();

  294.     current_hmi_page_id_ = hmi_editor_service_.firstPageId();

  295.     current_logic_id_ = logic_editor_service_.firstLogicId();

  296.     showControlProperties({});

  297.     refreshProjectUi();

  298.     updateModeUi(tr("系统已进入编辑态"));

  299. }

  300. 

  301. MainWindow::~MainWindow()

  302. {

  303.     qApp->removeEventFilter(this);

  304.     runtime_mode_service_.setPlcStatusChangedCallback({});

  305. }

  306. 

  307. bool MainWindow::eventFilter(QObject *watched, QEvent *event)

  308. {

  309.     if (event->type() == QEvent::ShortcutOverride

  310.         && isTextEditingObject(watched))

  311.     {

  312.         auto *key_event = static_cast<QKeyEvent *>(event);

  313.         if (isEditorShortcut(*key_event))

  314.         {

  315.             event->accept();

  316.             return true;

  317.         }

  318.     }

  319.     return QMainWindow::eventFilter(watched, event);

  320. }

  321. 

  322. void MainWindow::closeEvent(QCloseEvent *event)

  323. {

  324.     if (!confirmSaveBeforeDestructiveAction())

  325.     {

  326.         event->ignore();

  327.         return;

  328.     }

  329.     if (runtime_panel_controller_ != nullptr)

  330.     {

  331.         runtime_panel_controller_->closeForApplicationExit();

  332.     }

  333.     QMainWindow::closeEvent(event);

  334. }

  335. 

  336. const std::string &MainWindow::currentHmiPageId() const

  337. {

  338.     return current_hmi_page_id_;

  339. }

  340. 

  341. const std::string &MainWindow::currentLogicId() const

  342. {

  343.     return current_logic_id_;

  344. }

  345. 

  346. void MainWindow::configureActions()

  347. {

  348.     mode_action_group_ = new QActionGroup(this);

  349.     mode_action_group_->setExclusive(true);

  350.     mode_action_group_->addAction(ui_->editingModeAction);

  351.     mode_action_group_->addAction(ui_->offlineModeAction);

  352.     mode_action_group_->addAction(ui_->onlineModeAction);

  353. 

  354.     connect(ui_->editingModeAction, &QAction::triggered, this,

  355.             [this] { requestMode(ApplicationMode::Editing); });

  356.     connect(ui_->offlineModeAction, &QAction::triggered, this,

  357.             [this] { requestMode(ApplicationMode::OfflineRunning); });

  358.     connect(ui_->onlineModeAction, &QAction::triggered, this,

  359.             [this] { requestMode(ApplicationMode::OnlineRunning); });

  360.     connect(ui_->exitAction, &QAction::triggered, this, [this] { close(); });

  361.     connect(ui_->newProjectAction, &QAction::triggered, this, &MainWindow::createNewProject);

  362.     connect(ui_->saveProjectAction, &QAction::triggered, this, &MainWindow::saveProject);

  363.     connect(ui_->saveAsProjectAction, &QAction::triggered, this, &MainWindow::saveProjectAs);

  364.     connect(ui_->loadProjectAction, &QAction::triggered, this, &MainWindow::loadProject);

  365.     connect(ui_->undoAction, &QAction::triggered,

  366.             this, &MainWindow::undoActiveEditor);

  367.     connect(ui_->redoAction, &QAction::triggered,

  368.             this, &MainWindow::redoActiveEditor);

  369.     connect(ui_->deleteSelectionAction, &QAction::triggered,

  370.             this, &MainWindow::deleteActiveSelection);

  371.     connect(ui_->clearSelectionAction, &QAction::triggered,

  372.             this, &MainWindow::clearActiveSelection);

  373. 

  374.     connect(ui_->addButtonAction, &QAction::triggered, this,

  375.             [this] { addHmiControl(HmiControlType::Button); });

  376.     connect(ui_->addIndicatorAction, &QAction::triggered, this,

  377.             [this] { addHmiControl(HmiControlType::Indicator); });

  378.     connect(ui_->addNumericDisplayAction, &QAction::triggered, this,

  379.             [this] { addHmiControl(HmiControlType::NumericDisplay); });

  380.     connect(ui_->addNumericInputAction, &QAction::triggered, this,

  381.             [this] { addHmiControl(HmiControlType::NumericInput); });

  382.     connect(ui_->addProgressBarAction, &QAction::triggered, this,

  383.             [this] { addHmiControl(HmiControlType::ProgressBar); });

  384.     connect(ui_->addLabelAction, &QAction::triggered, this,

  385.             [this] { addHmiControl(HmiControlType::Label); });

  386.     connect(ui_->addPageJumpAction, &QAction::triggered, this,

  387.             [this] { addHmiControl(HmiControlType::PageJump); });

  388.     connect(ui_->addAlarmListAction, &QAction::triggered, this,

  389.             [this] { addHmiControl(HmiControlType::AlarmList); });

  390.     connect(ui_->deleteControlAction, &QAction::triggered,

  391.             this, &MainWindow::deleteSelectedControl);

  392.     addToolbarMenu(

  393.         ui_->hmiToolBar,

  394.         tr("更多控件"),

  395.         QStringLiteral("hmiMoreControlsButton"),

  396.         makeUiIcon(UiIcon::More),

  397.         QList<QAction *>{

  398.             ui_->addProgressBarAction,

  399.             ui_->addPageJumpAction,

  400.             ui_->addAlarmListAction,

  401.             ui_->configureAlarmsAction});

  402. 

  403.     connect(ui_->addRungAction, &QAction::triggered,

  404.             this, &MainWindow::addLogicRung);

  405.     connect(ui_->insertHorizontalWireAction, &QAction::triggered,

  406.             this, &MainWindow::addLogicHorizontalWire);

  407.     connect(ui_->insertVerticalWireAction, &QAction::triggered,

  408.             this, &MainWindow::addLogicVerticalWire);

  409.     connect(ui_->deleteHorizontalWireAction, &QAction::triggered,

  410.             this, &MainWindow::deleteLogicHorizontalWire);

  411.     connect(ui_->deleteVerticalWireAction, &QAction::triggered,

  412.             this, &MainWindow::deleteLogicVerticalWire);

  413.     connect(ui_->parallelInsertAction, &QAction::triggered,

  414.             this,

  415.             [this]

  416.             {

  417.                 addLogicParallelBranch(ContactNodeConfig{

  418.                     RegisterAddress{RegisterArea::M, 0},

  419.                     ContactMode::NormallyOpen});

  420.             });

  421.     QMenu *parallel_menu = new QMenu(this);

  422.     QAction *parallel_open = parallel_menu->addAction(tr("并联常开触点"));

  423.     QAction *parallel_closed = parallel_menu->addAction(tr("并联常闭触点"));

  424.     QAction *parallel_rising = parallel_menu->addAction(tr("并联上升沿触点"));

  425.     QAction *parallel_falling = parallel_menu->addAction(tr("并联下降沿触点"));

  426.     QAction *parallel_timer = parallel_menu->addAction(tr("并联 T 触点"));

  427.     QAction *parallel_counter = parallel_menu->addAction(tr("并联 C 触点"));

  428.     QAction *parallel_compare = parallel_menu->addAction(tr("并联比较条件"));

  429.     connect(parallel_open, &QAction::triggered,

  430.             this,

  431.             [this]

  432.             {

  433.                 addLogicParallelBranch(ContactNodeConfig{

  434.                     RegisterAddress{RegisterArea::M, 0},

  435.                     ContactMode::NormallyOpen});

  436.             });

  437.     connect(parallel_closed, &QAction::triggered,

  438.             this,

  439.             [this]

  440.             {

  441.                 addLogicParallelBranch(ContactNodeConfig{

  442.                     RegisterAddress{RegisterArea::M, 0},

  443.                     ContactMode::NormallyClosed});

  444.             });

  445.     connect(parallel_rising, &QAction::triggered,

  446.             this,

  447.             [this]

  448.             {

  449.                 addLogicParallelBranch(EdgeContactNodeConfig{

  450.                     RegisterAddress{RegisterArea::M, 0}, EdgeMode::Rising});

  451.             });

  452.     connect(parallel_falling, &QAction::triggered,

  453.             this,

  454.             [this]

  455.             {

  456.                 addLogicParallelBranch(EdgeContactNodeConfig{

  457.                     RegisterAddress{RegisterArea::M, 0}, EdgeMode::Falling});

  458.             });

  459.     connect(parallel_timer, &QAction::triggered,

  460.             this,

  461.             [this]

  462.             {

  463.                 addLogicParallelBranch(TimerContactNodeConfig{

  464.                     TimerAddress{0}, ContactMode::NormallyOpen});

  465.             });

  466.     connect(parallel_counter, &QAction::triggered,

  467.             this,

  468.             [this]

  469.             {

  470.                 addLogicParallelBranch(CounterContactNodeConfig{

  471.                     CounterAddress{0}, ContactMode::NormallyOpen});

  472.             });

  473.     connect(parallel_compare, &QAction::triggered,

  474.             this,

  475.             [this]

  476.             {

  477.                 addLogicParallelBranch(CompareNodeConfig{

  478.                     RegisterAddress{RegisterArea::D, 0},

  479.                     ComparisonOperator::Equal,

  480.                     0});

  481.             });

  482.     ui_->parallelInsertAction->setMenu(parallel_menu);

  483.     if (QToolButton *parallel_button = qobject_cast<QToolButton *>(

  484.             ui_->logicToolBar->widgetForAction(ui_->parallelInsertAction)))

  485.     {

  486.         parallel_button->setPopupMode(QToolButton::MenuButtonPopup);

  487.     }

  488.     connect(ui_->addNormallyOpenAction, &QAction::triggered,

  489.             this,

  490.             [this]

  491.             {

  492.                 addLogicCondition(ContactNodeConfig{

  493.                     RegisterAddress{RegisterArea::M, 0},

  494.                     ContactMode::NormallyOpen});

  495.             });

  496.     connect(ui_->addNormallyClosedAction, &QAction::triggered,

  497.             this,

  498.             [this]

  499.             {

  500.                 addLogicCondition(ContactNodeConfig{

  501.                     RegisterAddress{RegisterArea::M, 0},

  502.                     ContactMode::NormallyClosed});

  503.             });

  504.     connect(ui_->addRisingEdgeAction, &QAction::triggered,

  505.             this,

  506.             [this]

  507.             {

  508.                 addLogicCondition(EdgeContactNodeConfig{

  509.                     RegisterAddress{RegisterArea::M, 0}, EdgeMode::Rising});

  510.             });

  511.     connect(ui_->addFallingEdgeAction, &QAction::triggered,

  512.             this,

  513.             [this]

  514.             {

  515.                 addLogicCondition(EdgeContactNodeConfig{

  516.                     RegisterAddress{RegisterArea::M, 0}, EdgeMode::Falling});

  517.             });

  518.     connect(ui_->addTimerContactAction, &QAction::triggered,

  519.             this,

  520.             [this]

  521.             {

  522.                 addLogicCondition(TimerContactNodeConfig{

  523.                     TimerAddress{0}, ContactMode::NormallyOpen});

  524.             });

  525.     connect(ui_->addCounterContactAction, &QAction::triggered,

  526.             this,

  527.             [this]

  528.             {

  529.                 addLogicCondition(CounterContactNodeConfig{

  530.                     CounterAddress{0}, ContactMode::NormallyOpen});

  531.             });

  532.     connect(ui_->addNormalCoilAction, &QAction::triggered,

  533.             this,

  534.             [this]

  535.             {

  536.                 setLogicOutput(CoilNodeConfig{

  537.                     RegisterAddress{RegisterArea::M, 0},

  538.                     CoilMode::Normal});

  539.             });

  540.     connect(ui_->addSetCoilAction, &QAction::triggered,

  541.             this,

  542.             [this]

  543.             {

  544.                 setLogicOutput(CoilNodeConfig{

  545.                     RegisterAddress{RegisterArea::M, 0},

  546.                     CoilMode::Set});

  547.             });

  548.     connect(ui_->addResetCoilAction, &QAction::triggered,

  549.             this,

  550.             [this]

  551.             {

  552.                 setLogicOutput(CoilNodeConfig{

  553.                     RegisterAddress{RegisterArea::M, 0},

  554.                     CoilMode::Reset});

  555.             });

  556.     connect(ui_->addTonAction, &QAction::triggered,

  557.             this,

  558.             [this]

  559.             {

  560.                 setLogicOutput(TonNodeConfig{TimerAddress{0}, 1000});

  561.             });

  562.     connect(ui_->addCtuAction, &QAction::triggered,

  563.             this,

  564.             [this]

  565.             {

  566.                 configureAndSetLogicOutput(CounterNodeConfig{

  567.                     CounterAddress{0},

  568.                     CounterMode::Up,

  569.                     RegisterAddress{RegisterArea::D, 0},

  570.                     WordOperand{

  571.                         WordOperandKind::Constant,

  572.                         RegisterAddress{RegisterArea::D, 0},

  573.                         10},

  574.                     RegisterAddress{RegisterArea::M, 0}});

  575.             });

  576.     connect(ui_->addCtdAction, &QAction::triggered,

  577.             this,

  578.             [this]

  579.             {

  580.                 configureAndSetLogicOutput(CounterNodeConfig{

  581.                     CounterAddress{0},

  582.                     CounterMode::Down,

  583.                     RegisterAddress{RegisterArea::D, 0},

  584.                     WordOperand{

  585.                         WordOperandKind::Constant,

  586.                         RegisterAddress{RegisterArea::D, 0},

  587.                         10},

  588.                     RegisterAddress{RegisterArea::M, 0}});

  589.             });

  590.     connect(ui_->addMoveAction, &QAction::triggered,

  591.             this,

  592.             [this]

  593.             {

  594.                 configureAndSetLogicOutput(MoveNodeConfig{

  595.                     WordOperand{

  596.                         WordOperandKind::Constant,

  597.                         RegisterAddress{RegisterArea::D, 0},

  598.                         0},

  599.                     RegisterAddress{RegisterArea::D, 0}});

  600.             });

  601.     connect(ui_->addAddAction, &QAction::triggered,

  602.             this,

  603.             [this]

  604.             {

  605.                 configureAndSetLogicOutput(ArithmeticNodeConfig{

  606.                     ArithmeticOperation::Add,

  607.                     WordOperand{

  608.                         WordOperandKind::Register,

  609.                         RegisterAddress{RegisterArea::D, 0},

  610.                         0},

  611.                     WordOperand{

  612.                         WordOperandKind::Constant,

  613.                         RegisterAddress{RegisterArea::D, 0},

  614.                         1},

  615.                     RegisterAddress{RegisterArea::D, 0}});

  616.             });

  617.     connect(ui_->addSubAction, &QAction::triggered,

  618.             this,

  619.             [this]

  620.             {

  621.                 configureAndSetLogicOutput(ArithmeticNodeConfig{

  622.                     ArithmeticOperation::Subtract,

  623.                     WordOperand{

  624.                         WordOperandKind::Register,

  625.                         RegisterAddress{RegisterArea::D, 0},

  626.                         0},

  627.                     WordOperand{

  628.                         WordOperandKind::Constant,

  629.                         RegisterAddress{RegisterArea::D, 0},

  630.                         1},

  631.                     RegisterAddress{RegisterArea::D, 0}});

  632.             });

  633.     connect(ui_->addCompareAction, &QAction::triggered,

  634.             this,

  635.             [this]

  636.             {

  637.                 addLogicCondition(CompareNodeConfig{

  638.                     RegisterAddress{RegisterArea::D, 0},

  639.                     ComparisonOperator::Equal,

  640.                     0});

  641.             });

  642.     connect(ui_->deleteLogicAction, &QAction::triggered,

  643.             this, &MainWindow::deleteSelectedLogicObject);

  644.     connect(ui_->editRungCommentAction, &QAction::triggered,

  645.             this, &MainWindow::editSelectedRungComment);

  646.     addToolbarMenu(

  647.         ui_->logicToolBar,

  648.         tr("更多触点"),

  649.         QStringLiteral("logicContactMenuButton"),

  650.         makeUiIcon(UiIcon::NormallyOpenContact),

  651.         QList<QAction *>{

  652.             ui_->addRisingEdgeAction,

  653.             ui_->addFallingEdgeAction,

  654.             ui_->addTimerContactAction,

  655.             ui_->addCounterContactAction});

  656.     addToolbarMenu(

  657.         ui_->logicToolBar,

  658.         tr("更多输出"),

  659.         QStringLiteral("logicOutputMenuButton"),

  660.         makeUiIcon(UiIcon::Coil),

  661.         QList<QAction *>{ui_->addSetCoilAction, ui_->addResetCoilAction});

  662.     addToolbarMenu(

  663.         ui_->logicToolBar,

  664.         tr("定时/计数"),

  665.         QStringLiteral("logicTimerCounterMenuButton"),

  666.         makeUiIcon(UiIcon::Ton),

  667.         QList<QAction *>{ui_->addTonAction, ui_->addCtuAction, ui_->addCtdAction});

  668.     addToolbarMenu(

  669.         ui_->logicToolBar,

  670.         tr("数据运算"),

  671.         QStringLiteral("logicDataMenuButton"),

  672.         makeUiIcon(UiIcon::Move),

  673.         QList<QAction *>{

  674.             ui_->addMoveAction,

  675.             ui_->addAddAction,

  676.             ui_->addSubAction,

  677.             ui_->addCompareAction});

  678. 

  679.     connect(ui_->editorTabWidget, &QTabWidget::currentChanged,

  680.             this,

  681.             [this](int index)

  682.             {

  683.                 ui_->hmiToolBar->setVisible(index == 0);

  684.                 ui_->logicToolBar->setVisible(index == 1);

  685.                 if (index == 0)

  686.                 {

  687.                     showControlProperties(selected_control_id_);

  688.                 }

  689.                 else if (index == 1)

  690.                 {

  691.                     showLogicNodeProperties(selected_logic_node_id_);

  692.                 }

  693.                 if (index == 0 || index == 1)

  694.                 {

  695.                     refreshProjectUi();

  696.                 }

  697.             });

  698.     ui_->hmiToolBar->setVisible(ui_->editorTabWidget->currentIndex() == 0);

  699.     ui_->logicToolBar->setVisible(ui_->editorTabWidget->currentIndex() == 1);

  700. 

  701.     ui_->viewMenu->addAction(ui_->projectDock->toggleViewAction());

  702.     ui_->viewMenu->addAction(ui_->propertiesDock->toggleViewAction());

  703.     ui_->viewMenu->addAction(ui_->outputDock->toggleViewAction());

  704.     ui_->viewMenu->addAction(ui_->hmiToolBar->toggleViewAction());

  705.     ui_->viewMenu->addAction(ui_->logicToolBar->toggleViewAction());

  706.     ui_->viewMenu->addSeparator();

  707.     ui_->viewMenu->addAction(ui_->modeToolBar->toggleViewAction());

  708. }

  709. 

  710. void MainWindow::configureAppearance()

  711. {

  712.     setDockNestingEnabled(true);

  713.     setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);

  714.     setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);

  715. 

  716.     ui_->editingModeAction->setIcon(makeUiIcon(UiIcon::Edit));

  717.     ui_->offlineModeAction->setIcon(makeUiIcon(UiIcon::RunOffline));

  718.     ui_->onlineModeAction->setIcon(makeUiIcon(UiIcon::RunOnline));

  719.     ui_->newProjectAction->setIcon(makeUiIcon(UiIcon::NewDocument));

  720.     ui_->saveProjectAction->setIcon(makeUiIcon(UiIcon::Save));

  721.     ui_->saveAsProjectAction->setIcon(makeUiIcon(UiIcon::SaveAs));

  722.     ui_->loadProjectAction->setIcon(makeUiIcon(UiIcon::Open));

  723.     ui_->undoAction->setIcon(makeUiIcon(UiIcon::Undo));

  724.     ui_->redoAction->setIcon(makeUiIcon(UiIcon::Redo));

  725.     ui_->deleteSelectionAction->setIcon(makeUiIcon(UiIcon::Delete));

  726.     ui_->clearSelectionAction->setIcon(makeUiIcon(UiIcon::ClearList));

  727.     ui_->exitAction->setIcon(makeUiIcon(UiIcon::Exit));

  728.     ui_->configurePlcAction->setIcon(makeUiIcon(UiIcon::PlcSettings));

  729.     ui_->disconnectPlcAction->setIcon(makeUiIcon(UiIcon::Disconnect));

  730.     ui_->configureRegisterCommentsAction->setIcon(

  731.         makeUiIcon(UiIcon::RegisterComments));

  732.     ui_->addButtonAction->setIcon(makeUiIcon(UiIcon::HmiButton));

  733.     ui_->addIndicatorAction->setIcon(makeUiIcon(UiIcon::Indicator));

  734.     ui_->addNumericDisplayAction->setIcon(makeUiIcon(UiIcon::NumericDisplay));

  735.     ui_->addNumericInputAction->setIcon(makeUiIcon(UiIcon::NumericInput));

  736.     ui_->addProgressBarAction->setIcon(makeUiIcon(UiIcon::ProgressBar));

  737.     ui_->addLabelAction->setIcon(makeUiIcon(UiIcon::Text));

  738.     ui_->addPageJumpAction->setIcon(makeUiIcon(UiIcon::PageJump));

  739.     ui_->addAlarmListAction->setIcon(makeUiIcon(UiIcon::AlarmList));

  740.     ui_->configureAlarmsAction->setIcon(makeUiIcon(UiIcon::AlarmSettings));

  741.     ui_->deleteControlAction->setIcon(makeUiIcon(UiIcon::Delete));

  742.     ui_->addRungAction->setIcon(makeUiIcon(UiIcon::AddRung));

  743.     ui_->parallelInsertAction->setIcon(makeUiIcon(UiIcon::ParallelBranch));

  744.     ui_->insertHorizontalWireAction->setIcon(makeUiIcon(UiIcon::HorizontalWire));

  745.     ui_->insertVerticalWireAction->setIcon(makeUiIcon(UiIcon::VerticalWire));

  746.     ui_->deleteHorizontalWireAction->setIcon(makeUiIcon(UiIcon::Delete));

  747.     ui_->deleteVerticalWireAction->setIcon(makeUiIcon(UiIcon::Delete));

  748.     ui_->addNormallyOpenAction->setIcon(makeUiIcon(UiIcon::NormallyOpenContact));

  749.     ui_->addNormallyClosedAction->setIcon(makeUiIcon(UiIcon::NormallyClosedContact));

  750.     ui_->addRisingEdgeAction->setIcon(makeUiIcon(UiIcon::RisingEdgeContact));

  751.     ui_->addFallingEdgeAction->setIcon(makeUiIcon(UiIcon::FallingEdgeContact));

  752.     ui_->addTimerContactAction->setIcon(makeUiIcon(UiIcon::TimerContact));

  753.     ui_->addCounterContactAction->setIcon(makeUiIcon(UiIcon::CounterContact));

  754.     ui_->addNormalCoilAction->setIcon(makeUiIcon(UiIcon::Coil));

  755.     ui_->addSetCoilAction->setIcon(makeUiIcon(UiIcon::SetCoil));

  756.     ui_->addResetCoilAction->setIcon(makeUiIcon(UiIcon::ResetCoil));

  757.     ui_->addTonAction->setIcon(makeUiIcon(UiIcon::Ton));

  758.     ui_->addCtuAction->setIcon(makeUiIcon(UiIcon::Ctu));

  759.     ui_->addCtdAction->setIcon(makeUiIcon(UiIcon::Ctd));

  760.     ui_->addMoveAction->setIcon(makeUiIcon(UiIcon::Move));

  761.     ui_->addAddAction->setIcon(makeUiIcon(UiIcon::Add));

  762.     ui_->addSubAction->setIcon(makeUiIcon(UiIcon::Subtract));

  763.     ui_->addCompareAction->setIcon(makeUiIcon(UiIcon::Compare));

  764.     ui_->editRungCommentAction->setIcon(makeUiIcon(UiIcon::Comment));

  765.     ui_->deleteLogicAction->setIcon(makeUiIcon(UiIcon::Delete));

  766.     ui_->editorTabWidget->setTabIcon(0, makeUiIcon(UiIcon::HmiPage));

  767.     ui_->editorTabWidget->setTabIcon(1, makeUiIcon(UiIcon::Logic));

  768.     ui_->outputDock->setMaximumHeight(220);

  769. 

  770.     mode_status_label_ = new QLabel(this);

  771.     mode_status_label_->setObjectName(QStringLiteral("modeStatusLabel"));

  772.     mode_status_label_->setMinimumWidth(88);

  773.     mode_status_label_->setAlignment(Qt::AlignCenter);

  774.     register_status_label_ = new QLabel(this);

  775.     register_status_label_->setObjectName(QStringLiteral("registerStatusLabel"));

  776.     register_status_label_->setMinimumWidth(132);

  777.     executor_status_label_ = new QLabel(this);

  778.     executor_status_label_->setObjectName(QStringLiteral("executorStatusLabel"));

  779.     executor_status_label_->setMinimumWidth(132);

  780.     statusBar()->addPermanentWidget(mode_status_label_);

  781.     statusBar()->addPermanentWidget(register_status_label_);

  782.     statusBar()->addPermanentWidget(executor_status_label_);

  783. 

  784.     setStyleSheet(QStringLiteral(

  785.         "QMainWindow { background: #f3f5f7; }"

  786.         "QToolBar { background: #ffffff; border: 0; border-bottom: 1px solid #cbd2d9;"

  787.         " padding: 4px; spacing: 3px; }"

  788.         "QToolButton { min-height: 26px; padding: 3px 9px; border: 1px solid transparent; }"

  789.         "QToolButton:hover { background: #edf2f6; border-color: #c5ced6; }"

  790.         "QToolButton:checked { background: #dcece3; border-color: #75a58a; }"

  791.         "QDockWidget { color: #24313b; font-weight: 600; }"

  792.         "QDockWidget::title { background: #e9edf0; padding: 6px;"

  793.         " border-bottom: 1px solid #cbd2d9; }"

  794.         "QTreeWidget, QListWidget, QScrollArea { background: #ffffff; border: 1px solid #d5dbe0; }"

  795.         "QTabWidget::pane { border: 0; background: #f3f5f7; }"

  796.         "QTabBar::tab { background: #e5e9ec; padding: 7px 14px; border-right: 1px solid #cbd2d9; }"

  797.         "QTabBar::tab:selected { background: #ffffff; color: #15232d; }"

  798.         "QFrame#hmiCanvasPlaceholder, QFrame#logicCanvasPlaceholder { background: #ffffff;"

  799.         " border: 1px solid #cbd2d9; }"

  800.         "QLabel#hmiEmptyLabel, QLabel#logicEmptyLabel { color: #75838d; }"

  801.         "QLabel#hmiPageTitleLabel { color: #1d2a33; font-weight: 600; }"

  802.         "QLabel#hmiPageSizeLabel { color: #66747e; }"));

  803. }

  804. 

  805. void MainWindow::configureHmiEditor()

  806. {

  807.     QLayout *layout = ui_->hmiCanvasPlaceholder->layout();

  808.     delete ui_->hmiEmptyLabel;

  809.     hmi_editor_widget_ = new HmiEditorWidget(

  810.         hmi_editor_service_,

  811.         hmi_runtime_service_,

  812.         alarm_service_,

  813.         ui_->hmiCanvasPlaceholder);

  814.     hmi_editor_widget_->setMinimumHeight(320);

  815.     layout->addWidget(hmi_editor_widget_);

  816. }

  817. 

  818. void MainWindow::configureLogicEditor()

  819. {

  820.     QLayout *layout = ui_->logicCanvasPlaceholder->layout();

  821.     delete ui_->logicEmptyLabel;

  822.     logic_editor_widget_ = new LogicEditorWidget(

  823.         logic_editor_service_, ui_->logicCanvasPlaceholder);

  824.     logic_editor_widget_->setObjectName(QStringLiteral("logicEditorWidget"));

  825.     logic_editor_widget_->setMinimumHeight(320);

  826.     layout->addWidget(logic_editor_widget_);

  827.     property_panel_controller_->bindEditorWidgets(

  828.         *hmi_editor_widget_, *logic_editor_widget_);

  829. }

  830. 

  831. void MainWindow::configureRuntimeMonitor()

  832. {

  833.     runtime_panel_controller_ = std::make_unique<RuntimePanelController>(

  834.         *this,

  835.         runtime_mode_service_,

  836.         project_service_,

  837.         hmi_editor_service_,

  838.         hmi_runtime_service_,

  839.         logic_editor_service_,

  840.         *hmi_navigation_service_,

  841.         alarm_service_,

  842.         register_monitor_service_,

  843.         *hmi_editor_widget_,

  844.         *logic_editor_widget_,

  845.         *executor_status_label_,

  846.         [this] { return current_logic_id_; },

  847.         [this](const std::string &logic_id) { current_logic_id_ = logic_id; },

  848.         [this](const std::string &node_id)

  849.         {

  850.             showLogicNodeProperties(node_id);

  851.         },

  852.         [this](const QString &message, int timeout_ms)

  853.         {

  854.             statusBar()->showMessage(message, timeout_ms);

  855.         },

  856.         [this](const QString &message)

  857.         {

  858.             appendOutputMessage(message);

  859.         },

  860.         [this]

  861.         {

  862.             requestMode(ApplicationMode::Editing);

  863.         });

  864.     runtime_panel_controller_->configure();

  865.     runtime_monitor_widget_ = runtime_panel_controller_->runtimeMonitorWidget();

  866. }

  867. 

  868. void MainWindow::configureProjectTree()

  869. {

  870.     project_workspace_controller_ = std::make_unique<ProjectWorkspaceController>(

  871.         *this,

  872.         *ui_,

  873.         project_service_,

  874.         hmi_editor_service_,

  875.         logic_editor_service_,

  876.         runtime_mode_service_,

  877.         *hmi_navigation_service_,

  878.         *hmi_editor_widget_,

  879.         *logic_editor_widget_,

  880.         *runtime_monitor_widget_,

  881.         current_hmi_page_id_,

  882.         current_logic_id_,

  883.         [this](const std::string &control_id)

  884.         {

  885.             showControlProperties(control_id);

  886.         },

  887.         [this](const std::string &node_id)

  888.         {

  889.             showLogicNodeProperties(node_id);

  890.         },

  891.         [this](const QString &action, const QString &message, bool succeeded)

  892.         {

  893.             showProjectResult(action, message, succeeded);

  894.         },

  895.         [this](const QString &message, int timeout_ms)

  896.         {

  897.             statusBar()->showMessage(message, timeout_ms);

  898.         },

  899.         [this]

  900.         {

  901.             updateEditActions();

  902.         });

  903.     project_workspace_controller_->configure();

  904. }

  905. 

  906. void MainWindow::configurePropertyEditor()

  907. {

  908.     property_panel_controller_->configure();

  909. }

  910. 

  911. void MainWindow::configurePlcConnection()

  912. {

  913.     connect(ui_->configurePlcAction, &QAction::triggered, this, &MainWindow::connectPlc);

  914.     connect(ui_->disconnectPlcAction, &QAction::triggered, this, &MainWindow::disconnectPlc);

  915. }

  916. 

  917. void MainWindow::configureAlarms()

  918. {

  919.     connect(ui_->configureAlarmsAction, &QAction::triggered,

  920.             this,

  921.             [this]

  922.             {

  923.                 AlarmConfigurationDialog dialog(alarm_editor_service_, this);

  924.                 dialog.exec();

  925.                 refreshProjectUi();

  926.     });

  927. }

  928. 

  929. void MainWindow::configureRegisterComments()

  930. {

  931.     connect(

  932.         ui_->configureRegisterCommentsAction,

  933.         &QAction::triggered,

  934.         this,

  935.         [this]

  936.         {

  937.             RegisterCommentDialog dialog(register_comment_service_, this);

  938.             dialog.exec();

  939.             logic_editor_widget_->reloadLogic();

  940.             refreshProjectUi();

  941.         });

  942. }

  943. 

  944. void MainWindow::undoActiveEditor()

  945. {

  946.     if (!runtime_mode_service_.policy().allowsProjectEditing)

  947.     {

  948.         return;

  949.     }

  950.     if (ui_->editorTabWidget->currentWidget() == ui_->hmiEditorTab)

  951.     {

  952.         if (!hmi_editor_service_.undo().succeeded)

  953.         {

  954.             return;

  955.         }

  956.         selected_control_id_.clear();

  957.         showControlProperties({});

  958.         refreshProjectUi();

  959.         hmi_editor_widget_->reloadPage();

  960.         statusBar()->showMessage(tr("已撤销 HMI 编辑操作"), 3000);

  961.     }

  962.     else if (ui_->editorTabWidget->currentWidget() == ui_->logicEditorTab)

  963.     {

  964.         if (!logic_editor_service_.undo().succeeded)

  965.         {

  966.             return;

  967.         }

  968.         selected_logic_node_id_.clear();

  969.         showLogicNodeProperties({});

  970.         refreshProjectUi();

  971.         logic_editor_widget_->reloadLogic();

  972.         statusBar()->showMessage(tr("已撤销梯形图编辑操作"), 3000);

  973.     }

  974.     updateEditActions();

  975. }

  976. 

  977. void MainWindow::redoActiveEditor()

  978. {

  979.     if (!runtime_mode_service_.policy().allowsProjectEditing)

  980.     {

  981.         return;

  982.     }

  983.     if (ui_->editorTabWidget->currentWidget() == ui_->hmiEditorTab)

  984.     {

  985.         if (!hmi_editor_service_.redo().succeeded)

  986.         {

  987.             return;

  988.         }

  989.         selected_control_id_.clear();

  990.         showControlProperties({});

  991.         refreshProjectUi();

  992.         hmi_editor_widget_->reloadPage();

  993.         statusBar()->showMessage(tr("已重做 HMI 编辑操作"), 3000);

  994.     }

  995.     else if (ui_->editorTabWidget->currentWidget() == ui_->logicEditorTab)

  996.     {

  997.         if (!logic_editor_service_.redo().succeeded)

  998.         {

  999.             return;

  1000.         }

  1001.         selected_logic_node_id_.clear();

  1002.         showLogicNodeProperties({});

  1003.         refreshProjectUi();

  1004.         logic_editor_widget_->reloadLogic();

  1005.         statusBar()->showMessage(tr("已重做梯形图编辑操作"), 3000);

  1006.     }

  1007.     updateEditActions();

  1008. }

  1009. 

  1010. void MainWindow::deleteActiveSelection()

  1011. {

  1012.     if (ui_->editorTabWidget->currentWidget() == ui_->hmiEditorTab)

  1013.     {

  1014.         deleteSelectedControl();

  1015.     }

  1016.     else if (ui_->editorTabWidget->currentWidget() == ui_->logicEditorTab)

  1017.     {

  1018.         deleteSelectedLogicObject();

  1019.     }

  1020. }

  1021. 

  1022. void MainWindow::clearActiveSelection()

  1023. {

  1024.     if (ui_->editorTabWidget->currentWidget() == ui_->hmiEditorTab)

  1025.     {

  1026.         hmi_editor_widget_->scene()->clearSelection();

  1027.         selected_control_id_.clear();

  1028.         showControlProperties({});

  1029.     }

  1030.     else if (ui_->editorTabWidget->currentWidget() == ui_->logicEditorTab)

  1031.     {

  1032.         logic_editor_widget_->scene()->clearSelection();

  1033.         selected_logic_node_id_.clear();

  1034.         showLogicNodeProperties({});

  1035.     }

  1036. }

  1037. 

  1038. void MainWindow::updateEditActions()

  1039. {

  1040.     const bool editable = runtime_mode_service_.policy().allowsProjectEditing;

  1041.     const bool hmi_active = ui_->editorTabWidget->currentWidget() == ui_->hmiEditorTab;

  1042.     const bool logic_active =

  1043.         ui_->editorTabWidget->currentWidget() == ui_->logicEditorTab;

  1044.     ui_->undoAction->setEnabled(

  1045.         editable && ((hmi_active && hmi_editor_service_.canUndo())

  1046.                      || (logic_active && logic_editor_service_.canUndo())));

  1047.     ui_->redoAction->setEnabled(

  1048.         editable && ((hmi_active && hmi_editor_service_.canRedo())

  1049.                      || (logic_active && logic_editor_service_.canRedo())));

  1050.     ui_->deleteSelectionAction->setEnabled(editable && (hmi_active || logic_active));

  1051.     ui_->clearSelectionAction->setEnabled(editable && (hmi_active || logic_active));

  1052.     ui_->insertHorizontalWireAction->setEnabled(editable && logic_active);

  1053.     ui_->insertVerticalWireAction->setEnabled(editable && logic_active);

  1054.     ui_->deleteHorizontalWireAction->setEnabled(editable && logic_active);

  1055.     ui_->deleteVerticalWireAction->setEnabled(editable && logic_active);

  1056. }

  1057. 

  1058. void MainWindow::clearEditorHistories()

  1059. {

  1060.     hmi_editor_service_.clearHistory();

  1061.     logic_editor_service_.clearHistory();

  1062.     if (ui_->undoAction != nullptr)

  1063.     {

  1064.         updateEditActions();

  1065.     }

  1066. }

  1067. 

  1068. void MainWindow::refreshProjectUi()

  1069. {

  1070.     project_workspace_controller_->refresh();

  1071.     updateEditActions();

  1072.     updateWindowTitle();

  1073. }

  1074. 

  1075. void MainWindow::updateWindowTitle()

  1076. {

  1077.     QString title = tr("综合平台编程器");

  1078.     if (project_service_.isModified())

  1079.     {

  1080.         title += QStringLiteral("*");

  1081.     }

  1082.     setWindowTitle(title);

  1083. }

  1084. 

  1085. bool MainWindow::confirmSaveBeforeDestructiveAction()

  1086. {

  1087.     if (!project_service_.isModified())

  1088.     {

  1089.         return true;

  1090.     }

  1091. 

  1092.     const QString project_name = fromUtf8(project_service_.project().metadata.name);

  1093.     const QMessageBox::StandardButton choice = QMessageBox::warning(

  1094.         this,

  1095.         tr("工程尚未保存"),

  1096.         tr("工程“%1”有未保存的修改，是否先保存？").arg(project_name),

  1097.         QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel,

  1098.         QMessageBox::Save);

  1099.     if (choice == QMessageBox::Cancel)

  1100.     {

  1101.         return false;

  1102.     }

  1103.     if (choice == QMessageBox::Discard)

  1104.     {

  1105.         return true;

  1106.     }

  1107. 

  1108.     saveProject();

  1109.     return !project_service_.isModified();

  1110. }

  1111. 

  1112. void MainWindow::updateProjectTreeActions()

  1113. {

  1114.     project_workspace_controller_->updateActions();

  1115. }

  1116. 

  1117. void MainWindow::connectPlc()

  1118. {

  1119.     PlcConnectionDialog dialog(plc_configuration_, this);

  1120.     if (dialog.exec() != QDialog::Accepted)

  1121.     {

  1122.         return;

  1123.     }

  1124.     plc_configuration_ = dialog.configuration();

  1125.     if (plc_configuration_.portName.empty())

  1126.     {

  1127.         showProjectResult(tr("连接 PLC"), tr("请选择或输入串口端口"), false);

  1128.         return;

  1129.     }

  1130.     const PlcCommunicationResult result = runtime_mode_service_.connectPlc(

  1131.         plc_configuration_);

  1132.     if (!result.succeeded)

  1133.     {

  1134.         const QString message = fromUtf8(result.message);

  1135.         if (result.message == runtime_mode_service_.plcError())

  1136.         {

  1137.             statusBar()->showMessage(message, 5000);

  1138.             QMessageBox::warning(this, tr("连接 PLC"), message);

  1139.         }

  1140.         else

  1141.         {

  1142.             showProjectResult(tr("连接 PLC"), message, false);

  1143.         }

  1144.         return;

  1145.     }

  1146.     statusBar()->showMessage(tr("PLC 正在连接，等待首次 M/D 读取"), 5000);

  1147. }

  1148. 

  1149. void MainWindow::disconnectPlc()

  1150. {

  1151.     runtime_mode_service_.disconnectPlc();

  1152. }

  1153. 

  1154. void MainWindow::schedulePlcStatusUpdate()

  1155. {

  1156.     if (plc_status_update_pending_)

  1157.     {

  1158.         return;

  1159.     }

  1160.     plc_status_update_pending_ = true;

  1161.     QMetaObject::invokeMethod(

  1162.         this,

  1163.         [this]

  1164.         {

  1165.             plc_status_update_pending_ = false;

  1166.             updateModeUi(plcStatusText(runtime_mode_service_));

  1167.         },

  1168.         Qt::QueuedConnection);

  1169. }

  1170. 

  1171. // 根据控件ID加载控件属性到右侧属性面板

  1172. void MainWindow::showControlProperties(const std::string &control_id)

  1173. {

  1174.     property_panel_controller_->showControlProperties(control_id);

  1175. }

  1176. 

  1177. void MainWindow::showLogicNodeProperties(const std::string &node_id)

  1178. {

  1179.     property_panel_controller_->showLogicNodeProperties(node_id);

  1180. }

  1181. 

  1182. void MainWindow::addHmiControl(HmiControlType type)

  1183. {

  1184.     property_panel_controller_->addHmiControl(type);

  1185. }

  1186. 

  1187. void MainWindow::deleteSelectedControl()

  1188. {

  1189.     property_panel_controller_->deleteSelectedControl();

  1190. }

  1191. 

  1192. void MainWindow::addLogicCondition(const LogicNodeConfig &config)

  1193. {

  1194.     const LogicEditorResult result = logic_editor_widget_->addCondition(config);

  1195.     if (!result.succeeded)

  1196.     {

  1197.         showProjectResult(tr("添加逻辑条件"), fromUtf8(result.message), false);

  1198.         return;

  1199.     }

  1200.     selected_logic_node_id_ = result.id;

  1201.     showLogicNodeProperties(result.id);

  1202.     refreshProjectUi();

  1203.     statusBar()->showMessage(tr("已添加逻辑条件"), 3000);

  1204. }

  1205. 

  1206. void MainWindow::addLogicParallelBranch(const LogicNodeConfig &config)

  1207. {

  1208.     const LogicEditorResult result = logic_editor_widget_->addParallelBranch(config);

  1209.     if (!result.succeeded)

  1210.     {

  1211.         showProjectResult(tr("建立并联支路"), fromUtf8(result.message), false);

  1212.         return;

  1213.     }

  1214.     selected_logic_node_id_ = result.id;

  1215.     showLogicNodeProperties(result.id);

  1216.     refreshProjectUi();

  1217.     statusBar()->showMessage(tr("已建立并联支路，请配置新触点"), 3000);

  1218. }

  1219. 

  1220. void MainWindow::addLogicHorizontalWire()

  1221. {

  1222.     const LogicEditorResult result = logic_editor_widget_->addHorizontalWire();

  1223.     if (!result.succeeded)

  1224.     {

  1225.         showProjectResult(tr("插入横线"), fromUtf8(result.message), false);

  1226.         return;

  1227.     }

  1228.     selected_logic_node_id_.clear();

  1229.     showLogicNodeProperties({});

  1230.     refreshProjectUi();

  1231.     statusBar()->showMessage(tr("横线已插入，可直接用触点替换"), 3000);

  1232. }

  1233. 

  1234. void MainWindow::addLogicVerticalWire()

  1235. {

  1236.     const LogicEditorResult result = logic_editor_widget_->addVerticalWire();

  1237.     if (!result.succeeded)

  1238.     {

  1239.         showProjectResult(tr("插入竖线"), fromUtf8(result.message), false);

  1240.         return;

  1241.     }

  1242.     selected_logic_node_id_.clear();

  1243.     showLogicNodeProperties({});

  1244.     refreshProjectUi();

  1245.     statusBar()->showMessage(tr("已建立横线旁路和竖线连接"), 3000);

  1246. }

  1247. 

  1248. void MainWindow::deleteLogicHorizontalWire()

  1249. {

  1250.     const LogicEditorResult result = logic_editor_widget_->deleteHorizontalWire();

  1251.     if (!result.succeeded)

  1252.     {

  1253.         showProjectResult(tr("删除横线"), fromUtf8(result.message), false);

  1254.         return;

  1255.     }

  1256.     selected_logic_node_id_.clear();

  1257.     showLogicNodeProperties({});

  1258.     refreshProjectUi();

  1259.     statusBar()->showMessage(tr("横线已删除"), 3000);

  1260. }

  1261. 

  1262. void MainWindow::deleteLogicVerticalWire()

  1263. {

  1264.     const LogicEditorResult result = logic_editor_widget_->deleteVerticalWire();

  1265.     if (!result.succeeded)

  1266.     {

  1267.         showProjectResult(tr("删除竖线"), fromUtf8(result.message), false);

  1268.         return;

  1269.     }

  1270.     selected_logic_node_id_.clear();

  1271.     showLogicNodeProperties({});

  1272.     refreshProjectUi();

  1273.     statusBar()->showMessage(tr("竖线及对应并联支路已删除"), 3000);

  1274. }

  1275. 

  1276. void MainWindow::setLogicOutput(const LogicNodeConfig &config)

  1277. {

  1278.     const LogicEditorResult result = logic_editor_widget_->setOutput(config);

  1279.     if (!result.succeeded)

  1280.     {

  1281.         showProjectResult(tr("设置逻辑输出"), fromUtf8(result.message), false);

  1282.         return;

  1283.     }

  1284.     selected_logic_node_id_ = result.id;

  1285.     showLogicNodeProperties(result.id);

  1286.     refreshProjectUi();

  1287.     statusBar()->showMessage(tr("逻辑输出已设置"), 3000);

  1288. }

  1289. 

  1290. void MainWindow::configureAndSetLogicOutput(const LogicNodeConfig &config)

  1291. {

  1292.     LogicInstructionDialog dialog(config, this);

  1293.     if (dialog.exec() != QDialog::Accepted)

  1294.     {

  1295.         return;

  1296.     }

  1297.     const LogicNodeConfig configured = dialog.config();

  1298.     LogicEditorResult result = logic_editor_widget_->setOutput(configured, true);

  1299.     if (!result.succeeded)

  1300.     {

  1301.         showProjectResult(tr("设置逻辑输出"), fromUtf8(result.message), false);

  1302.         return;

  1303.     }

  1304.     const std::string node_id = result.id;

  1305.     selected_logic_node_id_ = node_id;

  1306.     showLogicNodeProperties(node_id);

  1307.     refreshProjectUi();

  1308.     statusBar()->showMessage(tr("逻辑输出已配置"), 3000);

  1309. }

  1310. 

  1311. void MainWindow::addLogicRung()

  1312. {

  1313.     const LogicEditorResult result = logic_editor_widget_->addRung();

  1314.     if (!result.succeeded)

  1315.     {

  1316.         showProjectResult(tr("新建网络"), fromUtf8(result.message), false);

  1317.         return;

  1318.     }

  1319.     selected_logic_node_id_.clear();

  1320.     showLogicNodeProperties({});

  1321.     refreshProjectUi();

  1322.     statusBar()->showMessage(tr("已新建网络"), 3000);

  1323. }

  1324. 

  1325. void MainWindow::editSelectedRungComment()

  1326. {

  1327.     const std::string rung_id = logic_editor_widget_->selectedRungId();

  1328.     if (rung_id.empty())

  1329.     {

  1330.         showProjectResult(tr("网络注释"), tr("请先选择一个梯形图网络"), false);

  1331.         return;

  1332.     }

  1333.     const LadderRung *rung = logic_editor_service_.findRung(

  1334.         current_logic_id_, rung_id);

  1335.     if (rung == nullptr)

  1336.     {

  1337.         return;

  1338.     }

  1339.     bool accepted = false;

  1340.     const QString comment = QInputDialog::getText(

  1341.         this,

  1342.         tr("网络注释"),

  1343.         tr("说明"),

  1344.         QLineEdit::Normal,

  1345.         fromUtf8(rung->comment),

  1346.         &accepted);

  1347.     if (!accepted)

  1348.     {

  1349.         return;

  1350.     }

  1351.     const LogicEditorResult result = logic_editor_service_.updateRungComment(

  1352.         current_logic_id_, rung_id, toUtf8(comment));

  1353.     if (!result.succeeded)

  1354.     {

  1355.         showProjectResult(tr("网络注释"), fromUtf8(result.message), false);

  1356.         return;

  1357.     }

  1358.     logic_editor_widget_->reloadLogic();

  1359.     refreshProjectUi();

  1360.     statusBar()->showMessage(tr("网络注释已更新"), 3000);

  1361. }

  1362. 

  1363. void MainWindow::deleteSelectedLogicObject()

  1364. {

  1365.     const LogicEditorResult result = logic_editor_widget_->deleteSelected();

  1366.     if (!result.succeeded)

  1367.     {

  1368.         return;

  1369.     }

  1370.     selected_logic_node_id_.clear();

  1371.     showLogicNodeProperties({});

  1372.     refreshProjectUi();

  1373. }

  1374. 

  1375. void MainWindow::createNewProject()

  1376. {

  1377.     if (!confirmSaveBeforeDestructiveAction())

  1378.     {

  1379.         return;

  1380.     }

  1381.     const QString name = QInputDialog::getText(

  1382.         this, tr("新建工程"), tr("工程名称"));

  1383.     if (name.isEmpty())

  1384.     {

  1385.         return;

  1386.     }

  1387.     const ProjectOperationResult result = project_service_.createNewProject(toUtf8(name));

  1388.     if (!result.succeeded)

  1389.     {

  1390.         showProjectResult(tr("新建工程"), fromUtf8(result.message), false);

  1391.         return;

  1392.     }

  1393.     hmi_editor_service_.ensureDefaultPage();

  1394.     logic_editor_service_.ensureDefaultLogic();

  1395.     clearEditorHistories();

  1396.     selected_control_id_.clear();

  1397.     selected_logic_node_id_.clear();

  1398.     current_hmi_page_id_ = project_service_.project().initialHmiPageId;

  1399.     current_logic_id_ = logic_editor_service_.firstLogicId();

  1400.     refreshProjectUi();

  1401.     hmi_editor_widget_->reloadPage();

  1402.     logic_editor_widget_->reloadLogic();

  1403.     showControlProperties({});

  1404.     statusBar()->showMessage(tr("已创建新工程"), 3000);

  1405. }

  1406. 

  1407. void MainWindow::saveProject()

  1408. {

  1409.     if (!project_service_.hasCurrentFile())

  1410.     {

  1411.         saveProjectAs();

  1412.         return;

  1413.     }

  1414.     const ProjectOperationResult result = project_service_.save();

  1415.     if (!result.succeeded)

  1416.     {

  1417.         showProjectResult(tr("保存工程"), fromUtf8(result.message), false);

  1418.         return;

  1419.     }

  1420.     updateWindowTitle();

  1421.     showProjectResult(tr("保存工程"), tr("工程已保存"), true);

  1422. }

  1423. 

  1424. void MainWindow::saveProjectAs()

  1425. {

  1426.     const QString path = QFileDialog::getSaveFileName(

  1427.         this, tr("工程另存为"), {}, tr("工程文件 (*.json)"));

  1428.     if (path.isEmpty())

  1429.     {

  1430.         return;

  1431.     }

  1432.     const ProjectOperationResult result = project_service_.saveAs(toUtf8(path));

  1433.     if (result.succeeded)

  1434.     {

  1435.         updateWindowTitle();

  1436.     }

  1437.     showProjectResult(

  1438.         tr("保存工程"),

  1439.         result.succeeded ? tr("工程已保存") : fromUtf8(result.message),

  1440.         result.succeeded);

  1441. }

  1442. 

  1443. void MainWindow::loadProject()

  1444. {

  1445.     if (!confirmSaveBeforeDestructiveAction())

  1446.     {

  1447.         return;

  1448.     }

  1449.     const QString path = QFileDialog::getOpenFileName(

  1450.         this, tr("加载工程"), {}, tr("工程文件 (*.json)"));

  1451.     if (path.isEmpty())

  1452.     {

  1453.         return;

  1454.     }

  1455.     const ProjectOperationResult result = project_service_.load(toUtf8(path));

  1456.     if (!result.succeeded)

  1457.     {

  1458.         showProjectResult(tr("加载工程"), fromUtf8(result.message), false);

  1459.         return;

  1460.     }

  1461.     clearEditorHistories();

  1462.     selected_control_id_.clear();

  1463.     selected_logic_node_id_.clear();

  1464.     current_hmi_page_id_ = project_service_.project().initialHmiPageId;

  1465.     current_logic_id_ = logic_editor_service_.firstLogicId();

  1466.     refreshProjectUi();

  1467.     hmi_editor_widget_->reloadPage();

  1468.     logic_editor_widget_->reloadLogic();

  1469.     showControlProperties({});

  1470.     showProjectResult(tr("加载工程"), tr("工程已加载"), true);

  1471. }

  1472. 

  1473. void MainWindow::showProjectResult(

  1474.     const QString &action, const QString &message, bool succeeded)

  1475. {

  1476.     const QString output = action + QStringLiteral(": ") + message;

  1477.     statusBar()->showMessage(output, 5000);

  1478.     appendOutputMessage(output);

  1479.     if (!succeeded)

  1480.     {

  1481.         QMessageBox::warning(this, action, message);

  1482.     }

  1483. }

  1484. 

  1485. void MainWindow::appendOutputMessage(const QString &message)

  1486. {

  1487.     while (ui_->outputList->count() >= ProjectLimits::kMaximumOutputMessages)

  1488.     {

  1489.         delete ui_->outputList->takeItem(0);

  1490.     }

  1491.     ui_->outputList->addItem(message);

  1492.     ui_->outputList->scrollToBottom();

  1493. }

  1494. 

  1495. void MainWindow::requestMode(ApplicationMode requested_mode)

  1496. {

  1497.     // UI 仅转发模式意图，合法性由服务层和领域状态机决定

  1498.     ModeTransitionResult result;

  1499.     switch (requested_mode)

  1500.     {

  1501.     case ApplicationMode::Editing:

  1502.     {

  1503.         result = runtime_mode_service_.enterEditing();

  1504.         break;

  1505.     }

  1506.     case ApplicationMode::OfflineRunning:

  1507.     {

  1508.         result = runtime_mode_service_.enterOfflineRunning();

  1509.         break;

  1510.     }

  1511.     case ApplicationMode::OnlineRunning:

  1512.     {

  1513.         result = runtime_mode_service_.enterOnlineRunning();

  1514.         break;

  1515.     }

  1516.     default:

  1517.     {

  1518.         restoreCurrentModeAction();

  1519.         statusBar()->showMessage(tr("不支持的运行模式"), 5000);

  1520.         return;

  1521.     }

  1522.     }

  1523.     if (!result.succeeded)

  1524.     {

  1525.         restoreCurrentModeAction();

  1526.         QString message = transitionErrorText(result.error);

  1527.         if (result.error == ModeTransitionError::InitialPlcReadRequired)

  1528.         {

  1529.             message += tr("；当前状态：%1").arg(plcStatusText(runtime_mode_service_));

  1530.         }

  1531.         if (result.error == ModeTransitionError::SimulationStartFailed)

  1532.         {

  1533.             const LogicScanResult &error = runtime_mode_service_.simulationError();

  1534.             if (!error.message.empty())

  1535.             {

  1536.                 message += QStringLiteral(": ") + fromUtf8(error.message);

  1537.             }

  1538.         }

  1539.         statusBar()->showMessage(message, 5000);

  1540.         return;

  1541.     }

  1542.     updateModeUi(tr("已进入%1").arg(modeText(runtime_mode_service_.mode())));

  1543. }

  1544. 

  1545. void MainWindow::updateModeUi(const QString &message)

  1546. {

  1547.     const ApplicationMode mode = runtime_mode_service_.mode();

  1548.     const ModePolicy policy = runtime_mode_service_.policy();

  1549.     restoreCurrentModeAction();

  1550.     const bool running = mode != ApplicationMode::Editing;

  1551.     if (running)

  1552.     {

  1553.         if (hmi_navigation_service_->currentPageId().empty())

  1554.         {

  1555.             const HmiNavigationResult navigation = hmi_navigation_service_->start();

  1556.             if (!navigation.succeeded)

  1557.             {

  1558.                 statusBar()->showMessage(fromUtf8(navigation.message), 5000);

  1559.             }

  1560.         }

  1561.         runtime_panel_controller_->enterRuntime(

  1562.             hmi_navigation_service_->currentPageId(),

  1563.             current_logic_id_,

  1564.             mode,

  1565.             runtime_mode_service_.plcConnectionState());

  1566.     }

  1567.     else

  1568.     {

  1569.         hmi_navigation_service_->stop();

  1570.         runtime_panel_controller_->leaveRuntime(

  1571.             mode, runtime_mode_service_.plcConnectionState());

  1572.     }

  1573.     // 将同一份模式策略同步到所有可编辑入口，避免只禁用部分操作

  1574.     ui_->projectDock->setEnabled(policy.allowsProjectEditing);

  1575.     ui_->propertiesDock->setEnabled(policy.allowsProjectEditing);

  1576.     hmi_editor_widget_->setEditingEnabled(policy.allowsProjectEditing);

  1577.     hmi_editor_widget_->setRuntimeActive(

  1578.         policy.usesVirtualRegisters || policy.usesPlcRegisters);

  1579.     logic_editor_widget_->setEditingEnabled(policy.allowsProjectEditing);

  1580.     if (mode == ApplicationMode::Editing)

  1581.     {

  1582.         alarm_service_.reset();

  1583.         logic_editor_widget_->clearRuntimeTrace();

  1584.     }

  1585.     ui_->hmiToolBar->setEnabled(policy.allowsProjectEditing);

  1586.     ui_->logicToolBar->setEnabled(policy.allowsProjectEditing);

  1587.     ui_->addButtonAction->setEnabled(policy.allowsProjectEditing);

  1588.     ui_->addIndicatorAction->setEnabled(policy.allowsProjectEditing);

  1589.     ui_->addNumericDisplayAction->setEnabled(policy.allowsProjectEditing);

  1590.     ui_->addNumericInputAction->setEnabled(policy.allowsProjectEditing);

  1591.     ui_->addProgressBarAction->setEnabled(policy.allowsProjectEditing);

  1592.     ui_->addLabelAction->setEnabled(policy.allowsProjectEditing);

  1593.     ui_->addPageJumpAction->setEnabled(policy.allowsProjectEditing);

  1594.     ui_->addAlarmListAction->setEnabled(policy.allowsProjectEditing);

  1595.     ui_->configureAlarmsAction->setEnabled(policy.allowsProjectEditing);

  1596.     ui_->configureRegisterCommentsAction->setEnabled(policy.allowsProjectEditing);

  1597.     ui_->deleteControlAction->setEnabled(policy.allowsProjectEditing);

  1598.     ui_->addNormallyOpenAction->setEnabled(policy.allowsProjectEditing);

  1599.     ui_->addNormallyClosedAction->setEnabled(policy.allowsProjectEditing);

  1600.     ui_->addRisingEdgeAction->setEnabled(policy.allowsProjectEditing);

  1601.     ui_->addFallingEdgeAction->setEnabled(policy.allowsProjectEditing);

  1602.     ui_->addTimerContactAction->setEnabled(policy.allowsProjectEditing);

  1603.     ui_->addCounterContactAction->setEnabled(policy.allowsProjectEditing);

  1604.     ui_->addNormalCoilAction->setEnabled(policy.allowsProjectEditing);

  1605.     ui_->addSetCoilAction->setEnabled(policy.allowsProjectEditing);

  1606.     ui_->addResetCoilAction->setEnabled(policy.allowsProjectEditing);

  1607.     ui_->addTonAction->setEnabled(policy.allowsProjectEditing);

  1608.     ui_->addCtuAction->setEnabled(policy.allowsProjectEditing);

  1609.     ui_->addCtdAction->setEnabled(policy.allowsProjectEditing);

  1610.     ui_->addMoveAction->setEnabled(policy.allowsProjectEditing);

  1611.     ui_->addAddAction->setEnabled(policy.allowsProjectEditing);

  1612.     ui_->addSubAction->setEnabled(policy.allowsProjectEditing);

  1613.     ui_->addCompareAction->setEnabled(policy.allowsProjectEditing);

  1614.     ui_->editRungCommentAction->setEnabled(policy.allowsProjectEditing);

  1615.     ui_->deleteLogicAction->setEnabled(policy.allowsProjectEditing);

  1616.     ui_->newProjectAction->setEnabled(policy.allowsProjectEditing);

  1617.     ui_->saveProjectAction->setEnabled(policy.allowsProjectEditing);

  1618.     ui_->saveAsProjectAction->setEnabled(policy.allowsProjectEditing);

  1619.     ui_->loadProjectAction->setEnabled(policy.allowsProjectEditing);

  1620.     updateProjectTreeActions();

  1621.     updateEditActions();

  1622. 

  1623.     mode_status_label_->setText(modeText(mode));

  1624.     if (mode == ApplicationMode::Editing)

  1625.     {

  1626.         mode_status_label_->setStyleSheet(QStringLiteral(

  1627.             "border: 1px solid #75a58a; background: #e3f0e8; color: #205c3b; padding: 2px 8px;"));

  1628.     }

  1629.     else if (mode == ApplicationMode::OfflineRunning)

  1630.     {

  1631.         mode_status_label_->setStyleSheet(QStringLiteral(

  1632.             "border: 1px solid #bd8739; background: #fff0d2; color: #744b0e; padding: 2px 8px;"));

  1633.     }

  1634.     else

  1635.     {

  1636.         mode_status_label_->setStyleSheet(QStringLiteral(

  1637.             "border: 1px solid #4b88a8; background: #deeff7; color: #174f6c; padding: 2px 8px;"));

  1638.     }

  1639.     register_status_label_->setText(

  1640.         policy.usesVirtualRegisters ? tr("数据源：虚拟 M/D")

  1641.         : policy.usesPlcRegisters ? tr("数据源：PLC 缓存") : tr("数据源：未启用"));

  1642.     const PlcConnectionState plc_state = runtime_mode_service_.plcConnectionState();

  1643.     const bool plc_configuration_available = plc_state == PlcConnectionState::Disconnected

  1644.         || plc_state == PlcConnectionState::Faulted;

  1645.     ui_->configurePlcAction->setEnabled(

  1646.         policy.allowsProjectEditing && plc_configuration_available);

  1647.     ui_->configurePlcAction->setText(

  1648.         plc_state == PlcConnectionState::Faulted ? tr("PLC 重新配置") : tr("PLC 配置"));

  1649.     ui_->configurePlcAction->setToolTip(

  1650.         plc_state == PlcConnectionState::Faulted

  1651.             ? tr("清理故障会话后重新配置并连接真实 PLC")

  1652.             : tr("配置参数并连接真实 PLC"));

  1653.     ui_->disconnectPlcAction->setEnabled(plc_state != PlcConnectionState::Disconnected);

  1654.     if (plc_state == PlcConnectionState::Connecting)

  1655.     {

  1656.         register_status_label_->setText(tr("PLC：正在连接"));

  1657.     }

  1658.     else if (plc_state == PlcConnectionState::Connected)

  1659.     {

  1660.         register_status_label_->setText(

  1661.             runtime_mode_service_.initialPlcReadCompleted()

  1662.                 ? tr("PLC：已连接，首读完成") : tr("PLC：已连接，正在首读"));

  1663.     }

  1664.     else if (plc_state == PlcConnectionState::Recovering)

  1665.     {

  1666.         register_status_label_->setText(tr("PLC：通信已恢复，正在重新首读"));

  1667.     }

  1668.     else if (plc_state == PlcConnectionState::Faulted)

  1669.     {

  1670.         register_status_label_->setText(tr("PLC：通信故障"));

  1671.     }

  1672.     updateSimulationUi(false);

  1673.     statusBar()->showMessage(message, 4000);

  1674.     const bool duplicate = ui_->outputList->count() > 0

  1675.         && ui_->outputList->item(ui_->outputList->count() - 1)->text() == message;

  1676.     if (!duplicate)

  1677.     {

  1678.         appendOutputMessage(message);

  1679.     }

  1680. }

  1681. 

  1682. void MainWindow::updateSimulationUi(bool report_fault)

  1683. {

  1684.     runtime_panel_controller_->updateSimulationUi(report_fault);

  1685. }

  1686. 

  1687. // 根据当前真实运行模式，同步更新模式工具栏单选按钮选中状态

  1688. void MainWindow::restoreCurrentModeAction()

  1689. {

  1690.     ui_->editingModeAction->setChecked(runtime_mode_service_.mode()

  1691.                                        == ApplicationMode::Editing);

  1692.     ui_->offlineModeAction->setChecked(runtime_mode_service_.mode()

  1693.                                        == ApplicationMode::OfflineRunning);

  1694.     ui_->onlineModeAction->setChecked(runtime_mode_service_.mode()

  1695.                                       == ApplicationMode::OnlineRunning);

  1696. }