kotschak/qelectrotech-source-mirror
0
0
Fork 0
mirror of https://github.com/qelectrotech/qelectrotech-source-mirror.git synced 2026-03-29 05:49:57 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update masterelement.cpp for max_slaves

Browse Source 
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
1 changed files with 212 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files

417
sources/editor/ui/elementpropertieseditorwidget.cpp
View File

@@ -1,4 +1,4 @@
/* /*
Copyright 2006-2026 The QElectroTech Team Copyright 2006-2026 The QElectroTech Team
This file is part of QElectroTech. This file is part of QElectroTech.
@@ -15,263 +15,230 @@
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));
if (m_data.m_type == ElementData::Slave)
{
ui->m_state_cb->setCurrentIndex(
ui->m_state_cb->findData(
m_data.m_slave_state));
ui->m_type_cb->setCurrentIndex (
ui->m_type_cb->findData(
m_data.m_slave_type));
ui->m_number_ctc->setValue(m_data.m_contact_count);
}
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 @brief ExportPropertiesWidget::exportProperties
@return les parametres d'export definis via le widget
*/ */
void ElementPropertiesEditorWidget::setUpInterface() ExportProperties ExportPropertiesWidget::exportProperties() const
{ {
// Type combo box ExportProperties export_properties;
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 export_properties.destination_directory = QDir(dirpath -> text());
ui->m_state_cb->addItem(tr("Normalement ouvert"), ElementData::NO); export_properties.format = format -> itemData(format -> currentIndex()).toString();
ui->m_state_cb->addItem(tr("Normalement fermé"), ElementData::NC); export_properties.draw_grid = draw_grid -> isChecked();
ui->m_state_cb->addItem(tr("Inverseur"), ElementData::SW); export_properties.draw_border = draw_border -> isChecked();
ui->m_state_cb->addItem(tr("Other"), ElementData::Other); export_properties.draw_titleblock = draw_titleblock -> isChecked();
ui->m_type_cb->addItem(tr("Simple"), ElementData::SSimple); export_properties.draw_terminals = draw_terminals -> isChecked();
ui->m_type_cb->addItem(tr("Puissance"), ElementData::Power); export_properties.draw_bg_transparent = draw_bg_transparent -> isChecked();
ui->m_type_cb->addItem(tr("Temporisé travail"), ElementData::DelayOn); export_properties.draw_colored_conductors = draw_colored_conductors -> isChecked();
ui->m_type_cb->addItem(tr("Temporisé repos"), ElementData::DelayOff); export_properties.exported_area = export_border -> isChecked() ? QET::BorderArea : QET::ElementsArea;
ui->m_type_cb->addItem(tr("Temporisé travail & repos"), ElementData::delayOnOff);
//Master option return(export_properties);
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() /**
{ @brief ExportPropertiesWidget::setExportProperties
auto type_ = ui->m_base_type_cb->currentData().value<ElementData::Type>(); @param export_properties les parametres d'export a afficher / editer via le widget
*/
void ExportPropertiesWidget::setExportProperties(const ExportProperties &export_properties) {
dirpath -> setText(QDir::toNativeSeparators(export_properties.destination_directory.absolutePath()));
switch (type_) { int index = format -> findData(export_properties.format);
case ElementData::Simple: if (index == -1) index = 0;
ui->m_tree->setEnabled(true); format -> setCurrentIndex(index);
break;
case ElementData::Thumbnail: draw_grid -> setChecked(export_properties.draw_grid);
ui->m_tree->setEnabled(true); draw_border -> setChecked(export_properties.draw_border);
break; draw_titleblock -> setChecked(export_properties.draw_titleblock);
case ElementData::NextReport: draw_terminals -> setChecked(export_properties.draw_terminals);
ui->m_tree->setDisabled(true); draw_bg_transparent -> setChecked(export_properties.draw_bg_transparent);
break; draw_colored_conductors -> setChecked(export_properties.draw_colored_conductors);
case ElementData::PreviousReport:
ui->m_tree->setDisabled(true); if (export_properties.exported_area == QET::BorderArea) {
break; export_border -> setChecked(true);
case ElementData::Master: } else {
ui->m_tree->setEnabled(true); export_elements -> setChecked(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 @brief ExportPropertiesWidget::setPrintingMode
Create QTreeWidgetItem of the tree widget and populate it 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 ElementPropertiesEditorWidget::populateTree() 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()
{ {
const auto keys = QETInformation::elementEditorElementInfoKeys(); QString user_dir = QFileDialog::getExistingDirectory(
for(const QString& key : keys) this,
{ tr("Exporter dans le dossier", "dialog title"),
QTreeWidgetItem *qtwi = new QTreeWidgetItem(ui->m_tree); dirpath -> text()
qtwi->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable); );
qtwi->setData(0, Qt::DisplayRole, if (!user_dir.isEmpty()) {
QETInformation::translatedInfoKey(key)); dirpath -> setText(QDir::toNativeSeparators(user_dir));
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 @brief ExportPropertiesWidget::build
Action on button accepted : the new information is set Generated the ExportPropertiesWidget ui
/ Cette methode construit le widget en lui-meme
*/ */
void ElementPropertiesEditorWidget::on_m_buttonBox_accepted() void ExportPropertiesWidget::build()
{ {
m_data.m_type = ui->m_base_type_cb->currentData().value<ElementData::Type>(); // le dialogue est un empilement vertical d'elements
QVBoxLayout *vboxLayout = new QVBoxLayout();
vboxLayout -> setContentsMargins(0, 0, 0, 0);
if (m_data.m_type == ElementData::Slave) /* le dialogue comprend une ligne permettant d'indiquer un chemin de dossier (hboxLayout) */
{ QHBoxLayout *hboxLayout = new QHBoxLayout();
m_data.m_slave_state = ui->m_state_cb->currentData().value<ElementData::SlaveState>(); dirpath_label = new QLabel(tr("Dossier cible :"), this);
m_data.m_slave_type = ui->m_type_cb->currentData().value<ElementData::SlaveType>(); dirpath = new QLineEdit(this);
m_data.m_contact_count = ui->m_number_ctc->value(); QCompleter *completer = new QCompleter(this);
} completer -> setModel(new QFileSystemModel(completer));
else if (m_data.m_type == ElementData::Master) { dirpath -> setCompleter(completer);
m_data.m_master_type = ui->m_master_type_cb->currentData().value<ElementData::MasterType>(); button_browse = new QPushButton(tr("Parcourir"), this);
} hboxLayout -> addWidget(dirpath_label);
else if (m_data.m_type == ElementData::Terminal) hboxLayout -> addWidget(dirpath);
{ hboxLayout -> addWidget(button_browse);
m_data.m_terminal_type = ui->m_terminal_type_cb->currentData().value<ElementData::TerminalType>(); hboxLayout -> addStretch();
m_data.m_terminal_function = ui->m_terminal_func_cb->currentData().value<ElementData::TerminalFunction>();
} vboxLayout -> addLayout(hboxLayout);
for (QTreeWidgetItem *qtwi : ui->m_tree->invisibleRootItem()->takeChildren()) /* une ligne permettant de choisir le format (hboxLayout1) */
{ QHBoxLayout *hboxLayout1 = new QHBoxLayout();
QString txt = qtwi->text(1); format_label = new QLabel(tr("Format :"), this);
//remove line feed and carriage return hboxLayout1 -> addWidget(format_label);
txt.remove("\r"); hboxLayout1 -> addWidget(format = new QComboBox(this));
txt.remove("\n"); format -> addItem(tr("PNG (*.png)"), "PNG");
format -> addItem(tr("JPEG (*.jpg)"), "JPG");
m_data.m_informations.addValue(qtwi->data(0, Qt::UserRole).toString(), format -> addItem(tr("Bitmap (*.bmp)"), "BMP");
txt); format -> addItem(tr("SVG (*.svg)"), "SVG");
} format -> addItem(tr("DXF (*.dxf)"), "DXF");
hboxLayout1 -> addStretch();
this->close();
} vboxLayout -> addLayout(hboxLayout1);
/** /* un cadre permettant de specifier les options de l'image finale */
@brief ElementPropertiesEditorWidget::on_m_base_type_cb_currentIndexChanged QGroupBox *groupbox_options = new QGroupBox(tr("Options de rendu", "groupbox title"));
@param index : Action when combo-box base type index change QGridLayout *optionshlayout = new QGridLayout(groupbox_options);
*/
void ElementPropertiesEditorWidget::on_m_base_type_cb_currentIndexChanged(int index) // Choix de la zone du schema a exporter
{ exported_content_choices = new QButtonGroup(groupbox_options);
bool slave = false , master = false, terminal = false; export_border = new QRadioButton(tr("Exporter entièrement le folio"), groupbox_options);
optionshlayout -> addWidget(export_border, 0, 0);
auto type_ = ui->m_base_type_cb->itemData(index).value<ElementData::Type>(); exported_content_choices -> addButton(export_border);
if (type_ == ElementData::Slave) export_elements = new QRadioButton(tr("Exporter seulement les éléments"), groupbox_options);
slave = true; optionshlayout -> addWidget(export_elements, 0, 1);
else if (type_ == ElementData::Master) exported_content_choices -> addButton(export_elements);
master = true;
else if (type_ == ElementData::Terminal) // dessiner la grille
terminal = true; draw_grid = new QCheckBox(tr("Dessiner la grille"), groupbox_options);
optionshlayout -> addWidget(draw_grid, 1, 1);
ui->m_slave_gb->setVisible(slave);
ui->m_master_gb->setVisible(master); // dessiner le cadre
ui->m_terminal_gb->setVisible(terminal); draw_border = new QCheckBox(tr("Dessiner le cadre"), groupbox_options);
optionshlayout -> addWidget(draw_border, 1, 0);
#if QT_VERSION >= QT_VERSION_CHECK(5,15,0)
ui->tabWidget->setTabVisible(1, // dessiner le cartouche
(type_ == ElementData::Simple || draw_titleblock = new QCheckBox(tr("Dessiner le cartouche"), groupbox_options);
type_ == ElementData::Master)); optionshlayout -> addWidget(draw_titleblock, 2, 0);
#endif
// dessiner les bornes
updateTree(); 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()));
} }