suyu
/
suyu_two
1
0
Креирај огранак 0
Код Дискусије 0 Захтеви за спајање 0 Издања 0 Вики Activity
综合平台编程器项目的远程存储
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
105 Комити
1 Грана
183 MiB
 
 
 
 
Дрво: 00b1035942
Гране Ознаке
${ item.name }
Create branch ${ searchTerm }
from '00b1035942'
${ noResults }
suyu_two/app/src/ui/property_panel_controller.cpp

800 lines
32 KiB
Датотека Blame Историја 

  1. #include "property_panel_controller.h"

  2. 

  3. #include "domain/hmi_control_registry.h"

  4. #include "domain/project_limits.h"

  5. #include "hmi_editor_widget.h"

  6. #include "logic_editor_widget.h"

  7. #include "logic_instruction_dialog.h"

  8. #include "services/hmi_editor_service.h"

  9. #include "services/logic_editor_service.h"

  10. #include "services/project_service.h"

  11. #include "ui_main_window.h"

  12. 

  13. #include <QApplication>

  14. #include <QCheckBox>

  15. #include <QColorDialog>

  16. #include <QComboBox>

  17. #include <QLabel>

  18. #include <QLineEdit>

  19. #include <QPushButton>

  20. #include <QDialog>

  21. #include <QObject>

  22. #include <QSpinBox>

  23. #include <QStackedWidget>

  24. #include <QWidget>

  25. 

  26. #include <algorithm>

  27. #include <cstdint>

  28. #include <utility>

  29. #include <vector>

  30. 

  31. namespace {

  32. 

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

  34. {

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

  36. }

  37. 

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

  39. {

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

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

  42. }

  43. 

  44. int defaultFontPointSize(HmiControlType type)

  45. {

  46.     int point_size = QApplication::font().pointSize();

  47.     if (type == HmiControlType::AlarmList)

  48.     {

  49.         point_size -= ProjectLimits::kAlarmDefaultFontPointReduction;

  50.     }

  51.     return std::clamp(

  52.         point_size,

  53.         ProjectLimits::kMinimumHmiFontPointSize,

  54.         ProjectLimits::kMaximumHmiFontPointSize);

  55. }

  56. 

  57. } // namespace

  58. 

  59. PropertyPanelController::PropertyPanelController(

  60.     QWidget &parent,

  61.     Ui::MainWindow &ui,

  62.     ProjectService &project_service,

  63.     HmiEditorService &hmi_editor_service,

  64.     LogicEditorService &logic_editor_service,

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

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

  67.     std::string &selected_control_id,

  68.     std::string &selected_logic_node_id,

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

  70.     ResultReporter result_reporter,

  71.     StatusReporter status_reporter)

  72.     : parent_(parent),

  73.       ui_(ui),

  74.       project_service_(project_service),

  75.       hmi_editor_service_(hmi_editor_service),

  76.       logic_editor_service_(logic_editor_service),

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

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

  79.       selected_control_id_(selected_control_id),

  80.       selected_logic_node_id_(selected_logic_node_id),

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

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

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

  84. {

  85. }

  86. 

  87. void PropertyPanelController::configure()

  88. {

  89.     ui_.pageWidthSpinBox->setRange(

  90.         ProjectLimits::kMinimumHmiPageWidth,

  91.         ProjectLimits::kMaximumHmiPageWidth);

  92.     ui_.pageHeightSpinBox->setRange(

  93.         ProjectLimits::kMinimumHmiPageHeight,

  94.         ProjectLimits::kMaximumHmiPageHeight);

  95.     ui_.fontSizeSpinBox->setRange(

  96.         ProjectLimits::kMinimumHmiFontPointSize,

  97.         ProjectLimits::kMaximumHmiFontPointSize);

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

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

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

  101.     ui_.buttonOperationComboBox->setItemData(

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

  103.     ui_.buttonOperationComboBox->setItemData(

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

  105.     ui_.buttonOperationComboBox->setItemData(

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

  107.     ui_.buttonOperationComboBox->setItemData(

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

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

  110.     {

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

  112.     }

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

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

  115.     QObject::connect(ui_.applyPagePropertiesButton, &QPushButton::clicked,

  116.             &parent_, [this] { applySelectedPageProperties(); });

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

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

  119.     QObject::connect(ui_.textColorButton, &QPushButton::clicked,

  120.             &parent_, [this] { chooseTextColor(); });

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

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

  123.     showControlProperties({});

  124. }

  125. 

  126. void PropertyPanelController::bindEditorWidgets(

  127.     HmiEditorWidget &hmi_editor_widget,

  128.     LogicEditorWidget &logic_editor_widget)

  129. {

  130.     hmi_editor_widget_ = &hmi_editor_widget;

  131.     logic_editor_widget_ = &logic_editor_widget;

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

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

  134.             {

  135.                 showControlProperties(toUtf8(id));

  136.             });

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

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

  139.             {

  140.                 showControlProperties(toUtf8(id));

  141.                 refresh_project_ui_();

  142.             });

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

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

  145.             {

  146.                 handleHmiEditorError(message);

  147.             });

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

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

  150.             {

  151.                 showLogicNodeProperties(toUtf8(id));

  152.             });

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

  154.             &parent_, [this]

  155.             {

  156.                 refresh_project_ui_();

  157.             });

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

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

  160.             {

  161.                 handleLogicEditorError(message);

  162.             });

  163. }

  164. 

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

  166. {

  167.     if (control_id.empty())

  168.     {

  169.         showPageProperties(current_page_id_());

  170.         return;

  171.     }

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

  173.     selected_control_id_ = control_id;

  174.     const HmiControl *control = hmi_editor_service_.findControl(

  175.         current_page_id_(), control_id);

  176.     const bool has_control = control != nullptr;

  177.     const HmiControlDescriptor *descriptor = has_control

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

  179.     ui_.selectionValueLabel->setText(

  180.         has_control ? fromUtf8(control->id)

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

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

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

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

  185. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  199.                             static_cast<QWidget *>(ui_.textColorEdit),

  200.                             static_cast<QWidget *>(ui_.textColorButton),

  201.                             static_cast<QWidget *>(ui_.fontSizeSpinBox),

  202.                             static_cast<QWidget *>(ui_.fontBoldCheckBox),

  203.                             static_cast<QWidget *>(ui_.fontItalicCheckBox),

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

  205.     {

  206.         widget->setEnabled(has_control);

  207.     }

  208. 

  209.     if (!has_control)

  210.     {

  211.         ui_.controlTextEdit->setMaxLength(

  212.             static_cast<int>(ProjectLimits::kMaximumHmiControlTextCharacters));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  227.         ui_.textColorEdit->clear();

  228.         ui_.textColorButton->setStyleSheet(QString{});

  229.         ui_.fontSizeSpinBox->setValue(

  230.             std::clamp(

  231.                 QApplication::font().pointSize(),

  232.                 ProjectLimits::kMinimumHmiFontPointSize,

  233.                 ProjectLimits::kMaximumHmiFontPointSize));

  234.         ui_.fontBoldCheckBox->setChecked(false);

  235.         ui_.fontItalicCheckBox->setChecked(false);

  236.         return;

  237.     }

  238. 

  239.     ui_.controlTextEdit->setMaxLength(

  240.         static_cast<int>(ProjectLimits::kMaximumHmiControlTextCharacters));

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

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

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

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

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

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

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

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

  249.     ui_.bindingIndexSpinBox->setValue(

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

  251.     const bool has_binding = descriptor != nullptr

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

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

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

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

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

  257. 

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

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

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

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

  262.     ui_.buttonOperationComboBox->setCurrentIndex(

  263.         ui_.buttonOperationComboBox->findData(

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

  265. 

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

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

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

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

  270.     ui_.targetPageComboBox->clear();

  271.     if (is_page_jump)

  272.     {

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

  274.         {

  275.             ui_.targetPageComboBox->addItem(

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

  277.         }

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

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

  280.         ui_.targetPageComboBox->setCurrentIndex(

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

  282.     }

  283. 

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

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

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

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

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

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

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

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

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

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

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

  295.         HmiProgressBarConfig{});

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

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

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

  299. 

  300.     const auto text_color = control->properties.find(

  301.         HmiAppearanceProperty::kTextColor);

  302.     ui_.textColorEdit->setText(text_color == control->properties.cend()

  303.                                    ? QString{}

  304.                                    : fromUtf8(text_color->second));

  305.     const QColor swatch_color(ui_.textColorEdit->text());

  306.     ui_.textColorButton->setStyleSheet(

  307.         swatch_color.isValid()

  308.             ? QStringLiteral("background-color: %1;").arg(

  309.                   swatch_color.name(QColor::HexRgb))

  310.             : QString{});

  311. 

  312.     const int default_font_size = defaultFontPointSize(control->type);

  313.     int font_size = default_font_size;

  314.     const auto font_size_property = control->properties.find(

  315.         HmiAppearanceProperty::kFontSize);

  316.     if (font_size_property != control->properties.cend())

  317.     {

  318.         bool ok = false;

  319.         const int parsed = fromUtf8(font_size_property->second).toInt(&ok);

  320.         if (ok)

  321.         {

  322.             font_size = parsed;

  323.         }

  324.     }

  325.     ui_.fontSizeSpinBox->setValue(std::clamp(

  326.         font_size,

  327.         ProjectLimits::kMinimumHmiFontPointSize,

  328.         ProjectLimits::kMaximumHmiFontPointSize));

  329.     const auto font_bold = control->properties.find(

  330.         HmiAppearanceProperty::kFontBold);

  331.     ui_.fontBoldCheckBox->setChecked(

  332.         font_bold != control->properties.cend() && font_bold->second == "true");

  333.     const auto font_italic = control->properties.find(

  334.         HmiAppearanceProperty::kFontItalic);

  335.     ui_.fontItalicCheckBox->setChecked(

  336.         font_italic != control->properties.cend()

  337.         && font_italic->second == "true");

  338. }

  339. 

  340. void PropertyPanelController::showPageProperties(const std::string &page_id)

  341. {

  342.     ui_.propertyStack->setCurrentWidget(ui_.pagePropertiesPage);

  343.     selected_control_id_.clear();

  344.     const HmiPage *page = hmi_editor_service_.findPage(page_id);

  345.     const bool has_page = page != nullptr;

  346.     ui_.pageWidthSpinBox->setRange(

  347.         ProjectLimits::kMinimumHmiPageWidth,

  348.         ProjectLimits::kMaximumHmiPageWidth);

  349.     ui_.pageHeightSpinBox->setRange(

  350.         ProjectLimits::kMinimumHmiPageHeight,

  351.         ProjectLimits::kMaximumHmiPageHeight);

  352.     ui_.selectionValueLabel->setText(

  353.         has_page ? fromUtf8(page->name) : QObject::tr("未选择"));

  354.     ui_.pageWidthSpinBox->setEnabled(has_page);

  355.     ui_.pageHeightSpinBox->setEnabled(has_page);

  356.     ui_.applyPagePropertiesButton->setEnabled(has_page);

  357.     if (!has_page)

  358.     {

  359.         ui_.pageWidthSpinBox->setValue(ProjectLimits::kDefaultHmiPageWidth);

  360.         ui_.pageHeightSpinBox->setValue(ProjectLimits::kDefaultHmiPageHeight);

  361.         return;

  362.     }

  363.     ui_.pageWidthSpinBox->setValue(page->width);

  364.     ui_.pageHeightSpinBox->setValue(page->height);

  365. }

  366. 

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

  368. {

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

  370.     selected_logic_node_id_ = node_id;

  371.     const LogicNode *node = logic_editor_service_.findNode(

  372.         current_logic_id_(), node_id);

  373.     const bool has_node = node != nullptr;

  374.     ui_.selectionValueLabel->setText(

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

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

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

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

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

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

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

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

  383.     {

  384.         widget->setEnabled(has_node);

  385.     }

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

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

  388.     if (!has_node)

  389.     {

  390.         ui_.logicNodeIdEdit->clear();

  391.         ui_.logicNodeTypeLabel->clear();

  392.         ui_.logicAddressAreaLabel->clear();

  393.         ui_.logicModeComboBox->clear();

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

  395.         return;

  396.     }

  397. 

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

  399.     ui_.logicModeComboBox->clear();

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

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

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

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

  404.     {

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

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

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

  408.         ui_.logicModeComboBox->addItem(

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

  410.         ui_.logicModeComboBox->addItem(

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

  412.         ui_.logicModeComboBox->setCurrentIndex(

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

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

  415.     }

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

  417.     {

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

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

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

  421.         ui_.logicModeComboBox->addItem(

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

  423.         ui_.logicModeComboBox->addItem(

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

  425.         ui_.logicModeComboBox->setCurrentIndex(

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

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

  428.     }

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

  430.     {

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

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

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

  434.         ui_.logicModeComboBox->addItem(

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

  436.         ui_.logicModeComboBox->addItem(

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

  438.         ui_.logicModeComboBox->setCurrentIndex(

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

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

  441.     }

  442.     else if (const auto *counter_contact =

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

  444.     {

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

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

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

  448.         ui_.logicModeComboBox->addItem(

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

  450.         ui_.logicModeComboBox->addItem(

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

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

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

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

  455.     }

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

  457.     {

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

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

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

  461.         ui_.logicModeComboBox->addItem(

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

  463.         ui_.logicModeComboBox->addItem(

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

  465.         ui_.logicModeComboBox->addItem(

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

  467.         ui_.logicModeComboBox->setCurrentIndex(

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

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

  470.     }

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

  472.     {

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

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

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

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

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

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

  479.         ui_.logicComparisonComboBox->setCurrentIndex(

  480.             ui_.logicComparisonComboBox->findData(

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

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

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

  484.     }

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

  486.     {

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

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

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

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

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

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

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

  494.     }

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

  496.     {

  497.         ui_.logicNodeTypeLabel->setText(

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

  499.                                              : QStringLiteral("CTD"));

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

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

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

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

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

  505.     }

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

  507.     {

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

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

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

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

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

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

  514.     }

  515.     else

  516.     {

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

  518.         ui_.logicNodeTypeLabel->setText(

  519.             arithmetic.operation == ArithmeticOperation::Add

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

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

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

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

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

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

  526.     }

  527.     if (!node->configured)

  528.     {

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

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

  531.     }

  532. }

  533. 

  534. void PropertyPanelController::addHmiControl(HmiControlType type)

  535. {

  536.     const HmiEditorResult result = hmi_editor_service_.addControl(

  537.         current_page_id_(), type);

  538.     if (!result.succeeded)

  539.     {

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

  541.         return;

  542.     }

  543.     hmi_editor_widget_->reloadPage();

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

  545.     showControlProperties(result.id);

  546.     refresh_project_ui_();

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

  548.     const QString display_name = descriptor == nullptr

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

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

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

  552. }

  553. 

  554. void PropertyPanelController::deleteSelectedControl()

  555. {

  556.     if (hmi_editor_widget_ == nullptr)

  557.     {

  558.         return;

  559.     }

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

  561.         hmi_editor_widget_->selectedControlIds();

  562.     if (selected_ids.empty())

  563.     {

  564.         return;

  565.     }

  566.     const HmiEditorResult result = hmi_editor_service_.removeControls(

  567.         current_page_id_(), selected_ids);

  568.     if (!result.succeeded)

  569.     {

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

  571.         return;

  572.     }

  573.     selected_control_id_.clear();

  574.     hmi_editor_widget_->reloadPage();

  575.     showControlProperties({});

  576.     refresh_project_ui_();

  577. }

  578. 

  579. void PropertyPanelController::applySelectedControlProperties()

  580. {

  581.     const HmiControl *old_control = hmi_editor_service_.findControl(

  582.         current_page_id_(), selected_control_id_);

  583.     if (old_control == nullptr)

  584.     {

  585.         return;

  586.     }

  587.     HmiControl control = *old_control;

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

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

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

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

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

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

  594.     const HmiControlDescriptor *descriptor =

  595.         findHmiControlDescriptor(control.type);

  596.     if (descriptor == nullptr

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

  598.     {

  599.         control.binding.reset();

  600.     }

  601.     else

  602.     {

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

  604.         if (binding_area < 0)

  605.         {

  606.             control.binding.reset();

  607.         }

  608.         else

  609.         {

  610.             const RegisterArea area = binding_area == 0

  611.                 ? RegisterArea::M : RegisterArea::D;

  612.             control.binding = RegisterAddress{

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

  614.         }

  615.     }

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

  617.     {

  618.         control.buttonOperation = static_cast<HmiButtonOperation>(

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

  620.     }

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

  622.     {

  623.         control.pageJump = HmiPageJumpConfig{

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

  625.     }

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

  627.     {

  628.         control.progressBar = HmiProgressBarConfig{

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

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

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

  632.     }

  633.     const std::string text_color = toUtf8(ui_.textColorEdit->text());

  634.     if (text_color.empty())

  635.     {

  636.         control.properties.erase(HmiAppearanceProperty::kTextColor);

  637.     }

  638.     else

  639.     {

  640.         control.properties[HmiAppearanceProperty::kTextColor] = text_color;

  641.     }

  642.     control.properties[HmiAppearanceProperty::kFontSize] = std::to_string(

  643.         ui_.fontSizeSpinBox->value());

  644.     control.properties[HmiAppearanceProperty::kFontBold] =

  645.         ui_.fontBoldCheckBox->isChecked() ? "true" : "false";

  646.     control.properties[HmiAppearanceProperty::kFontItalic] =

  647.         ui_.fontItalicCheckBox->isChecked() ? "true" : "false";

  648.     const HmiEditorResult result = hmi_editor_service_.updateControl(

  649.         current_page_id_(), selected_control_id_, control);

  650.     if (!result.succeeded)

  651.     {

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

  653.         return;

  654.     }

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

  656.     hmi_editor_widget_->reloadPage();

  657.     selected_control_id_ = updated_control_id;

  658.     hmi_editor_widget_->selectControl(updated_control_id);

  659.     showControlProperties(updated_control_id);

  660.     refresh_project_ui_();

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

  662. }

  663. 

  664. void PropertyPanelController::applySelectedPageProperties()

  665. {

  666.     const std::string page_id = current_page_id_();

  667.     if (hmi_editor_service_.findPage(page_id) == nullptr)

  668.     {

  669.         return;

  670.     }

  671.     const HmiEditorResult result = hmi_editor_service_.resizePage(

  672.         page_id,

  673.         ui_.pageWidthSpinBox->value(),

  674.         ui_.pageHeightSpinBox->value());

  675.     if (!result.succeeded)

  676.     {

  677.         reportFailure(QObject::tr("应用页面尺寸"), result.message);

  678.         return;

  679.     }

  680.     if (hmi_editor_widget_ != nullptr)

  681.     {

  682.         hmi_editor_widget_->reloadPage();

  683.     }

  684.     showPageProperties(page_id);

  685.     refresh_project_ui_();

  686.     status_reporter_(QObject::tr("页面尺寸已更新"), 3000);

  687. }

  688. 

  689. void PropertyPanelController::chooseTextColor()

  690. {

  691.     QColor initial_color(ui_.textColorEdit->text());

  692.     if (!initial_color.isValid())

  693.     {

  694.         initial_color = QColor(QStringLiteral("#24313b"));

  695.     }

  696.     const QColor color = QColorDialog::getColor(

  697.         initial_color, &parent_, QObject::tr("选择字体颜色"));

  698.     if (color.isValid())

  699.     {

  700.         ui_.textColorEdit->setText(color.name(QColor::HexRgb));

  701.         ui_.textColorButton->setStyleSheet(

  702.             QStringLiteral("background-color: %1;").arg(

  703.                 color.name(QColor::HexRgb)));

  704.     }

  705. }

  706. 

  707. void PropertyPanelController::applySelectedLogicNodeProperties()

  708. {

  709.     const LogicNode *node = logic_editor_service_.findNode(

  710.         current_logic_id_(), selected_logic_node_id_);

  711.     if (node == nullptr)

  712.     {

  713.         return;

  714.     }

  715. 

  716.     LogicNodeConfig config = node->config;

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

  718.     {

  719.         config = ContactNodeConfig{

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

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

  722.     }

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

  724.     {

  725.         config = EdgeContactNodeConfig{

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

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

  728.     }

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

  730.     {

  731.         config = TimerContactNodeConfig{

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

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

  734.     }

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

  736.     {

  737.         config = CounterContactNodeConfig{

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

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

  740.     }

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

  742.     {

  743.         config = CoilNodeConfig{

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

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

  746.     }

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

  748.     {

  749.         config = CompareNodeConfig{

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

  751.             static_cast<ComparisonOperator>(

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

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

  754.     }

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

  756.     {

  757.         config = TonNodeConfig{

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

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

  760.     }

  761.     else

  762.     {

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

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

  765.         {

  766.             return;

  767.         }

  768.         config = dialog.config();

  769.     }

  770. 

  771.     const LogicEditorResult result = logic_editor_service_.updateNodeConfig(

  772.         current_logic_id_(), selected_logic_node_id_, config);

  773.     if (!result.succeeded)

  774.     {

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

  776.         return;

  777.     }

  778.     logic_editor_widget_->reloadLogic();

  779.     logic_editor_widget_->selectNode(selected_logic_node_id_);

  780.     showLogicNodeProperties(selected_logic_node_id_);

  781.     refresh_project_ui_();

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

  783. }

  784. 

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

  786. {

  787.     status_reporter_(message, 5000);

  788. }

  789. 

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

  791. {

  792.     status_reporter_(message, 5000);

  793. }

  794. 

  795. void PropertyPanelController::reportFailure(

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

  797. {

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

  799. }