suyu
/
suyu_two
1
0
Форкнуть 0
Код Задачи 0 Pull Request'ы 0 Релизы 0 Вики Активность
综合平台编程器项目的远程存储
Вы не можете выбрать более 25 тем Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
75 коммитов
1 ветка
183 MiB
 
 
 
 
Дерево: 2fa8c1f226
Ветки Теги
${ item.name }
Создать ветку ${ searchTerm }
из '2fa8c1f226'
${ noResults }
suyu_two/app/src/ui/property_panel_controller.cpp

622 строки
26 KiB
Исходник Вина История 

  1. #include "property_panel_controller.h"

  2. 

  3. #include "domain/hmi_control_registry.h"

  4. #include "hmi_editor_widget.h"

  5. #include "logic_editor_widget.h"

  6. #include "logic_instruction_dialog.h"

  7. #include "services/hmi_editor_service.h"

  8. #include "services/logic_editor_service.h"

  9. #include "services/project_service.h"

  10. #include "ui_main_window.h"

  11. 

  12. #include <QCheckBox>

  13. #include <QComboBox>

  14. #include <QLabel>

  15. #include <QPushButton>

  16. #include <QDialog>

  17. #include <QObject>

  18. #include <QSpinBox>

  19. #include <QStackedWidget>

  20. #include <QWidget>

  21. 

  22. #include <cstdint>

  23. #include <utility>

  24. #include <vector>

  25. 

  26. namespace {

  27. 

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

  29. {

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

  31. }

  32. 

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

  34. {

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

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

  37. }

  38. 

  39. } // namespace

  40. 

  41. PropertyPanelController::PropertyPanelController(

  42.     QWidget &parent,

  43.     Ui::MainWindow &ui,

  44.     ProjectService &project_service,

  45.     HmiEditorService &hmi_editor_service,

  46.     LogicEditorService &logic_editor_service,

  47.     std::function<std::string()> current_page_id,

  48.     std::function<std::string()> current_logic_id,

  49.     std::string &selected_control_id,

  50.     std::string &selected_logic_node_id,

  51.     std::function<void()> refresh_project_ui,

  52.     ResultReporter result_reporter,

  53.     StatusReporter status_reporter)

  54.     : parent_(parent),

  55.       ui_(ui),

  56.       project_service_(project_service),

  57.       hmi_editor_service_(hmi_editor_service),

  58.       logic_editor_service_(logic_editor_service),

  59.       current_page_id_(std::move(current_page_id)),

  60.       current_logic_id_(std::move(current_logic_id)),

  61.       selected_control_id_(selected_control_id),

  62.       selected_logic_node_id_(selected_logic_node_id),

  63.       refresh_project_ui_(std::move(refresh_project_ui)),

  64.       result_reporter_(std::move(result_reporter)),

  65.       status_reporter_(std::move(status_reporter))

  66. {

  67. }

  68. 

  69. void PropertyPanelController::configure()

  70. {

  71.     ui_.bindingAreaComboBox->setItemData(0, -1);

  72.     ui_.bindingAreaComboBox->setItemData(1, 0);

  73.     ui_.bindingAreaComboBox->setItemData(2, 1);

  74.     ui_.buttonOperationComboBox->setItemData(

  75.         0, static_cast<int>(HmiButtonOperation::SetOn));

  76.     ui_.buttonOperationComboBox->setItemData(

  77.         1, static_cast<int>(HmiButtonOperation::SetOff));

  78.     ui_.buttonOperationComboBox->setItemData(

  79.         2, static_cast<int>(HmiButtonOperation::Toggle));

  80.     ui_.buttonOperationComboBox->setItemData(

  81.         3, static_cast<int>(HmiButtonOperation::MomentaryOn));

  82.     for (int index = 0; index < ui_.logicComparisonComboBox->count(); ++index)

  83.     {

  84.         ui_.logicComparisonComboBox->setItemData(index, index);

  85.     }

  86.     QObject::connect(ui_.applyPropertiesButton, &QPushButton::clicked,

  87.             &parent_, [this] { applySelectedControlProperties(); });

  88.     QObject::connect(ui_.applyLogicPropertiesButton, &QPushButton::clicked,

  89.             &parent_, [this] { applySelectedLogicNodeProperties(); });

  90.     ui_.targetPageLabel->setVisible(false);

  91.     ui_.targetPageComboBox->setVisible(false);

  92.     showControlProperties({});

  93. }

  94. 

  95. void PropertyPanelController::bindEditorWidgets(

  96.     HmiEditorWidget &hmi_editor_widget,

  97.     LogicEditorWidget &logic_editor_widget)

  98. {

  99.     hmi_editor_widget_ = &hmi_editor_widget;

  100.     logic_editor_widget_ = &logic_editor_widget;

  101.     QObject::connect(&hmi_editor_widget, &HmiEditorWidget::controlSelected,

  102.             &parent_, [this](const QString &id)

  103.             {

  104.                 showControlProperties(toUtf8(id));

  105.             });

  106.     QObject::connect(&hmi_editor_widget, &HmiEditorWidget::controlChanged,

  107.             &parent_, [this](const QString &id)

  108.             {

  109.                 showControlProperties(toUtf8(id));

  110.                 refresh_project_ui_();

  111.             });

  112.     QObject::connect(&hmi_editor_widget, &HmiEditorWidget::editorError,

  113.             &parent_, [this](const QString &message)

  114.             {

  115.                 handleHmiEditorError(message);

  116.             });

  117.     QObject::connect(&logic_editor_widget, &LogicEditorWidget::nodeSelected,

  118.             &parent_, [this](const QString &id)

  119.             {

  120.                 showLogicNodeProperties(toUtf8(id));

  121.             });

  122.     QObject::connect(&logic_editor_widget, &LogicEditorWidget::graphChanged,

  123.             &parent_, [this]

  124.             {

  125.                 refresh_project_ui_();

  126.             });

  127.     QObject::connect(&logic_editor_widget, &LogicEditorWidget::editorError,

  128.             &parent_, [this](const QString &message)

  129.             {

  130.                 handleLogicEditorError(message);

  131.             });

  132. }

  133. 

  134. void PropertyPanelController::showControlProperties(const std::string &control_id)

  135. {

  136.     ui_.propertyStack->setCurrentWidget(ui_.hmiPropertiesPage);

  137.     selected_control_id_ = control_id;

  138.     const HmiControl *control = hmi_editor_service_.findControl(

  139.         current_page_id_(), control_id);

  140.     const bool has_control = control != nullptr;

  141.     const HmiControlDescriptor *descriptor = has_control

  142.         ? findHmiControlDescriptor(control->type) : nullptr;

  143.     ui_.selectionValueLabel->setText(

  144.         has_control ? fromUtf8(control->id)

  145.                           + (control->isConfigured() ? QString{}

  146.                              : control->type == HmiControlType::PageJump

  147.                                  ? QObject::tr("（未配置）") : QObject::tr("（未绑定）"))

  148.                     : QObject::tr("未选择"));

  149. 

  150.     for (QWidget *widget : {static_cast<QWidget *>(ui_.controlIdEdit),

  151.                             static_cast<QWidget *>(ui_.controlTextEdit),

  152.                             static_cast<QWidget *>(ui_.controlXSpinBox),

  153.                             static_cast<QWidget *>(ui_.controlYSpinBox),

  154.                             static_cast<QWidget *>(ui_.controlWidthSpinBox),

  155.                             static_cast<QWidget *>(ui_.controlHeightSpinBox),

  156.                             static_cast<QWidget *>(ui_.bindingAreaComboBox),

  157.                             static_cast<QWidget *>(ui_.bindingIndexSpinBox),

  158.                             static_cast<QWidget *>(ui_.targetPageComboBox),

  159.                             static_cast<QWidget *>(ui_.buttonOperationComboBox),

  160.                             static_cast<QWidget *>(ui_.progressMinimumSpinBox),

  161.                             static_cast<QWidget *>(ui_.progressMaximumSpinBox),

  162.                             static_cast<QWidget *>(ui_.progressShowValueCheckBox),

  163.                             static_cast<QWidget *>(ui_.applyPropertiesButton)})

  164.     {

  165.         widget->setEnabled(has_control);

  166.     }

  167. 

  168.     if (!has_control)

  169.     {

  170.         ui_.bindingAreaLabel->setVisible(false);

  171.         ui_.bindingAreaComboBox->setVisible(false);

  172.         ui_.bindingIndexLabel->setVisible(false);

  173.         ui_.bindingIndexSpinBox->setVisible(false);

  174.         ui_.targetPageLabel->setVisible(false);

  175.         ui_.targetPageComboBox->setVisible(false);

  176.         ui_.buttonOperationLabel->setVisible(false);

  177.         ui_.buttonOperationComboBox->setVisible(false);

  178.         ui_.progressMinimumLabel->setVisible(false);

  179.         ui_.progressMinimumSpinBox->setVisible(false);

  180.         ui_.progressMaximumLabel->setVisible(false);

  181.         ui_.progressMaximumSpinBox->setVisible(false);

  182.         ui_.progressShowValueLabel->setVisible(false);

  183.         ui_.progressShowValueCheckBox->setVisible(false);

  184.         return;

  185.     }

  186. 

  187.     ui_.controlIdEdit->setText(fromUtf8(control->id));

  188.     ui_.controlTextEdit->setText(fromUtf8(control->text));

  189.     ui_.controlXSpinBox->setValue(control->bounds.x);

  190.     ui_.controlYSpinBox->setValue(control->bounds.y);

  191.     ui_.controlWidthSpinBox->setValue(control->bounds.width);

  192.     ui_.controlHeightSpinBox->setValue(control->bounds.height);

  193.     ui_.bindingAreaComboBox->setCurrentIndex(!control->binding.has_value() ? 0

  194.         : control->binding->area() == RegisterArea::M ? 1 : 2);

  195.     ui_.bindingIndexSpinBox->setValue(

  196.         control->binding.has_value() ? control->binding->index() : 0);

  197.     const bool has_binding = descriptor != nullptr

  198.         && descriptor->bindingKind != HmiBindingKind::None;

  199.     ui_.bindingAreaLabel->setVisible(has_binding);

  200.     ui_.bindingAreaComboBox->setVisible(has_binding);

  201.     ui_.bindingIndexLabel->setVisible(has_binding);

  202.     ui_.bindingIndexSpinBox->setVisible(has_binding);

  203. 

  204.     const bool is_button = control->type == HmiControlType::Button;

  205.     ui_.buttonOperationLabel->setVisible(is_button);

  206.     ui_.buttonOperationComboBox->setVisible(is_button);

  207.     ui_.buttonOperationComboBox->setEnabled(is_button);

  208.     ui_.buttonOperationComboBox->setCurrentIndex(

  209.         ui_.buttonOperationComboBox->findData(

  210.             static_cast<int>(control->buttonOperation)));

  211. 

  212.     const bool is_page_jump = control->type == HmiControlType::PageJump;

  213.     ui_.targetPageLabel->setVisible(is_page_jump);

  214.     ui_.targetPageComboBox->setVisible(is_page_jump);

  215.     ui_.targetPageComboBox->setEnabled(is_page_jump);

  216.     ui_.targetPageComboBox->clear();

  217.     if (is_page_jump)

  218.     {

  219.         for (const HmiPage &page : project_service_.project().hmiPages)

  220.         {

  221.             ui_.targetPageComboBox->addItem(

  222.                 fromUtf8(page.name), fromUtf8(page.id));

  223.         }

  224.         const std::string target_id = control->pageJump.has_value()

  225.             ? control->pageJump->targetPageId : std::string{};

  226.         ui_.targetPageComboBox->setCurrentIndex(

  227.             ui_.targetPageComboBox->findData(fromUtf8(target_id)));

  228.     }

  229. 

  230.     const bool is_progress_bar = control->type == HmiControlType::ProgressBar;

  231.     ui_.progressMinimumLabel->setVisible(is_progress_bar);

  232.     ui_.progressMinimumSpinBox->setVisible(is_progress_bar);

  233.     ui_.progressMaximumLabel->setVisible(is_progress_bar);

  234.     ui_.progressMaximumSpinBox->setVisible(is_progress_bar);

  235.     ui_.progressShowValueLabel->setVisible(is_progress_bar);

  236.     ui_.progressShowValueCheckBox->setVisible(is_progress_bar);

  237.     ui_.progressMinimumSpinBox->setEnabled(is_progress_bar);

  238.     ui_.progressMaximumSpinBox->setEnabled(is_progress_bar);

  239.     ui_.progressShowValueCheckBox->setEnabled(is_progress_bar);

  240.     const HmiProgressBarConfig progress_config = control->progressBar.value_or(

  241.         HmiProgressBarConfig{});

  242.     ui_.progressMinimumSpinBox->setValue(progress_config.minimumValue);

  243.     ui_.progressMaximumSpinBox->setValue(progress_config.maximumValue);

  244.     ui_.progressShowValueCheckBox->setChecked(progress_config.showValue);

  245. }

  246. 

  247. void PropertyPanelController::showLogicNodeProperties(const std::string &node_id)

  248. {

  249.     ui_.propertyStack->setCurrentWidget(ui_.logicPropertiesPage);

  250.     selected_logic_node_id_ = node_id;

  251.     const LogicNode *node = logic_editor_service_.findNode(

  252.         current_logic_id_(), node_id);

  253.     const bool has_node = node != nullptr;

  254.     ui_.selectionValueLabel->setText(

  255.         has_node ? fromUtf8(node->id) : QObject::tr("未选择"));

  256.     for (QWidget *widget : {static_cast<QWidget *>(ui_.logicNodeIdEdit),

  257.                             static_cast<QWidget *>(ui_.logicAddressSpinBox),

  258.                             static_cast<QWidget *>(ui_.logicModeComboBox),

  259.                             static_cast<QWidget *>(ui_.logicComparisonComboBox),

  260.                             static_cast<QWidget *>(ui_.logicValueSpinBox),

  261.                             static_cast<QWidget *>(ui_.logicPresetSpinBox),

  262.                             static_cast<QWidget *>(ui_.applyLogicPropertiesButton)})

  263.     {

  264.         widget->setEnabled(has_node);

  265.     }

  266.     ui_.logicNodeTypeLabel->setEnabled(has_node);

  267.     ui_.logicAddressAreaLabel->setEnabled(has_node);

  268.     if (!has_node)

  269.     {

  270.         ui_.logicNodeIdEdit->clear();

  271.         ui_.logicNodeTypeLabel->clear();

  272.         ui_.logicAddressAreaLabel->clear();

  273.         ui_.logicModeComboBox->clear();

  274.         ui_.logicPresetSpinBox->setValue(TonNodeConfig::kMinimumPresetMs);

  275.         return;

  276.     }

  277. 

  278.     ui_.logicNodeIdEdit->setText(fromUtf8(node->id));

  279.     ui_.logicModeComboBox->clear();

  280.     ui_.logicComparisonComboBox->setEnabled(false);

  281.     ui_.logicValueSpinBox->setEnabled(false);

  282.     ui_.logicPresetSpinBox->setEnabled(false);

  283.     if (const auto *contact = std::get_if<ContactNodeConfig>(&node->config))

  284.     {

  285.         ui_.logicNodeTypeLabel->setText(QObject::tr("触点"));

  286.         ui_.logicAddressAreaLabel->setText(QStringLiteral("M"));

  287.         ui_.logicAddressSpinBox->setValue(contact->address.index());

  288.         ui_.logicModeComboBox->addItem(

  289.             QObject::tr("常开"), static_cast<int>(ContactMode::NormallyOpen));

  290.         ui_.logicModeComboBox->addItem(

  291.             QObject::tr("常闭"), static_cast<int>(ContactMode::NormallyClosed));

  292.         ui_.logicModeComboBox->setCurrentIndex(

  293.             ui_.logicModeComboBox->findData(static_cast<int>(contact->mode)));

  294.         ui_.logicModeComboBox->setEnabled(true);

  295.     }

  296.     else if (const auto *edge = std::get_if<EdgeContactNodeConfig>(&node->config))

  297.     {

  298.         ui_.logicNodeTypeLabel->setText(QObject::tr("边沿触点"));

  299.         ui_.logicAddressAreaLabel->setText(QStringLiteral("M"));

  300.         ui_.logicAddressSpinBox->setValue(edge->address.index());

  301.         ui_.logicModeComboBox->addItem(

  302.             QObject::tr("上升沿"), static_cast<int>(EdgeMode::Rising));

  303.         ui_.logicModeComboBox->addItem(

  304.             QObject::tr("下降沿"), static_cast<int>(EdgeMode::Falling));

  305.         ui_.logicModeComboBox->setCurrentIndex(

  306.             ui_.logicModeComboBox->findData(static_cast<int>(edge->mode)));

  307.         ui_.logicModeComboBox->setEnabled(true);

  308.     }

  309.     else if (const auto *timer = std::get_if<TimerContactNodeConfig>(&node->config))

  310.     {

  311.         ui_.logicNodeTypeLabel->setText(QObject::tr("T 触点"));

  312.         ui_.logicAddressAreaLabel->setText(QStringLiteral("T"));

  313.         ui_.logicAddressSpinBox->setValue(timer->address.index());

  314.         ui_.logicModeComboBox->addItem(

  315.             QObject::tr("常开"), static_cast<int>(ContactMode::NormallyOpen));

  316.         ui_.logicModeComboBox->addItem(

  317.             QObject::tr("常闭"), static_cast<int>(ContactMode::NormallyClosed));

  318.         ui_.logicModeComboBox->setCurrentIndex(

  319.             ui_.logicModeComboBox->findData(static_cast<int>(timer->mode)));

  320.         ui_.logicModeComboBox->setEnabled(true);

  321.     }

  322.     else if (const auto *counter_contact =

  323.                  std::get_if<CounterContactNodeConfig>(&node->config))

  324.     {

  325.         ui_.logicNodeTypeLabel->setText(QObject::tr("C 触点"));

  326.         ui_.logicAddressAreaLabel->setText(QStringLiteral("C"));

  327.         ui_.logicAddressSpinBox->setValue(counter_contact->address.index());

  328.         ui_.logicModeComboBox->addItem(

  329.             QObject::tr("常开"), static_cast<int>(ContactMode::NormallyOpen));

  330.         ui_.logicModeComboBox->addItem(

  331.             QObject::tr("常闭"), static_cast<int>(ContactMode::NormallyClosed));

  332.         ui_.logicModeComboBox->setCurrentIndex(ui_.logicModeComboBox->findData(

  333.             static_cast<int>(counter_contact->mode)));

  334.         ui_.logicModeComboBox->setEnabled(true);

  335.     }

  336.     else if (const auto *coil = std::get_if<CoilNodeConfig>(&node->config))

  337.     {

  338.         ui_.logicNodeTypeLabel->setText(QObject::tr("线圈"));

  339.         ui_.logicAddressAreaLabel->setText(QStringLiteral("M"));

  340.         ui_.logicAddressSpinBox->setValue(coil->address.index());

  341.         ui_.logicModeComboBox->addItem(

  342.             QObject::tr("普通"), static_cast<int>(CoilMode::Normal));

  343.         ui_.logicModeComboBox->addItem(

  344.             QObject::tr("置位"), static_cast<int>(CoilMode::Set));

  345.         ui_.logicModeComboBox->addItem(

  346.             QObject::tr("复位"), static_cast<int>(CoilMode::Reset));

  347.         ui_.logicModeComboBox->setCurrentIndex(

  348.             ui_.logicModeComboBox->findData(static_cast<int>(coil->mode)));

  349.         ui_.logicModeComboBox->setEnabled(true);

  350.     }

  351.     else if (const auto *compare = std::get_if<CompareNodeConfig>(&node->config))

  352.     {

  353.         ui_.logicNodeTypeLabel->setText(QObject::tr("D 值比较"));

  354.         ui_.logicAddressAreaLabel->setText(QStringLiteral("D"));

  355.         ui_.logicAddressSpinBox->setValue(compare->address.index());

  356.         ui_.logicModeComboBox->addItem(QObject::tr("不适用"));

  357.         ui_.logicModeComboBox->setEnabled(false);

  358.         ui_.logicComparisonComboBox->setEnabled(true);

  359.         ui_.logicComparisonComboBox->setCurrentIndex(

  360.             ui_.logicComparisonComboBox->findData(

  361.                 static_cast<int>(compare->comparison)));

  362.         ui_.logicValueSpinBox->setEnabled(true);

  363.         ui_.logicValueSpinBox->setValue(compare->value);

  364.     }

  365.     else if (const auto *ton = std::get_if<TonNodeConfig>(&node->config))

  366.     {

  367.         ui_.logicNodeTypeLabel->setText(QObject::tr("TON"));

  368.         ui_.logicAddressAreaLabel->setText(QStringLiteral("T"));

  369.         ui_.logicAddressSpinBox->setValue(ton->address.index());

  370.         ui_.logicModeComboBox->addItem(QObject::tr("非保持接通延时"));

  371.         ui_.logicModeComboBox->setEnabled(false);

  372.         ui_.logicPresetSpinBox->setEnabled(true);

  373.         ui_.logicPresetSpinBox->setValue(ton->presetMs);

  374.     }

  375.     else if (const auto *counter = std::get_if<CounterNodeConfig>(&node->config))

  376.     {

  377.         ui_.logicNodeTypeLabel->setText(

  378.             counter->mode == CounterMode::Up ? QStringLiteral("CTU")

  379.                                              : QStringLiteral("CTD"));

  380.         ui_.logicAddressAreaLabel->setText(QStringLiteral("C"));

  381.         ui_.logicAddressSpinBox->setValue(counter->address.index());

  382.         ui_.logicAddressSpinBox->setEnabled(false);

  383.         ui_.logicModeComboBox->addItem(QObject::tr("使用配置对话框编辑"));

  384.         ui_.logicModeComboBox->setEnabled(false);

  385.     }

  386.     else if (const auto *move = std::get_if<MoveNodeConfig>(&node->config))

  387.     {

  388.         ui_.logicNodeTypeLabel->setText(QStringLiteral("MOVE"));

  389.         ui_.logicAddressAreaLabel->setText(QStringLiteral("D"));

  390.         ui_.logicAddressSpinBox->setValue(move->destination.index());

  391.         ui_.logicAddressSpinBox->setEnabled(false);

  392.         ui_.logicModeComboBox->addItem(QObject::tr("使用配置对话框编辑"));

  393.         ui_.logicModeComboBox->setEnabled(false);

  394.     }

  395.     else

  396.     {

  397.         const auto &arithmetic = std::get<ArithmeticNodeConfig>(node->config);

  398.         ui_.logicNodeTypeLabel->setText(

  399.             arithmetic.operation == ArithmeticOperation::Add

  400.                 ? QStringLiteral("ADD") : QStringLiteral("SUB"));

  401.         ui_.logicAddressAreaLabel->setText(QStringLiteral("D"));

  402.         ui_.logicAddressSpinBox->setValue(arithmetic.destination.index());

  403.         ui_.logicAddressSpinBox->setEnabled(false);

  404.         ui_.logicModeComboBox->addItem(QObject::tr("使用配置对话框编辑"));

  405.         ui_.logicModeComboBox->setEnabled(false);

  406.     }

  407.     if (!node->configured)

  408.     {

  409.         ui_.logicNodeTypeLabel->setText(QObject::tr("待配置：%1").arg(

  410.             ui_.logicNodeTypeLabel->text()));

  411.     }

  412. }

  413. 

  414. void PropertyPanelController::addHmiControl(HmiControlType type)

  415. {

  416.     const HmiEditorResult result = hmi_editor_service_.addControl(

  417.         current_page_id_(), type);

  418.     if (!result.succeeded)

  419.     {

  420.         reportFailure(QObject::tr("添加控件"), result.message);

  421.         return;

  422.     }

  423.     hmi_editor_widget_->reloadPage();

  424.     hmi_editor_widget_->selectControl(result.id);

  425.     showControlProperties(result.id);

  426.     refresh_project_ui_();

  427.     const HmiControlDescriptor *descriptor = findHmiControlDescriptor(type);

  428.     const QString display_name = descriptor == nullptr

  429.         ? QObject::tr("未知控件")

  430.         : QString::fromUtf8(descriptor->displayName);

  431.     status_reporter_(QObject::tr("已添加%1").arg(display_name), 3000);

  432. }

  433. 

  434. void PropertyPanelController::deleteSelectedControl()

  435. {

  436.     if (hmi_editor_widget_ == nullptr)

  437.     {

  438.         return;

  439.     }

  440.     const std::vector<std::string> selected_ids =

  441.         hmi_editor_widget_->selectedControlIds();

  442.     if (selected_ids.empty())

  443.     {

  444.         return;

  445.     }

  446.     const HmiEditorResult result = hmi_editor_service_.removeControls(

  447.         current_page_id_(), selected_ids);

  448.     if (!result.succeeded)

  449.     {

  450.         reportFailure(QObject::tr("删除控件"), result.message);

  451.         return;

  452.     }

  453.     selected_control_id_.clear();

  454.     hmi_editor_widget_->reloadPage();

  455.     showControlProperties({});

  456.     refresh_project_ui_();

  457. }

  458. 

  459. void PropertyPanelController::applySelectedControlProperties()

  460. {

  461.     const HmiControl *old_control = hmi_editor_service_.findControl(

  462.         current_page_id_(), selected_control_id_);

  463.     if (old_control == nullptr)

  464.     {

  465.         return;

  466.     }

  467.     HmiControl control = *old_control;

  468.     control.id = toUtf8(ui_.controlIdEdit->text());

  469.     control.text = toUtf8(ui_.controlTextEdit->text());

  470.     control.bounds.x = ui_.controlXSpinBox->value();

  471.     control.bounds.y = ui_.controlYSpinBox->value();

  472.     control.bounds.width = ui_.controlWidthSpinBox->value();

  473.     control.bounds.height = ui_.controlHeightSpinBox->value();

  474.     const HmiControlDescriptor *descriptor =

  475.         findHmiControlDescriptor(control.type);

  476.     if (descriptor == nullptr

  477.         || descriptor->bindingKind == HmiBindingKind::None)

  478.     {

  479.         control.binding.reset();

  480.     }

  481.     else

  482.     {

  483.         const int binding_area = ui_.bindingAreaComboBox->currentData().toInt();

  484.         if (binding_area < 0)

  485.         {

  486.             control.binding.reset();

  487.         }

  488.         else

  489.         {

  490.             const RegisterArea area = binding_area == 0

  491.                 ? RegisterArea::M : RegisterArea::D;

  492.             control.binding = RegisterAddress{

  493.                 area, ui_.bindingIndexSpinBox->value()};

  494.         }

  495.     }

  496.     if (control.type == HmiControlType::Button)

  497.     {

  498.         control.buttonOperation = static_cast<HmiButtonOperation>(

  499.             ui_.buttonOperationComboBox->currentData().toInt());

  500.     }

  501.     if (control.type == HmiControlType::PageJump)

  502.     {

  503.         control.pageJump = HmiPageJumpConfig{

  504.             toUtf8(ui_.targetPageComboBox->currentData().toString())};

  505.     }

  506.     if (control.type == HmiControlType::ProgressBar)

  507.     {

  508.         control.progressBar = HmiProgressBarConfig{

  509.             static_cast<std::int16_t>(ui_.progressMinimumSpinBox->value()),

  510.             static_cast<std::int16_t>(ui_.progressMaximumSpinBox->value()),

  511.             ui_.progressShowValueCheckBox->isChecked()};

  512.     }

  513.     const HmiEditorResult result = hmi_editor_service_.updateControl(

  514.         current_page_id_(), selected_control_id_, control);

  515.     if (!result.succeeded)

  516.     {

  517.         reportFailure(QObject::tr("应用属性"), result.message);

  518.         return;

  519.     }

  520.     const std::string updated_control_id = result.id;

  521.     hmi_editor_widget_->reloadPage();

  522.     selected_control_id_ = updated_control_id;

  523.     hmi_editor_widget_->selectControl(updated_control_id);

  524.     showControlProperties(updated_control_id);

  525.     refresh_project_ui_();

  526.     status_reporter_(QObject::tr("控件属性已更新"), 3000);

  527. }

  528. 

  529. void PropertyPanelController::applySelectedLogicNodeProperties()

  530. {

  531.     const LogicNode *node = logic_editor_service_.findNode(

  532.         current_logic_id_(), selected_logic_node_id_);

  533.     if (node == nullptr)

  534.     {

  535.         return;

  536.     }

  537. 

  538.     LogicNodeConfig config = node->config;

  539.     if (std::holds_alternative<ContactNodeConfig>(config))

  540.     {

  541.         config = ContactNodeConfig{

  542.             RegisterAddress{RegisterArea::M, ui_.logicAddressSpinBox->value()},

  543.             static_cast<ContactMode>(ui_.logicModeComboBox->currentData().toInt())};

  544.     }

  545.     else if (std::holds_alternative<EdgeContactNodeConfig>(config))

  546.     {

  547.         config = EdgeContactNodeConfig{

  548.             RegisterAddress{RegisterArea::M, ui_.logicAddressSpinBox->value()},

  549.             static_cast<EdgeMode>(ui_.logicModeComboBox->currentData().toInt())};

  550.     }

  551.     else if (std::holds_alternative<TimerContactNodeConfig>(config))

  552.     {

  553.         config = TimerContactNodeConfig{

  554.             TimerAddress{ui_.logicAddressSpinBox->value()},

  555.             static_cast<ContactMode>(ui_.logicModeComboBox->currentData().toInt())};

  556.     }

  557.     else if (std::holds_alternative<CounterContactNodeConfig>(config))

  558.     {

  559.         config = CounterContactNodeConfig{

  560.             CounterAddress{ui_.logicAddressSpinBox->value()},

  561.             static_cast<ContactMode>(ui_.logicModeComboBox->currentData().toInt())};

  562.     }

  563.     else if (std::holds_alternative<CoilNodeConfig>(config))

  564.     {

  565.         config = CoilNodeConfig{

  566.             RegisterAddress{RegisterArea::M, ui_.logicAddressSpinBox->value()},

  567.             static_cast<CoilMode>(ui_.logicModeComboBox->currentData().toInt())};

  568.     }

  569.     else if (std::holds_alternative<CompareNodeConfig>(config))

  570.     {

  571.         config = CompareNodeConfig{

  572.             RegisterAddress{RegisterArea::D, ui_.logicAddressSpinBox->value()},

  573.             static_cast<ComparisonOperator>(

  574.                 ui_.logicComparisonComboBox->currentData().toInt()),

  575.             static_cast<std::int16_t>(ui_.logicValueSpinBox->value())};

  576.     }

  577.     else if (std::holds_alternative<TonNodeConfig>(config))

  578.     {

  579.         config = TonNodeConfig{

  580.             TimerAddress{ui_.logicAddressSpinBox->value()},

  581.             ui_.logicPresetSpinBox->value()};

  582.     }

  583.     else

  584.     {

  585.         LogicInstructionDialog dialog(node->config, &parent_);

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

  587.         {

  588.             return;

  589.         }

  590.         config = dialog.config();

  591.     }

  592. 

  593.     const LogicEditorResult result = logic_editor_service_.updateNodeConfig(

  594.         current_logic_id_(), selected_logic_node_id_, config);

  595.     if (!result.succeeded)

  596.     {

  597.         reportFailure(QObject::tr("应用逻辑属性"), result.message);

  598.         return;

  599.     }

  600.     logic_editor_widget_->reloadLogic();

  601.     logic_editor_widget_->selectNode(selected_logic_node_id_);

  602.     showLogicNodeProperties(selected_logic_node_id_);

  603.     refresh_project_ui_();

  604.     status_reporter_(QObject::tr("逻辑节点属性已更新，节点已配置"), 3000);

  605. }

  606. 

  607. void PropertyPanelController::handleHmiEditorError(const QString &message) const

  608. {

  609.     status_reporter_(message, 5000);

  610. }

  611. 

  612. void PropertyPanelController::handleLogicEditorError(const QString &message) const

  613. {

  614.     status_reporter_(message, 5000);

  615. }

  616. 

  617. void PropertyPanelController::reportFailure(

  618.     const QString &action, const std::string &message) const

  619. {

  620.     result_reporter_(action, fromUtf8(message), false);

  621. }