Update masterelement.cpp for max_slaves

https://qelectrotech.org/forum/viewtopic.php?id=3101
This commit is contained in:
Kellermorph
2026-03-26 15:21:34 +01:00
committed by GitHub
parent baec0a4afb
commit 536315ebc0

View File

@@ -1,277 +1,244 @@
/* /*
Copyright 2006-2026 The QElectroTech Team Copyright 2006-2026 The QElectroTech Team
This file is part of QElectroTech. This file is part of QElectroTech.
QElectroTech is free software: you can redistribute it and/or modify QElectroTech is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or the Free Software Foundation, either version 2 of the License, or
(at your option) any later version. (at your option) any later version.
QElectroTech is distributed in the hope that it will be useful, QElectroTech is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with QElectroTech. If not, see <http://www.gnu.org/licenses/>. along with QElectroTech. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "elementpropertieseditorwidget.h" #include "exportpropertieswidget.h"
#include <QFileSystemModel>
#include "../../qetapp.h"
#include "../../qetinformation.h"
#include "ui_elementpropertieseditorwidget.h"
#include "../../qetinformation.h"
#include <QItemDelegate>
/** /**
@brief The EditorDelegate class @brief ExportPropertiesWidget::ExportPropertiesWidget
This delegate is only use for disable the edition of the first Constructeur
column of the information tree widget @param parent QWidget parent
*/ */
class EditorDelegate : public QItemDelegate ExportPropertiesWidget::ExportPropertiesWidget(QWidget *parent) : QWidget(parent) {
{ setMinimumWidth(680);
public: setMinimumHeight(720);
EditorDelegate(QObject *parent) : build();
QItemDelegate(parent) setExportProperties(ExportProperties());
{}
QWidget* createEditor(QWidget *parent,
const QStyleOptionViewItem &option,
const QModelIndex &index) const override
{
if(index.column() == 1)
{
return QItemDelegate::createEditor(parent,
option,
index);
}
return nullptr;
}
};
/**
* @brief ElementPropertiesEditorWidget::ElementPropertiesEditorWidget
* @param data
* @param parent
*/
ElementPropertiesEditorWidget::ElementPropertiesEditorWidget(ElementData data, QWidget *parent) :
QDialog(parent),
ui(new Ui::ElementPropertiesEditorWidget),
m_data(data)
{
ui->setupUi(this);
setUpInterface();
upDateInterface();
} }
/** /**
@brief ElementPropertiesEditorWidget::~ElementPropertiesEditorWidget @brief ExportPropertiesWidget::ExportPropertiesWidget
Default destructor Constructeur
@param export_properties Parametres d'export a afficher / editer
@param parent QWidget parent
*/ */
ElementPropertiesEditorWidget::~ElementPropertiesEditorWidget() ExportPropertiesWidget::ExportPropertiesWidget(const ExportProperties &export_properties, QWidget *parent) : QWidget(parent) {
{ build();
delete ui; setExportProperties(export_properties);
} }
/** /**
@brief ElementPropertiesEditorWidget::upDateInterface @brief ExportPropertiesWidget::~ExportPropertiesWidget
Update the interface with the current value Destructeur
*/ */
void ElementPropertiesEditorWidget::upDateInterface() ExportPropertiesWidget::~ExportPropertiesWidget()
{ {
ui->m_base_type_cb->setCurrentIndex( }
ui->m_base_type_cb->findData(
m_data.m_type)); /**
@brief ExportPropertiesWidget::exportProperties
@return les parametres d'export definis via le widget
*/
ExportProperties ExportPropertiesWidget::exportProperties() const
{
ExportProperties export_properties;
if (m_data.m_type == ElementData::Slave) export_properties.destination_directory = QDir(dirpath -> text());
{ export_properties.format = format -> itemData(format -> currentIndex()).toString();
ui->m_state_cb->setCurrentIndex( export_properties.draw_grid = draw_grid -> isChecked();
ui->m_state_cb->findData( export_properties.draw_border = draw_border -> isChecked();
m_data.m_slave_state)); export_properties.draw_titleblock = draw_titleblock -> isChecked();
ui->m_type_cb->setCurrentIndex ( export_properties.draw_terminals = draw_terminals -> isChecked();
ui->m_type_cb->findData( export_properties.draw_bg_transparent = draw_bg_transparent -> isChecked();
m_data.m_slave_type)); export_properties.draw_colored_conductors = draw_colored_conductors -> isChecked();
ui->m_number_ctc->setValue(m_data.m_contact_count); export_properties.exported_area = export_border -> isChecked() ? QET::BorderArea : QET::ElementsArea;
}
else if (m_data.m_type == ElementData::Master) {
ui->m_master_type_cb->setCurrentIndex(
ui->m_master_type_cb->findData (
m_data.m_master_type));
} else if (m_data.m_type == ElementData::Terminal) {
ui->m_terminal_type_cb->setCurrentIndex(
ui->m_terminal_type_cb->findData(
m_data.m_terminal_type));
ui->m_terminal_func_cb->setCurrentIndex(
ui->m_terminal_func_cb->findData(
m_data.m_terminal_function));
}
on_m_base_type_cb_currentIndexChanged(ui->m_base_type_cb->currentIndex());
}
/**
@brief ElementPropertiesEditorWidget::setUpInterface
*/
void ElementPropertiesEditorWidget::setUpInterface()
{
// Type combo box
ui->m_base_type_cb->addItem (tr("Simple"), ElementData::Simple);
ui->m_base_type_cb->addItem (tr("Maître"), ElementData::Master);
ui->m_base_type_cb->addItem (tr("Esclave"), ElementData::Slave);
ui->m_base_type_cb->addItem (tr("Renvoi de folio suivant"), ElementData::NextReport);
ui->m_base_type_cb->addItem (tr("Renvoi de folio précédent"), ElementData::PreviousReport);
ui->m_base_type_cb->addItem (tr("Bornier"), ElementData::Terminal);
ui->m_base_type_cb->addItem (tr("Vignette"), ElementData::Thumbnail);
// Slave option
ui->m_state_cb->addItem(tr("Normalement ouvert"), ElementData::NO);
ui->m_state_cb->addItem(tr("Normalement fermé"), ElementData::NC);
ui->m_state_cb->addItem(tr("Inverseur"), ElementData::SW);
ui->m_state_cb->addItem(tr("Other"), ElementData::Other);
ui->m_type_cb->addItem(tr("Simple"), ElementData::SSimple);
ui->m_type_cb->addItem(tr("Puissance"), ElementData::Power);
ui->m_type_cb->addItem(tr("Temporisé travail"), ElementData::DelayOn);
ui->m_type_cb->addItem(tr("Temporisé repos"), ElementData::DelayOff);
ui->m_type_cb->addItem(tr("Temporisé travail & repos"), ElementData::delayOnOff);
//Master option
ui->m_master_type_cb->addItem(tr("Bobine"), ElementData::Coil);
ui->m_master_type_cb->addItem(tr("Organe de protection"), ElementData::Protection);
ui->m_master_type_cb->addItem(tr("Commutateur / bouton"), ElementData::Commutator);
//Terminal option
ui->m_terminal_type_cb->addItem(tr("Générique"), ElementData::TTGeneric);
ui->m_terminal_type_cb->addItem(tr("Fusible"), ElementData::TTFuse);
ui->m_terminal_type_cb->addItem(tr("Séctionnable"), ElementData::TTSectional);
ui->m_terminal_type_cb->addItem(tr("Diode"), ElementData::TTDiode);
ui->m_terminal_type_cb->addItem(tr("Terre"), ElementData::TTGround);
ui->m_terminal_func_cb->addItem(tr("Générique"), ElementData::TFGeneric);
ui->m_terminal_func_cb->addItem(tr("Phase"), ElementData::TFPhase);
ui->m_terminal_func_cb->addItem(tr("Neutre"), ElementData::TFNeutral);
//Disable the edition of the first column of the information tree
//by this little workaround
ui->m_tree->setItemDelegate(new EditorDelegate(this));
ui->m_tree->header()->resizeSection(0, 150);
populateTree();
}
void ElementPropertiesEditorWidget::updateTree()
{
auto type_ = ui->m_base_type_cb->currentData().value<ElementData::Type>();
switch (type_) {
case ElementData::Simple:
ui->m_tree->setEnabled(true);
break;
case ElementData::Thumbnail:
ui->m_tree->setEnabled(true);
break;
case ElementData::NextReport:
ui->m_tree->setDisabled(true);
break;
case ElementData::PreviousReport:
ui->m_tree->setDisabled(true);
break;
case ElementData::Master:
ui->m_tree->setEnabled(true);
break;
case ElementData::Slave:
ui->m_tree->setDisabled(true);
break;
case ElementData::Terminal:
ui->m_tree->setEnabled(true);
break;
default:
ui->m_tree->setDisabled(true);
break;
}
}
/**
@brief ElementPropertiesEditorWidget::populateTree
Create QTreeWidgetItem of the tree widget and populate it
*/
void ElementPropertiesEditorWidget::populateTree()
{
const auto keys = QETInformation::elementEditorElementInfoKeys();
for(const QString& key : keys)
{
QTreeWidgetItem *qtwi = new QTreeWidgetItem(ui->m_tree);
qtwi->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable);
qtwi->setData(0, Qt::DisplayRole,
QETInformation::translatedInfoKey(key));
qtwi->setData(0, Qt::UserRole, key);
qtwi->setText(1, m_data.m_informations.value(key).toString());
// Adjust column width
ui->m_tree->resizeColumnToContents(0);
}
}
/**
@brief ElementPropertiesEditorWidget::on_m_buttonBox_accepted
Action on button accepted : the new information is set
*/
void ElementPropertiesEditorWidget::on_m_buttonBox_accepted()
{
m_data.m_type = ui->m_base_type_cb->currentData().value<ElementData::Type>();
if (m_data.m_type == ElementData::Slave)
{
m_data.m_slave_state = ui->m_state_cb->currentData().value<ElementData::SlaveState>();
m_data.m_slave_type = ui->m_type_cb->currentData().value<ElementData::SlaveType>();
m_data.m_contact_count = ui->m_number_ctc->value();
}
else if (m_data.m_type == ElementData::Master) {
m_data.m_master_type = ui->m_master_type_cb->currentData().value<ElementData::MasterType>();
}
else if (m_data.m_type == ElementData::Terminal)
{
m_data.m_terminal_type = ui->m_terminal_type_cb->currentData().value<ElementData::TerminalType>();
m_data.m_terminal_function = ui->m_terminal_func_cb->currentData().value<ElementData::TerminalFunction>();
}
for (QTreeWidgetItem *qtwi : ui->m_tree->invisibleRootItem()->takeChildren()) return(export_properties);
{
QString txt = qtwi->text(1);
//remove line feed and carriage return
txt.remove("\r");
txt.remove("\n");
m_data.m_informations.addValue(qtwi->data(0, Qt::UserRole).toString(),
txt);
}
this->close();
} }
/** /**
@brief ElementPropertiesEditorWidget::on_m_base_type_cb_currentIndexChanged @brief ExportPropertiesWidget::setExportProperties
@param index : Action when combo-box base type index change @param export_properties les parametres d'export a afficher / editer via le widget
*/ */
void ElementPropertiesEditorWidget::on_m_base_type_cb_currentIndexChanged(int index) void ExportPropertiesWidget::setExportProperties(const ExportProperties &export_properties) {
{ dirpath -> setText(QDir::toNativeSeparators(export_properties.destination_directory.absolutePath()));
bool slave = false , master = false, terminal = false;
int index = format -> findData(export_properties.format);
auto type_ = ui->m_base_type_cb->itemData(index).value<ElementData::Type>(); if (index == -1) index = 0;
if (type_ == ElementData::Slave) format -> setCurrentIndex(index);
slave = true;
else if (type_ == ElementData::Master) draw_grid -> setChecked(export_properties.draw_grid);
master = true; draw_border -> setChecked(export_properties.draw_border);
else if (type_ == ElementData::Terminal) draw_titleblock -> setChecked(export_properties.draw_titleblock);
terminal = true; draw_terminals -> setChecked(export_properties.draw_terminals);
draw_bg_transparent -> setChecked(export_properties.draw_bg_transparent);
ui->m_slave_gb->setVisible(slave); draw_colored_conductors -> setChecked(export_properties.draw_colored_conductors);
ui->m_master_gb->setVisible(master);
ui->m_terminal_gb->setVisible(terminal); if (export_properties.exported_area == QET::BorderArea) {
export_border -> setChecked(true);
#if QT_VERSION >= QT_VERSION_CHECK(5,15,0) } else {
ui->tabWidget->setTabVisible(1, export_elements -> setChecked(true);
(type_ == ElementData::Simple || }
type_ == ElementData::Master)); }
#endif
/**
updateTree(); @brief ExportPropertiesWidget::setPrintingMode
Puts the widget in Print or Export mode. Print mode
does not display as many options as Export mode.
/
Passe le widget en mode Impression ou en mode Export. Le mode Impression
n'affiche pas autant d'options que le mode Export.
@param mode
true to use the widget in print mode,
false to use it in export mode
/
true pour utiliser le widget en mode impression, false pour
l'utiliser en mode export
*/
void ExportPropertiesWidget::setPrintingMode(bool mode) {
dirpath_label -> setVisible(!mode);
dirpath -> setVisible(!mode);
button_browse -> setVisible(!mode);
format_label -> setVisible(!mode);
format -> setVisible(!mode);
export_border -> setVisible(!mode);
export_elements -> setVisible(!mode);
draw_bg_transparent -> setVisible(!mode);
}
/**
@brief ExportPropertiesWidget::slot_chooseADirectory
Slot asking the user to choose a folder
/ Slot demandant a l'utilisateur de choisir un dossier
*/
void ExportPropertiesWidget::slot_chooseADirectory()
{
QString user_dir = QFileDialog::getExistingDirectory(
this,
tr("Exporter dans le dossier", "dialog title"),
dirpath -> text()
);
if (!user_dir.isEmpty()) {
dirpath -> setText(QDir::toNativeSeparators(user_dir));
}
}
/**
@brief ExportPropertiesWidget::build
Generated the ExportPropertiesWidget ui
/ Cette methode construit le widget en lui-meme
*/
void ExportPropertiesWidget::build()
{
// le dialogue est un empilement vertical d'elements
QVBoxLayout *vboxLayout = new QVBoxLayout();
vboxLayout -> setContentsMargins(0, 0, 0, 0);
/* le dialogue comprend une ligne permettant d'indiquer un chemin de dossier (hboxLayout) */
QHBoxLayout *hboxLayout = new QHBoxLayout();
dirpath_label = new QLabel(tr("Dossier cible :"), this);
dirpath = new QLineEdit(this);
QCompleter *completer = new QCompleter(this);
completer -> setModel(new QFileSystemModel(completer));
dirpath -> setCompleter(completer);
button_browse = new QPushButton(tr("Parcourir"), this);
hboxLayout -> addWidget(dirpath_label);
hboxLayout -> addWidget(dirpath);
hboxLayout -> addWidget(button_browse);
hboxLayout -> addStretch();
vboxLayout -> addLayout(hboxLayout);
/* une ligne permettant de choisir le format (hboxLayout1) */
QHBoxLayout *hboxLayout1 = new QHBoxLayout();
format_label = new QLabel(tr("Format :"), this);
hboxLayout1 -> addWidget(format_label);
hboxLayout1 -> addWidget(format = new QComboBox(this));
format -> addItem(tr("PNG (*.png)"), "PNG");
format -> addItem(tr("JPEG (*.jpg)"), "JPG");
format -> addItem(tr("Bitmap (*.bmp)"), "BMP");
format -> addItem(tr("SVG (*.svg)"), "SVG");
format -> addItem(tr("DXF (*.dxf)"), "DXF");
hboxLayout1 -> addStretch();
vboxLayout -> addLayout(hboxLayout1);
/* un cadre permettant de specifier les options de l'image finale */
QGroupBox *groupbox_options = new QGroupBox(tr("Options de rendu", "groupbox title"));
QGridLayout *optionshlayout = new QGridLayout(groupbox_options);
// Choix de la zone du schema a exporter
exported_content_choices = new QButtonGroup(groupbox_options);
export_border = new QRadioButton(tr("Exporter entièrement le folio"), groupbox_options);
optionshlayout -> addWidget(export_border, 0, 0);
exported_content_choices -> addButton(export_border);
export_elements = new QRadioButton(tr("Exporter seulement les éléments"), groupbox_options);
optionshlayout -> addWidget(export_elements, 0, 1);
exported_content_choices -> addButton(export_elements);
// dessiner la grille
draw_grid = new QCheckBox(tr("Dessiner la grille"), groupbox_options);
optionshlayout -> addWidget(draw_grid, 1, 1);
// dessiner le cadre
draw_border = new QCheckBox(tr("Dessiner le cadre"), groupbox_options);
optionshlayout -> addWidget(draw_border, 1, 0);
// dessiner le cartouche
draw_titleblock = new QCheckBox(tr("Dessiner le cartouche"), groupbox_options);
optionshlayout -> addWidget(draw_titleblock, 2, 0);
// dessiner les bornes
draw_terminals = new QCheckBox(tr("Dessiner les bornes"), groupbox_options);
optionshlayout -> addWidget(draw_terminals, 2, 1);
// conserver les couleurs des conducteurs
draw_colored_conductors = new QCheckBox(tr("Conserver les couleurs des conducteurs"), groupbox_options);
optionshlayout -> addWidget(draw_colored_conductors, 3, 0);
// use transparent background for SVG-Export
draw_bg_transparent = new QCheckBox(tr("SVG: fond transparent"), groupbox_options);
optionshlayout -> addWidget(draw_bg_transparent, 3, 1);
vboxLayout -> addWidget(groupbox_options);
setLayout(vboxLayout);
// ordre des input selectionnes avec la touche tab
setTabOrder(dirpath, button_browse);
setTabOrder(button_browse, format);
setTabOrder(format, export_border);
setTabOrder(export_border, draw_border);
setTabOrder(draw_border, draw_grid);
setTabOrder(draw_grid, draw_titleblock);
setTabOrder(draw_titleblock, draw_terminals);
setTabOrder(draw_terminals, draw_colored_conductors);
setTabOrder(draw_colored_conductors, draw_bg_transparent);
// connexion du bouton permettant le choix du repertoire
connect(button_browse, SIGNAL(released()), this, SLOT(slot_chooseADirectory()));
// emission de signaux lors du changement de format et lors du changement de zone exportee
connect(format, SIGNAL(currentIndexChanged(int)), this, SIGNAL(formatChanged()));
connect(exported_content_choices, SIGNAL(buttonClicked(QAbstractButton *)), this, SIGNAL(exportedAreaChanged()));
connect(draw_grid, SIGNAL(stateChanged(int)), this, SIGNAL(optionChanged()));
connect(draw_border, SIGNAL(stateChanged(int)), this, SIGNAL(optionChanged()));
connect(draw_titleblock, SIGNAL(stateChanged(int)), this, SIGNAL(optionChanged()));
connect(draw_terminals, SIGNAL(stateChanged(int)), this, SIGNAL(optionChanged()));
connect(draw_bg_transparent, SIGNAL(stateChanged(int)), this, SIGNAL(optionChanged()));
connect(draw_colored_conductors, SIGNAL(stateChanged(int)), this, SIGNAL(optionChanged()));
} }