Refactor ElementPropertiesEditorWidget and add EditorDelegate

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

View File

@@ -15,230 +15,284 @@
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 "exportpropertieswidget.h" #include "elementpropertieseditorwidget.h"
#include <QFileSystemModel>
#include "../../qetapp.h"
#include "../../qetinformation.h"
#include "ui_elementpropertieseditorwidget.h"
#include "../../qetinformation.h"
#include <QItemDelegate>
/** /**
@brief ExportPropertiesWidget::ExportPropertiesWidget @brief The EditorDelegate class
Constructeur This delegate is only use for disable the edition of the first
@param parent QWidget parent column of the information tree widget
*/ */
ExportPropertiesWidget::ExportPropertiesWidget(QWidget *parent) : QWidget(parent) { class EditorDelegate : public QItemDelegate
setMinimumWidth(680);
setMinimumHeight(720);
build();
setExportProperties(ExportProperties());
}
/**
@brief ExportPropertiesWidget::ExportPropertiesWidget
Constructeur
@param export_properties Parametres d'export a afficher / editer
@param parent QWidget parent
*/
ExportPropertiesWidget::ExportPropertiesWidget(const ExportProperties &export_properties, QWidget *parent) : QWidget(parent) {
build();
setExportProperties(export_properties);
}
/**
@brief ExportPropertiesWidget::~ExportPropertiesWidget
Destructeur
*/
ExportPropertiesWidget::~ExportPropertiesWidget()
{ {
} public:
EditorDelegate(QObject *parent) :
QItemDelegate(parent)
{}
/** QWidget* createEditor(QWidget *parent,
@brief ExportPropertiesWidget::exportProperties const QStyleOptionViewItem &option,
@return les parametres d'export definis via le widget const QModelIndex &index) const override
*/
ExportProperties ExportPropertiesWidget::exportProperties() const
{ {
ExportProperties export_properties; if(index.column() == 1)
{
return QItemDelegate::createEditor(parent,
option,
index);
}
return nullptr;
}
};
export_properties.destination_directory = QDir(dirpath -> text()); /**
export_properties.format = format -> itemData(format -> currentIndex()).toString(); * @brief ElementPropertiesEditorWidget::ElementPropertiesEditorWidget
export_properties.draw_grid = draw_grid -> isChecked(); * @param data
export_properties.draw_border = draw_border -> isChecked(); * @param parent
export_properties.draw_titleblock = draw_titleblock -> isChecked(); */
export_properties.draw_terminals = draw_terminals -> isChecked(); ElementPropertiesEditorWidget::ElementPropertiesEditorWidget(ElementData data, QWidget *parent) :
export_properties.draw_bg_transparent = draw_bg_transparent -> isChecked(); QDialog(parent),
export_properties.draw_colored_conductors = draw_colored_conductors -> isChecked(); ui(new Ui::ElementPropertiesEditorWidget),
export_properties.exported_area = export_border -> isChecked() ? QET::BorderArea : QET::ElementsArea; m_data(data)
{
return(export_properties); ui->setupUi(this);
setUpInterface();
upDateInterface();
} }
/** /**
@brief ExportPropertiesWidget::setExportProperties @brief ElementPropertiesEditorWidget::~ElementPropertiesEditorWidget
@param export_properties les parametres d'export a afficher / editer via le widget Default destructor
*/ */
void ExportPropertiesWidget::setExportProperties(const ExportProperties &export_properties) { ElementPropertiesEditorWidget::~ElementPropertiesEditorWidget()
dirpath -> setText(QDir::toNativeSeparators(export_properties.destination_directory.absolutePath())); {
delete ui;
}
int index = format -> findData(export_properties.format); /**
if (index == -1) index = 0; @brief ElementPropertiesEditorWidget::upDateInterface
format -> setCurrentIndex(index); Update the interface with the current value
*/
void ElementPropertiesEditorWidget::upDateInterface()
{
ui->m_base_type_cb->setCurrentIndex(
ui->m_base_type_cb->findData(
m_data.m_type));
draw_grid -> setChecked(export_properties.draw_grid); if (m_data.m_type == ElementData::Slave)
draw_border -> setChecked(export_properties.draw_border); {
draw_titleblock -> setChecked(export_properties.draw_titleblock); ui->m_state_cb->setCurrentIndex(
draw_terminals -> setChecked(export_properties.draw_terminals); ui->m_state_cb->findData(
draw_bg_transparent -> setChecked(export_properties.draw_bg_transparent); m_data.m_slave_state));
draw_colored_conductors -> setChecked(export_properties.draw_colored_conductors); 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));
if (export_properties.exported_area == QET::BorderArea) { // NEU: Checkbox und Zahlenbox für max_slaves einstellen
export_border -> setChecked(true); if (m_data.m_max_slaves == -1) {
ui->max_slaves_checkbox->setChecked(false);
ui->max_slaves_spinbox->setEnabled(false);
} else { } else {
export_elements -> setChecked(true); ui->max_slaves_checkbox->setChecked(true);
ui->max_slaves_spinbox->setEnabled(true);
ui->max_slaves_spinbox->setValue(m_data.m_max_slaves);
} }
} 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 ExportPropertiesWidget::setPrintingMode @brief ElementPropertiesEditorWidget::setUpInterface
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) { void ElementPropertiesEditorWidget::setUpInterface()
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( // Type combo box
this, ui->m_base_type_cb->addItem (tr("Simple"), ElementData::Simple);
tr("Exporter dans le dossier", "dialog title"), ui->m_base_type_cb->addItem (tr("Maître"), ElementData::Master);
dirpath -> text() ui->m_base_type_cb->addItem (tr("Esclave"), ElementData::Slave);
); ui->m_base_type_cb->addItem (tr("Renvoi de folio suivant"), ElementData::NextReport);
if (!user_dir.isEmpty()) { ui->m_base_type_cb->addItem (tr("Renvoi de folio précédent"), ElementData::PreviousReport);
dirpath -> setText(QDir::toNativeSeparators(user_dir)); 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);
// NEU: Checkbox mit der Zahlenbox verbinden (Aktivieren/Deaktivieren)
connect(ui->max_slaves_checkbox, SIGNAL(toggled(bool)), ui->max_slaves_spinbox, SLOT(setEnabled(bool)));
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 ExportPropertiesWidget::build @brief ElementPropertiesEditorWidget::populateTree
Generated the ExportPropertiesWidget ui Create QTreeWidgetItem of the tree widget and populate it
/ Cette methode construit le widget en lui-meme
*/ */
void ExportPropertiesWidget::build() void ElementPropertiesEditorWidget::populateTree()
{ {
// le dialogue est un empilement vertical d'elements const auto keys = QETInformation::elementEditorElementInfoKeys();
QVBoxLayout *vboxLayout = new QVBoxLayout(); for(const QString& key : keys)
vboxLayout -> setContentsMargins(0, 0, 0, 0); {
QTreeWidgetItem *qtwi = new QTreeWidgetItem(ui->m_tree);
/* le dialogue comprend une ligne permettant d'indiquer un chemin de dossier (hboxLayout) */ qtwi->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable);
QHBoxLayout *hboxLayout = new QHBoxLayout(); qtwi->setData(0, Qt::DisplayRole,
dirpath_label = new QLabel(tr("Dossier cible :"), this); QETInformation::translatedInfoKey(key));
dirpath = new QLineEdit(this); qtwi->setData(0, Qt::UserRole, key);
QCompleter *completer = new QCompleter(this); qtwi->setText(1, m_data.m_informations.value(key).toString());
completer -> setModel(new QFileSystemModel(completer)); // Adjust column width
dirpath -> setCompleter(completer); ui->m_tree->resizeColumnToContents(0);
button_browse = new QPushButton(tr("Parcourir"), this); }
hboxLayout -> addWidget(dirpath_label); }
hboxLayout -> addWidget(dirpath);
hboxLayout -> addWidget(button_browse); /**
hboxLayout -> addStretch(); @brief ElementPropertiesEditorWidget::on_m_buttonBox_accepted
Action on button accepted : the new information is set
vboxLayout -> addLayout(hboxLayout); */
void ElementPropertiesEditorWidget::on_m_buttonBox_accepted()
/* une ligne permettant de choisir le format (hboxLayout1) */ {
QHBoxLayout *hboxLayout1 = new QHBoxLayout(); m_data.m_type = ui->m_base_type_cb->currentData().value<ElementData::Type>();
format_label = new QLabel(tr("Format :"), this);
hboxLayout1 -> addWidget(format_label); if (m_data.m_type == ElementData::Slave)
hboxLayout1 -> addWidget(format = new QComboBox(this)); {
format -> addItem(tr("PNG (*.png)"), "PNG"); m_data.m_slave_state = ui->m_state_cb->currentData().value<ElementData::SlaveState>();
format -> addItem(tr("JPEG (*.jpg)"), "JPG"); m_data.m_slave_type = ui->m_type_cb->currentData().value<ElementData::SlaveType>();
format -> addItem(tr("Bitmap (*.bmp)"), "BMP"); m_data.m_contact_count = ui->m_number_ctc->value();
format -> addItem(tr("SVG (*.svg)"), "SVG"); }
format -> addItem(tr("DXF (*.dxf)"), "DXF"); else if (m_data.m_type == ElementData::Master) {
hboxLayout1 -> addStretch(); m_data.m_master_type = ui->m_master_type_cb->currentData().value<ElementData::MasterType>();
vboxLayout -> addLayout(hboxLayout1); // NEU: Wenn Häkchen gesetzt, speichere die Zahl, ansonsten -1 (unendlich)
if (ui->max_slaves_checkbox->isChecked()) {
/* un cadre permettant de specifier les options de l'image finale */ m_data.m_max_slaves = ui->max_slaves_spinbox->value();
QGroupBox *groupbox_options = new QGroupBox(tr("Options de rendu", "groupbox title")); } else {
QGridLayout *optionshlayout = new QGridLayout(groupbox_options); m_data.m_max_slaves = -1;
}
// Choix de la zone du schema a exporter }
exported_content_choices = new QButtonGroup(groupbox_options); else if (m_data.m_type == ElementData::Terminal)
export_border = new QRadioButton(tr("Exporter entièrement le folio"), groupbox_options); {
optionshlayout -> addWidget(export_border, 0, 0); m_data.m_terminal_type = ui->m_terminal_type_cb->currentData().value<ElementData::TerminalType>();
exported_content_choices -> addButton(export_border); m_data.m_terminal_function = ui->m_terminal_func_cb->currentData().value<ElementData::TerminalFunction>();
export_elements = new QRadioButton(tr("Exporter seulement les éléments"), groupbox_options); }
optionshlayout -> addWidget(export_elements, 0, 1);
exported_content_choices -> addButton(export_elements); for (QTreeWidgetItem *qtwi : ui->m_tree->invisibleRootItem()->takeChildren())
{
// dessiner la grille QString txt = qtwi->text(1);
draw_grid = new QCheckBox(tr("Dessiner la grille"), groupbox_options); //remove line feed and carriage return
optionshlayout -> addWidget(draw_grid, 1, 1); txt.remove("\r");
txt.remove("\n");
// dessiner le cadre
draw_border = new QCheckBox(tr("Dessiner le cadre"), groupbox_options); m_data.m_informations.addValue(qtwi->data(0, Qt::UserRole).toString(),
optionshlayout -> addWidget(draw_border, 1, 0); txt);
}
// dessiner le cartouche
draw_titleblock = new QCheckBox(tr("Dessiner le cartouche"), groupbox_options); this->close();
optionshlayout -> addWidget(draw_titleblock, 2, 0); }
// dessiner les bornes /**
draw_terminals = new QCheckBox(tr("Dessiner les bornes"), groupbox_options); @brief ElementPropertiesEditorWidget::on_m_base_type_cb_currentIndexChanged
optionshlayout -> addWidget(draw_terminals, 2, 1); @param index : Action when combo-box base type index change
*/
// conserver les couleurs des conducteurs void ElementPropertiesEditorWidget::on_m_base_type_cb_currentIndexChanged(int index)
draw_colored_conductors = new QCheckBox(tr("Conserver les couleurs des conducteurs"), groupbox_options); {
optionshlayout -> addWidget(draw_colored_conductors, 3, 0); bool slave = false , master = false, terminal = false;
// use transparent background for SVG-Export auto type_ = ui->m_base_type_cb->itemData(index).value<ElementData::Type>();
draw_bg_transparent = new QCheckBox(tr("SVG: fond transparent"), groupbox_options); if (type_ == ElementData::Slave)
optionshlayout -> addWidget(draw_bg_transparent, 3, 1); slave = true;
else if (type_ == ElementData::Master)
vboxLayout -> addWidget(groupbox_options); master = true;
else if (type_ == ElementData::Terminal)
setLayout(vboxLayout); terminal = true;
// ordre des input selectionnes avec la touche tab ui->m_slave_gb->setVisible(slave);
setTabOrder(dirpath, button_browse); ui->m_master_gb->setVisible(master);
setTabOrder(button_browse, format); ui->m_terminal_gb->setVisible(terminal);
setTabOrder(format, export_border);
setTabOrder(export_border, draw_border); #if QT_VERSION >= QT_VERSION_CHECK(5,15,0)
setTabOrder(draw_border, draw_grid); ui->tabWidget->setTabVisible(1,
setTabOrder(draw_grid, draw_titleblock); (type_ == ElementData::Simple ||
setTabOrder(draw_titleblock, draw_terminals); type_ == ElementData::Master));
setTabOrder(draw_terminals, draw_colored_conductors); #endif
setTabOrder(draw_colored_conductors, draw_bg_transparent);
updateTree();
// 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()));
} }