/* Copyright 2006-2026 The QElectroTech Team This file is part of QElectroTech. QElectroTech is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version. QElectroTech is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with QElectroTech. If not, see . */ #include "projectconfigpages.h" #include "../autoNum/autonumschemecommand.h" #include "../autoNum/elementautonumschemecommand.h" #include "../autoNum/ui/counterwarning.h" #include "../autoNum/ui/renumberpreviewdialog.h" #include "../autoNum/numerotationcontext.h" #include "../autoNum/ui/autonumberingmanagementw.h" #include "../autoNum/ui/folioautonumbering.h" #include "../autoNum/ui/formulaautonumberingw.h" #include "../autoNum/ui/selectautonumw.h" #include "../project/projectpropertieshandler.h" #include "../qet.h" #include "../qeticons.h" #include "../qetproject.h" #include "../wiringrules.h" #include "../wiringruleswarning.h" #include "../qetgraphicsitem/element.h" #include "../diagram.h" #include "../borderpropertieswidget.h" #include "../conductorpropertieswidget.h" #include "../diagramcontextwidget.h" #include "../reportpropertiewidget.h" #include "../titleblockpropertieswidget.h" #include "../xrefpropertieswidget.h" //#include "ui_autonumberingmanagementw.h" #include #include /** Constructor @param project Project this page is editing. @param parent Parent QWidget */ ProjectConfigPage::ProjectConfigPage(QETProject *project, QWidget *parent) : ConfigPage(parent), m_project(project) { } /** Destructor */ ProjectConfigPage::~ProjectConfigPage() { } /** @return the project being edited by this page */ QETProject *ProjectConfigPage::project() const { return(m_project); } /** @brief ProjectConfigPage::setProject Set \a new_project as the project being edited by this page. @param new_project : True to read values from the project into widgets before setting them read only accordingly, false otherwise. Defaults to true. @param read_values @return the former project */ QETProject *ProjectConfigPage::setProject(QETProject *new_project, bool read_values) { if (new_project == m_project) return(m_project); QETProject *former_project = m_project; m_project = new_project; if (m_project && read_values) { readValuesFromProject(); adjustReadOnly(); } return(former_project); } /** Apply the configuration after user input */ void ProjectConfigPage::applyConf() { if (!m_project || m_project -> isReadOnly()) return; applyProjectConf(); } /** Initialize the page by calling initWidgets() and initLayout(). Also call readValuesFromProject() and adjustReadOnly() if a non-zero project has been set. Typically, you should call this function in your subclass constructor. */ void ProjectConfigPage::init() { initWidgets(); initLayout(); if (m_project) { readValuesFromProject(); adjustReadOnly(); } } //######################################################################################// /** Constructor @param project Project this page is editing. @param parent Parent QWidget */ ProjectMainConfigPage::ProjectMainConfigPage(QETProject *project, QWidget *parent) : ProjectConfigPage(project, parent) { init(); } /** Destructor */ ProjectMainConfigPage::~ProjectMainConfigPage() { } /** @return the title for this page */ QString ProjectMainConfigPage::title() const { return(tr("General", "configuration page title")); } /** @return the icon for this page */ QIcon ProjectMainConfigPage::icon() const { return(QET::Icons::Settings); } /** Apply the configuration after user input */ void ProjectMainConfigPage::applyProjectConf() { bool modified_project = false; QString new_title = title_value_ -> text(); if (m_project -> title() != new_title) { m_project -> setTitle(new_title); modified_project = true; } DiagramContext new_properties = project_variables_ -> context(); if (m_project -> projectProperties() != new_properties) { m_project -> setProjectProperties(new_properties); modified_project = true; } ProjectUsageTracker &usage_tracker = m_project -> projectPropertiesHandler().usageTracker(); if (usage_tracker.isEnabled() != usage_enabled_cb_ -> isChecked()) { usage_tracker.setEnabled(usage_enabled_cb_ -> isChecked()); modified_project = true; } const auto wire_hops = WireHops::fromString(wire_hops_cb_ -> currentData().toString()); if (m_project -> wireHops() != wire_hops) { m_project -> setWireHops(wire_hops); modified_project = true; } if (m_project -> uprightSymbolTexts() != upright_symbol_texts_cb_ -> isChecked()) { m_project -> setUprightSymbolTexts(upright_symbol_texts_cb_ -> isChecked()); modified_project = true; } //Following the application's rules stores nothing in the project WiringRules::Settings wiring_rules; if (!use_application_rules_cb_ -> isChecked()) { wiring_rules.own = true; wiring_rules.max_wires = max_wires_sb_ -> value(); wiring_rules.one_wire_per_report = one_wire_per_report_cb_ -> isChecked(); } if (m_project -> projectWiringRules() != wiring_rules) { const WiringRules::Settings before = m_project -> wiringRules(); m_project -> setWiringRules(wiring_rules); modified_project = true; if (WiringRules::masterEnabled() && WiringRules::turnsRuleOn(before, m_project -> wiringRules())) { WiringRulesWarning::show(this); } } if (modified_project) { m_project -> setModified(true); } } /** @return the project title entered by the user */ QString ProjectMainConfigPage::projectTitle() const { return(title_value_ -> text()); } /** Initialize widgets displayed by the page. */ void ProjectMainConfigPage::initWidgets() { title_label_ = new QLabel(tr("Project title :", "label when configuring")); title_value_ = new QLineEdit(); title_information_ = new QLabel(tr("This title is made available to all child sheets as %projecttitle.", "informative label")); project_variables_label_ = new QLabel( tr( "You may define below custom properties that will be made available to all sheets of the project (typically to use within title blocks).", "informative label" ) ); project_variables_label_ -> setWordWrap(true); project_variables_ = new DiagramContextWidget(); project_variables_ -> setContext(DiagramContext()); usage_label_ = new QLabel(tr("Time spent on this project:", "label when configuring")); usage_value_ = new QLabel(); usage_enabled_cb_ = new QCheckBox(tr("Track the time spent on this project (recorded locally in this file only)", "checkbox label")); usage_reset_pb_ = new QPushButton(tr("Reset", "button label")); connect(usage_reset_pb_, &QPushButton::clicked, this, &ProjectMainConfigPage::resetUsageTracker); //Hops where two conductors cross without being connected (issue #436) wire_hops_label_ = new QLabel(tr("Conductor crossings:", "label when configuring")); wire_hops_cb_ = new QComboBox(); wire_hops_cb_ -> addItem(tr("No hop", "wire crossings"), WireHops::toString(WireHops::Mode::None)); wire_hops_cb_ -> addItem(tr("Hop on horizontal conductors", "wire crossings"), WireHops::toString(WireHops::Mode::Horizontal)); wire_hops_cb_ -> addItem(tr("Hop on vertical conductors", "wire crossings"), WireHops::toString(WireHops::Mode::Vertical)); wire_hops_cb_ -> setToolTip(tr("Draws a small arc where two conductors cross without being connected. Only the " "drawing changes: no element is added and no conductor is cut.", "tooltip")); //Texts of turned symbols kept horizontal upright_symbol_texts_cb_ = new QCheckBox(tr("Keep the texts of rotated elements horizontal", "checkbox label")); upright_symbol_texts_cb_ -> setToolTip(tr("Texts drawn in an element and the names of its terminals stay readable " "when the element is rotated: their frame turns with the element, not the " "text. Uncheck to make them turn with the element, as before.", "tooltip")); //How many wires a terminal may take (discussion #1158) wiring_rules_gb_ = new QGroupBox(tr("Conductors per terminal", "group box title")); use_application_rules_cb_ = new QCheckBox(tr("Use the application settings", "checkbox label")); use_application_rules_cb_ -> setToolTip(tr("The settings in Configure QElectroTech > General apply. Untick to give this " "project its own settings, saved in the project.", "tooltip")); connect(use_application_rules_cb_, &QCheckBox::toggled, this, [this](bool use) { //Show the values that will apply: the application's, or the //application's as a starting point for the project's own if (use) { const WiringRules::Settings application = WiringRules::applicationSettings(); max_wires_sb_ -> setValue(application.max_wires); one_wire_per_report_cb_ -> setChecked(application.one_wire_per_report); } updateWiringRulesWidgets(); }); max_wires_label_ = new QLabel(tr("Maximum conductors per terminal:", "label when configuring")); max_wires_sb_ = new QSpinBox(); max_wires_sb_ -> setRange(0, 99); max_wires_sb_ -> setSpecialValueText(tr("No limit", "wires per terminal")); max_wires_sb_ -> setToolTip(tr("A new conductor that would take a terminal past this number is refused. " "Conductors already drawn are not changed. 4 means two twin ferrules, one " "on each side of the screw.", "tooltip")); one_wire_per_report_cb_ = new QCheckBox(tr("Only one conductor per sheet reference", "checkbox label")); one_wire_per_report_cb_ -> setToolTip(tr("A sheet reference is a virtual point: it takes only one conductor, the " "one that continues on the other sheet.", "tooltip")); wiring_rules_off_label_ = new QLabel(tr("These rules are turned off for every project " "(Configure QElectroTech > General).", "informative label")); wiring_rules_off_label_ -> setWordWrap(true); } /** Initialize the layout of this page. */ void ProjectMainConfigPage::initLayout() { QVBoxLayout *main_layout0 = new QVBoxLayout(); QHBoxLayout *title_layout0 = new QHBoxLayout(); title_layout0 -> addWidget(title_label_); title_layout0 -> addWidget(title_value_); main_layout0 -> addLayout(title_layout0); main_layout0 -> addWidget(title_information_); main_layout0 -> addSpacing(10); main_layout0 -> addWidget(project_variables_label_); main_layout0 -> addWidget(project_variables_); main_layout0 -> addSpacing(10); QHBoxLayout *usage_layout0 = new QHBoxLayout(); usage_layout0 -> addWidget(usage_label_); usage_layout0 -> addWidget(usage_value_); usage_layout0 -> addStretch(); usage_layout0 -> addWidget(usage_reset_pb_); main_layout0 -> addLayout(usage_layout0); main_layout0 -> addWidget(usage_enabled_cb_); main_layout0 -> addSpacing(10); QHBoxLayout *wire_hops_layout0 = new QHBoxLayout(); wire_hops_layout0 -> addWidget(wire_hops_label_); wire_hops_layout0 -> addWidget(wire_hops_cb_); wire_hops_layout0 -> addStretch(); main_layout0 -> addLayout(wire_hops_layout0); main_layout0 -> addSpacing(10); main_layout0 -> addWidget(upright_symbol_texts_cb_); main_layout0 -> addSpacing(10); QVBoxLayout *wiring_rules_layout = new QVBoxLayout(wiring_rules_gb_); wiring_rules_layout -> addWidget(use_application_rules_cb_); QHBoxLayout *max_wires_layout = new QHBoxLayout(); max_wires_layout -> addWidget(max_wires_label_); max_wires_layout -> addWidget(max_wires_sb_); max_wires_layout -> addStretch(); wiring_rules_layout -> addLayout(max_wires_layout); wiring_rules_layout -> addWidget(one_wire_per_report_cb_); wiring_rules_layout -> addWidget(wiring_rules_off_label_); main_layout0 -> addWidget(wiring_rules_gb_); setLayout(main_layout0); this -> setMinimumWidth(680); } /** Read properties from the edited project then fill widgets with them. */ void ProjectMainConfigPage::readValuesFromProject() { title_value_ -> setText(m_project -> title()); project_variables_ -> setContext(m_project -> projectProperties()); const ProjectUsageTracker &usage_tracker = m_project -> projectPropertiesHandler().usageTracker(); const qint64 total_seconds = usage_tracker.secondsSpent(); usage_value_ -> setText(tr("%1 h %2 min", "hours and minutes of time spent on a project") .arg(total_seconds / 3600) .arg((total_seconds % 3600) / 60)); usage_enabled_cb_ -> setChecked(usage_tracker.isEnabled()); const int wire_hops_index = wire_hops_cb_ -> findData(WireHops::toString(m_project -> wireHops())); wire_hops_cb_ -> setCurrentIndex(qMax(0, wire_hops_index)); upright_symbol_texts_cb_ -> setChecked(m_project -> uprightSymbolTexts()); //The rules that apply: the project's own or the application's const WiringRules::Settings wiring_rules = m_project -> wiringRules(); { const QSignalBlocker blocker(use_application_rules_cb_); use_application_rules_cb_ -> setChecked(!wiring_rules.own); } max_wires_sb_ -> setValue(wiring_rules.max_wires); one_wire_per_report_cb_ -> setChecked(wiring_rules.one_wire_per_report); updateWiringRulesWidgets(); } /** @brief ProjectMainConfigPage::updateWiringRulesWidgets Enable the wiring rule fields only when they can change something: the master switch is on and the project sets its own rules. */ void ProjectMainConfigPage::updateWiringRulesWidgets() { //The master switch wins over every project: say so rather than //let the user set a rule that does nothing. const bool master = WiringRules::masterEnabled(); const bool own = master && !use_application_rules_cb_ -> isChecked(); wiring_rules_off_label_ -> setVisible(!master); use_application_rules_cb_ -> setEnabled(master); max_wires_label_ -> setEnabled(own); max_wires_sb_ -> setEnabled(own); one_wire_per_report_cb_ -> setEnabled(own); } /** @brief ProjectMainConfigPage::resetUsageTracker Reset the accumulated "time spent on this project" counter to zero and refresh its displayed value. Applies immediately (not staged behind OK/Cancel like the other fields on this page), since it isn't destructive to any actual project content. */ void ProjectMainConfigPage::resetUsageTracker() { m_project -> projectPropertiesHandler().usageTracker().resetSecondsSpent(); m_project -> setModified(true); usage_value_ -> setText(tr("%1 h %2 min", "hours and minutes of time spent on a project").arg(0).arg(0)); } /** Set the content of this page read only if the project is read only, editable if the project is editable. */ void ProjectMainConfigPage::adjustReadOnly() { bool is_read_only = m_project -> isReadOnly(); title_value_ -> setReadOnly(is_read_only); usage_enabled_cb_ -> setDisabled(is_read_only); usage_reset_pb_ -> setDisabled(is_read_only); wire_hops_cb_ -> setDisabled(is_read_only); upright_symbol_texts_cb_ -> setDisabled(is_read_only); wiring_rules_gb_ -> setDisabled(is_read_only); } //######################################################################################// /** @brief ProjectAutoNumConfigPage::ProjectAutoNumConfigPage Default constructor @param project : project to edit @param parent : parent widget */ ProjectAutoNumConfigPage::ProjectAutoNumConfigPage (QETProject *project, QWidget *parent) : ProjectConfigPage(project, parent) { // Follow the same contract ProjectMainConfigPage's constructor does -- // init() is documented to be the thing a subclass constructor calls // (see ProjectConfigPage::init()'s doc comment). Calling the pieces // individually here used to skip both initLayout() and adjustReadOnly(), // and called readValuesFromProject() even when m_project was null. // buildConnections() itself is invoked from the end of initWidgets() // below, in the same relative position it held here. init(); } /** @brief ProjectAutoNumConfigPage::title Title of this config page @return */ QString ProjectAutoNumConfigPage::title() const { return tr("Auto Numbering"); } /** @brief ProjectAutoNumConfigPage::icon Icon of this config pafe @return */ QIcon ProjectAutoNumConfigPage::icon() const { return QIcon (QET::Icons::AutoNum); } /** @brief ProjectAutoNumConfigPage::applyProjectConf */ void ProjectAutoNumConfigPage::applyProjectConf() {} namespace { /** A tab of a numbering list over a table of the folios which follow the numbering shown */ QWidget *schemeTab(SelectAutonumW *saw, QGroupBox *&box, QTableWidget *&table) { auto *tab = new QWidget(); auto *layout = new QVBoxLayout(tab); layout->setContentsMargins(0, 0, 0, 0); layout->addWidget(saw); box = new QGroupBox(tab); auto *box_layout = new QVBoxLayout(box); table = new QTableWidget(0, 2, box); table->setHorizontalHeaderLabels({QObject::tr("Sheet"), QObject::tr("Title")}); table->setEditTriggers(QAbstractItemView::NoEditTriggers); table->setSelectionBehavior(QAbstractItemView::SelectRows); table->verticalHeader()->setVisible(false); table->horizontalHeader()->setStretchLastSection(true); table->setAlternatingRowColors(true); box_layout->addWidget(table); layout->addWidget(box, 1); return tab; } } // namespace /** @brief ProjectAutoNumConfigPage::initWidgets Init some widget of this page */ void ProjectAutoNumConfigPage::initWidgets() { QTabWidget *tab_widget = new QTabWidget(this); m_tab_widget = tab_widget; //Management tab m_amw = new AutoNumberingManagementW(project()); tab_widget->addTab(m_amw, tr("Management")); //Conductor tab m_saw_conductor = new SelectAutonumW(1); m_saw_conductor->setExplicitNaming(); tab_widget->addTab(schemeTab(m_saw_conductor, m_conductor_users_box, m_conductor_users), tr("Conductors")); //Element tab m_saw_element = new SelectAutonumW(0); m_saw_element->setExplicitNaming(); auto *element_tab = new QWidget(this); auto *element_layout = new QVBoxLayout(element_tab); element_layout->setContentsMargins(0, 0, 0, 0); element_layout->addWidget(m_saw_element); //The elements which follow the numbering shown: what an edit or a //renumbering would touch, and which of them stop it m_element_users_box = new QGroupBox(element_tab); auto *users_layout = new QVBoxLayout(m_element_users_box); m_element_users = new QTableWidget(0, 5, m_element_users_box); m_element_users->setHorizontalHeaderLabels({tr("No."), tr("Name"), tr("Sheet"), tr("Element"), tr("Frozen")}); m_element_users->setEditTriggers(QAbstractItemView::NoEditTriggers); m_element_users->setSelectionBehavior(QAbstractItemView::SelectRows); m_element_users->verticalHeader()->setVisible(false); m_element_users->horizontalHeader()->setStretchLastSection(true); m_element_users->setAlternatingRowColors(true); users_layout->addWidget(m_element_users); m_assign_number_pb = new QPushButton(tr("Assign a free number…"), m_element_users_box); m_assign_number_pb->setToolTip(tr("Give the selected element a number nobody has: it keeps its " "numbering, only its number changes.")); m_assign_number_pb->setEnabled(false); users_layout->addWidget(m_assign_number_pb, 0, Qt::AlignLeft); connect(m_assign_number_pb, &QPushButton::clicked, this, &ProjectAutoNumConfigPage::assignFreeNumber); connect(m_element_users, &QTableWidget::itemSelectionChanged, this, &ProjectAutoNumConfigPage::updateAssignNumberButton); element_layout->addWidget(m_element_users_box, 1); tab_widget->addTab(element_tab, tr("Elements")); //Folio Tab m_saw_folio = new SelectAutonumW(2); m_saw_folio->setExplicitNaming(); tab_widget->addTab(schemeTab(m_saw_folio, m_folio_users_box, m_folio_users), tr("Sheets")); //AutoNumbering Tab m_faw = new FolioAutonumberingW(project()); tab_widget->addTab(m_faw, tr("Sheet Auto Numbering")); m_import_pb = new QPushButton( tr("Import from another project..."), this); m_import_pb->setToolTip( tr("Reuse the automatic numbering saved in " "another project")); QHBoxLayout *button_layout = new QHBoxLayout(); button_layout->addStretch(); button_layout->addWidget(m_import_pb); QVBoxLayout *main_layout = new QVBoxLayout(); main_layout->addWidget(tab_widget); main_layout->addLayout(button_layout); setLayout(main_layout); buildConnections(); } /** @brief ProjectAutoNumConfigPage::readValuesFromProject Read value stored on project, and update display */ void ProjectAutoNumConfigPage::readValuesFromProject() { // This is called again after an import, so start from an empty // combo box instead of appending a second copy of every name. m_saw_conductor->contextComboBox()->clear(); m_saw_element->contextComboBox()->clear(); m_saw_folio->contextComboBox()->clear(); //Conductor Tab refreshSchemes(SchemeKind::Conductor, m_project->conductorCurrentAutoNum()); //Element Tab refreshElementSchemes(m_project->elementCurrentAutoNum()); //Folio Tab refreshSchemes(SchemeKind::Folio, QString()); //Folio AutoNumbering Tab m_faw->setContext(m_project->folioAutoNum().keys()); } /** @brief ProjectAutoNumConfigPage::adjustReadOnly set this config page disable if project is read only */ void ProjectAutoNumConfigPage::adjustReadOnly() { if (m_import_pb && m_project) { m_import_pb->setDisabled(m_project->isReadOnly()); } } /** @brief ProjectAutoNumConfigPage::buildConnections setup some connections */ void ProjectAutoNumConfigPage::buildConnections() { //Management Tab connect(m_amw, &AutoNumberingManagementW::applyPressed, this, &ProjectAutoNumConfigPage::applyManagement); //Conductor Tab connect(m_saw_conductor, &SelectAutonumW::applyPressed, this, &ProjectAutoNumConfigPage::saveContextConductor); connect(m_saw_conductor, &SelectAutonumW::removeClicked, this, &ProjectAutoNumConfigPage::removeContextConductor); connect(m_saw_conductor, &SelectAutonumW::newClicked, this, &ProjectAutoNumConfigPage::newContextConductor); connect(m_saw_conductor, &SelectAutonumW::renameClicked, this, &ProjectAutoNumConfigPage::renameContextConductor); connect(m_saw_conductor->contextComboBox(), &QComboBox::textActivated, this, &ProjectAutoNumConfigPage::updateContextConductor); //Element Tab connect(m_saw_element, &SelectAutonumW::applyPressed, this, &ProjectAutoNumConfigPage::saveContextElement); connect(m_saw_element, &SelectAutonumW::removeClicked, this, &ProjectAutoNumConfigPage::removeContextElement); connect(m_saw_element, &SelectAutonumW::newClicked, this, &ProjectAutoNumConfigPage::newContextElement); connect(m_saw_element, &SelectAutonumW::renameClicked, this, &ProjectAutoNumConfigPage::renameContextElement); connect(m_saw_element->contextComboBox(), &QComboBox::textActivated, this, &ProjectAutoNumConfigPage::updateContextElement); //Folio Tab connect(m_saw_folio, &SelectAutonumW::applyPressed, this, &ProjectAutoNumConfigPage::saveContextFolio); connect(m_saw_folio, &SelectAutonumW::removeClicked, this, &ProjectAutoNumConfigPage::removeContextFolio); connect(m_saw_folio, &SelectAutonumW::newClicked, this, &ProjectAutoNumConfigPage::newContextFolio); connect(m_saw_folio, &SelectAutonumW::renameClicked, this, &ProjectAutoNumConfigPage::renameContextFolio); connect(m_saw_folio->contextComboBox(), &QComboBox::textActivated, this, &ProjectAutoNumConfigPage::updateContextFolio); // Auto Folio Numbering connect(m_faw, &FolioAutonumberingW::applyPressed, this, &ProjectAutoNumConfigPage::applyAutoNum); //Import from another project connect(m_import_pb, &QPushButton::clicked, this, &ProjectAutoNumConfigPage::importFromProject); } /** @brief ProjectAutoNumConfigPage::updateContext_conductor Display the current selected context for conductor @param str : key of context stored in project */ void ProjectAutoNumConfigPage::updateContextConductor(const QString& str) { m_saw_conductor->setContext(AutoNumSchemeCommand::contextOf(m_project, SchemeKind::Conductor, str)); refreshSchemeUsers(SchemeKind::Conductor); } void ProjectAutoNumConfigPage::updateContextFolio(const QString& str) { m_saw_folio->setContext(AutoNumSchemeCommand::contextOf(m_project, SchemeKind::Folio, str)); refreshSchemeUsers(SchemeKind::Folio); } /** @brief ProjectAutoNumConfigPage::updateContextElement Display the current selected context for element @param str : key of context stored in project */ void ProjectAutoNumConfigPage::updateContextElement(const QString& str) { if (str.isEmpty() || !m_project->elementAutoNum().contains(str)) { m_saw_element->setContext(NumerotationContext()); } else { m_saw_element->setContext(m_project->elementAutoNum(str)); } refreshElementUsers(); } /** @brief ProjectAutoNumConfigPage::refreshElementUsers List, in folio and position order, the elements which follow the element numbering shown, with their label and whether it is frozen. */ void ProjectAutoNumConfigPage::refreshElementUsers() { if (!m_element_users || !m_element_users_box) { return; } const QString title = m_saw_element->contextComboBox()->currentText(); QVector users = m_project->elementsUsingElementAutoNum(title); std::sort(users.begin(), users.end(), [](Element *a, Element *b) { return comparPos(a, b); }); //With a single sequence of numbers the elements are listed by number, //and the numbers no element has between the lowest and the highest //are shown too: where an element was deleted or given another number using Support = ElementAutoNumSchemeCommand::NumberSupport; const Support support = m_project->elementAutoNum().contains(title) ? ElementAutoNumSchemeCommand::numberSupport(m_project->elementAutoNum().value(title)) : Support(); struct Entry { int number = 0; int to = 0; ///< the end of a range of free numbers Element *element = nullptr; }; QVector entries; QVector unnumbered; for (Element *el : std::as_const(users)) { const auto number = support.supported ? ElementAutoNumSchemeCommand::numberOf(support, el) : std::nullopt; if (support.supported && !number) { unnumbered << Entry{0, 0, el}; } else { entries << Entry{number.value_or(0), 0, el}; } } if (support.supported) { for (const auto &gap : ElementAutoNumSchemeCommand::gapRanges(m_project, title)) { entries << Entry{gap.from, gap.to, nullptr}; } std::stable_sort(entries.begin(), entries.end(), [](const Entry &a, const Entry &b) { return a.number < b.number; }); entries += unnumbered; } int frozen = 0; int gaps = 0; m_element_users->setRowCount(0); m_element_rows.clear(); for (const Entry &entry : std::as_const(entries)) { const int row = m_element_users->rowCount(); m_element_users->insertRow(row); m_element_rows << QPointer(entry.element); QStringList cells; if (entry.element) { const bool is_frozen = entry.element->isFreezeLabel(); if (is_frozen) ++frozen; const auto number = support.supported ? ElementAutoNumSchemeCommand::numberOf(support, entry.element) : std::nullopt; cells = QStringList{ number ? QString::number(*number) : QString(), entry.element->elementInformations().value(QStringLiteral("label")).toString(), entry.element->diagram() ? QString::number(entry.element->diagram()->folioIndex() + 1) : QString(), entry.element->name(), is_frozen ? tr("frozen") : QString()}; } else { ++gaps; cells = QStringList{ entry.to > entry.number ? QStringLiteral("%1 – %2").arg(entry.number).arg(entry.to) : QString::number(entry.number), tr("— free —"), QString(), tr("no element has this number (deleted or renumbered)"), QString()}; } for (int column = 0 ; column < cells.size() ; ++column) { auto *item = new QTableWidgetItem(cells.at(column)); if (!entry.element) { QFont font = item->font(); font.setItalic(true); item->setFont(font); item->setForeground(QBrush(Qt::gray)); } m_element_users->setItem(row, column, item); } } m_element_users->setColumnHidden(0, !support.supported); m_element_users->resizeColumnsToContents(); m_element_users_box->setTitle( users.isEmpty() ? tr("No element follows this numbering") : tr("%n elements follow this numbering, %1 with a frozen name", "", users.size()) .arg(frozen) + (gaps ? tr("; %n numbers without an element", "", gaps) : QString())); updateAssignNumberButton(); } /** @brief ProjectAutoNumConfigPage::updateAssignNumberButton The button which gives an element a free number needs an element row selected, in a numbering whose numbers are one sequence. */ void ProjectAutoNumConfigPage::updateAssignNumberButton() { if (!m_assign_number_pb) { return; } const int row = m_element_users->currentRow(); const Element *element = row >= 0 ? m_element_rows.value(row).data() : nullptr; const QString title = m_saw_element->contextComboBox()->currentText(); const bool supported = m_project->elementAutoNum().contains(title) && ElementAutoNumSchemeCommand::numberSupport(m_project->elementAutoNum().value(title)).supported; m_assign_number_pb->setEnabled(element && supported && !m_project->isReadOnly()); m_assign_number_pb->setToolTip( !supported ? tr("This numbering has several numbers (or one number per sheet): one " "cannot be chosen by hand.") : tr("Give the selected element a number nobody has: it keeps its " "numbering, only its number changes.")); } /** @brief ProjectAutoNumConfigPage::assignFreeNumber Give the element selected in the table a free number, chosen in the list of those which are, each with the label it would give. The element keeps following the numbering. One undo step. */ void ProjectAutoNumConfigPage::assignFreeNumber() { const int row = m_element_users->currentRow(); Element *element = row >= 0 ? m_element_rows.value(row).data() : nullptr; const QString title = m_saw_element->contextComboBox()->currentText(); const QString caption = tr("Assign a free number"); if (!element || m_project->isReadOnly()) { return; } if (element->isFreezeLabel()) { QMessageBox::information(this, caption, tr("This element's name is frozen: unfreeze it first.")); return; } const QList numbers = ElementAutoNumSchemeCommand::freeNumbers(m_project, title, element); if (numbers.isEmpty()) { QMessageBox::information(this, caption, tr("No number is free.")); return; } QStringList items; for (int n : numbers) { items << tr("%1 → %2").arg(n).arg(ElementAutoNumSchemeCommand::labelForNumber( m_project, title, element, n)); } bool ok = false; const QString chosen = QInputDialog::getItem( this, caption, tr("Free number for element “%1” (%2):") .arg(element->elementInformations().value(QStringLiteral("label")).toString(), element->name()), items, 0, false, &ok); if (!ok) { return; } QString problem; auto *cmd = ElementAutoNumSchemeCommand::assignNumber( m_project, element, numbers.at(items.indexOf(chosen)), &problem); if (!cmd) { QMessageBox::warning(this, caption, problem); return; } m_project->undoStack()->push(cmd); updateContextElement(title); // the counter may have moved; lists the elements again } /** @brief ProjectAutoNumConfigPage::refreshElementSchemes Fill the list of element numberings from the project and show @p selected, or the first one if there is no such numbering */ void ProjectAutoNumConfigPage::refreshElementSchemes(const QString &selected) { QComboBox *cb = m_saw_element->contextComboBox(); const QSignalBlocker blocker(cb); cb->clear(); QStringList titles(m_project->elementAutoNum().keys()); titles.sort(Qt::CaseInsensitive); cb->addItems(titles); const int index = cb->findText(selected); cb->setCurrentIndex(index >= 0 ? index : 0); updateContextElement(cb->currentText()); } /** @brief ProjectAutoNumConfigPage::askElementSchemeName Ask the user for the name of an element numbering until it is an acceptable one or the user gives up. @param title : title of the dialog @param name : name proposed first @param ignored_title : the numbering being renamed, if any @return the name, empty if the user cancelled */ QString ProjectAutoNumConfigPage::askElementSchemeName(const QString &title, QString name, const QString &ignored_title) { for (;;) { bool ok = false; name = QInputDialog::getText(this, title, tr("Numbering name:"), QLineEdit::Normal, name, &ok); if (!ok) { return QString(); } const QString problem = ElementAutoNumSchemeCommand::nameProblem( m_project, name, ignored_title); if (problem.isEmpty()) { return QETProject::normalizedAutoNumName(name); } QMessageBox::warning(this, title, problem); } } /** @brief ProjectAutoNumConfigPage::pushElementSchemeCommand Push @p cmd on the project's undo stack, after the user agreed when it changes the label of elements. @return true if pushed; @p cmd is deleted otherwise */ bool ProjectAutoNumConfigPage::pushElementSchemeCommand(ElementAutoNumSchemeCommand *cmd) { if (!cmd) { return false; } if (const int changed = cmd->changedElementCount()) { if (!RenumberPreviewDialog::confirm( this, tr("Modify numbering"), tr("%n elements follow this numbering and will change " "formula and name.", "", changed), cmd->changes(), {})) { delete cmd; return false; } } m_project->undoStack()->push(cmd); return true; } /** @brief ProjectAutoNumConfigPage::newContextElement Create an element numbering under a name asked to the user, with a default definition, and show it to be defined. */ void ProjectAutoNumConfigPage::newContextElement() { if (m_project->isReadOnly()) { return; } const QString name = askElementSchemeName(tr("New numbering"), QString(), QString()); if (name.isEmpty()) { return; } m_saw_element->setContext(NumerotationContext()); if (pushElementSchemeCommand(ElementAutoNumSchemeCommand::create( m_project, name, m_saw_element->toNumContext(), QUuid(), false))) { refreshElementSchemes(name); } } /** @brief ProjectAutoNumConfigPage::renameContextElement Rename the shown element numbering; the elements following it keep following it. */ void ProjectAutoNumConfigPage::renameContextElement() { const QString old_title = m_saw_element->contextComboBox()->currentText(); if (m_project->isReadOnly() || !m_project->elementAutoNum().contains(old_title)) { return; } const QString name = askElementSchemeName(tr("Rename numbering"), old_title, old_title); if (name.isEmpty() || name == old_title) { return; } if (pushElementSchemeCommand(ElementAutoNumSchemeCommand::edit( m_project, old_title, name, m_project->elementAutoNum(old_title), false))) { refreshElementSchemes(name); } } /** @brief ProjectAutoNumConfigPage::saveContextElement Save the current displayed Element formula in project */ void ProjectAutoNumConfigPage::saveContextElement() { if (m_project->isReadOnly()) { return; } const QString title = m_saw_element->contextComboBox()->currentText(); ElementAutoNumSchemeCommand *cmd = nullptr; QString shown = title; if (!m_project->elementAutoNum().contains(title)) { //No numbering yet: the definition needs a name shown = askElementSchemeName(tr("New numbering"), QString(), QString()); if (shown.isEmpty()) { return; } cmd = ElementAutoNumSchemeCommand::create( m_project, shown, m_saw_element->toNumContext()); } else { const NumerotationContext wanted = m_saw_element->toNumContext(); if (const int frozen = ElementAutoNumSchemeCommand::editBlockedBy( m_project, title, wanted).size()) { QMessageBox::warning( this, tr("Modify numbering"), tr("The “%1” numbering cannot be modified: %n elements with a " "frozen name follow it.\n" "Unfreeze them first (see the list), or just rename the " "numbering.", "", frozen).arg(title)); refreshElementSchemes(title); //Back to the definition the project has return; } //A counter put back on numbers in use: the next elements skip them if (!CounterWarning::confirm(this, m_project, title, wanted)) { refreshElementSchemes(title); //Back to the definition the project has return; } cmd = ElementAutoNumSchemeCommand::edit( m_project, title, title, wanted); } if (pushElementSchemeCommand(cmd)) { refreshElementSchemes(shown); } } /** @brief ProjectAutoNumConfigPage::importFromProject Read the automatic numbering rules stored in another .qet project and copy the ones the user selects into this project. The source file is parsed as plain XML rather than opened as a QETProject: opening it would run the whole load path, including the modal dialog raised when the file was written by a different version of QElectroTech. */ void ProjectAutoNumConfigPage::importFromProject() { if (!m_project || m_project->isReadOnly()) { return; } const QString path = QFileDialog::getOpenFileName( this, tr("Import numbering from a project"), m_project->currentDir(), tr("Project QElectroTech (*.qet)")); if (path.isEmpty()) { return; } QFile file(path); if (!file.open(QIODevice::ReadOnly)) { QMessageBox::warning(this, tr("Import not possible"), tr("Unable to open %1").arg(path)); return; } QDomDocument doc; if (!doc.setContent(&file)) { QMessageBox::warning(this, tr("Import not possible"), tr("%1 is not a valid QElectroTech project.") .arg(QFileInfo(path).fileName())); return; } file.close(); const QDomNodeList newdiagrams = doc.elementsByTagName(QStringLiteral("newdiagrams")); if (newdiagrams.isEmpty()) { QMessageBox::information(this, tr("No numbering"), tr("This project does not contain any automatic numbering.")); return; } const QDomElement root = newdiagrams.at(0).toElement(); // tag of the group, tag of one entry, label shown to the user struct Category { QString group_tag; QString item_tag; QString label; }; const QList categories { {QStringLiteral("conductors_autonums"), QStringLiteral("conductor_autonum"), tr("Conductors")}, {QStringLiteral("element_autonums"), QStringLiteral("element_autonum"), tr("Elements")}, {QStringLiteral("folio_autonums"), QStringLiteral("folio_autonum"), tr("Sheets")} }; QDialog dialog(this); dialog.setWindowTitle(tr("Numbering to import")); QVBoxLayout *layout = new QVBoxLayout(&dialog); layout->addWidget(new QLabel( tr("Numbering found in %1:") .arg(QFileInfo(path).fileName()), &dialog)); QListWidget *list = new QListWidget(&dialog); layout->addWidget(list); // NumerotationContext is not a QVariant type, so the list item // carries an index into this instead of the context itself. QList contexts; for (int i = 0 ; i < categories.count() ; ++i) { const Category &category = categories.at(i); QDomElement group; for (QDomNode n = root.firstChild() ; !n.isNull() ; n = n.nextSibling()) { if (n.toElement().tagName() == category.group_tag) { group = n.toElement(); break; } } if (group.isNull()) { continue; } for (QDomElement entry : QET::findInDomElement(group, category.item_tag)) { const QString title = entry.attribute(QStringLiteral("title")); if (title.isEmpty()) { continue; } bool exists = false; switch (i) { case 0: exists = m_project->conductorAutoNum().contains(title); break; case 1: exists = !m_project->elementAutoNumNameClash(title).isEmpty(); break; default: exists = m_project->folioAutoNum().contains(title); break; } QListWidgetItem *item = new QListWidgetItem( exists ? tr("%1: %2 (already exists)") .arg(category.label, title) : QStringLiteral("%1 : %2") .arg(category.label, title), list); item->setFlags(item->flags() | Qt::ItemIsUserCheckable); item->setCheckState(exists ? Qt::Unchecked : Qt::Checked); item->setData(Qt::UserRole, i); item->setData(Qt::UserRole + 1, title); item->setData(Qt::UserRole + 3, entry.attribute(QStringLiteral("id"))); NumerotationContext nc; nc.fromXml(entry); item->setData(Qt::UserRole + 2, contexts.count()); contexts << nc; } } if (contexts.isEmpty()) { QMessageBox::information(this, tr("No numbering"), tr("This project does not contain any automatic numbering.")); return; } QCheckBox *overwrite_cb = new QCheckBox( tr("Replace numbering with the same name"), &dialog); layout->addWidget(overwrite_cb); QDialogButtonBox *buttons = new QDialogButtonBox( QDialogButtonBox::Ok | QDialogButtonBox::Cancel, &dialog); layout->addWidget(buttons); connect(buttons, &QDialogButtonBox::accepted, &dialog, &QDialog::accept); connect(buttons, &QDialogButtonBox::rejected, &dialog, &QDialog::reject); if (dialog.exec() != QDialog::Accepted) { return; } int imported = 0, skipped = 0, conductors = 0, relabelled = 0, blocked = 0; m_project->undoStack()->beginMacro(tr("Import numberings")); for (int row = 0 ; row < list->count() ; ++row) { QListWidgetItem *item = list->item(row); if (item->checkState() != Qt::Checked) { continue; } const int category = item->data(Qt::UserRole).toInt(); const QString title = item->data(Qt::UserRole + 1).toString(); bool exists = false; switch (category) { case 0: exists = !AutoNumSchemeCommand::nameClash(m_project, SchemeKind::Conductor, title).isEmpty(); break; case 1: exists = !m_project->elementAutoNumNameClash(title).isEmpty(); break; default: exists = !AutoNumSchemeCommand::nameClash(m_project, SchemeKind::Folio, title).isEmpty(); break; } if (exists && !overwrite_cb->isChecked()) { ++skipped; continue; } const NumerotationContext &nc = contexts.at(item->data(Qt::UserRole + 2).toInt()); switch (category) { case 0: { const QString clash = AutoNumSchemeCommand::nameClash(m_project, SchemeKind::Conductor, title); auto *cmd = clash.isEmpty() ? AutoNumSchemeCommand::create(m_project, SchemeKind::Conductor, title, nc) : AutoNumSchemeCommand::edit(m_project, SchemeKind::Conductor, clash, clash, nc); if (cmd) m_project->undoStack()->push(cmd); ++conductors; break; } case 1: { //Undoable, and an existing numbering is edited, not //replaced: the elements following it follow the //imported definition. A new one keeps the id it has //in the other project when free here, so elements //pasted from there follow it too. const QString clash = m_project->elementAutoNumNameClash(title); if (!clash.isEmpty() && !ElementAutoNumSchemeCommand::editBlockedBy(m_project, clash, nc).isEmpty()) { //Elements with a frozen label follow it: kept as it is ++blocked; continue; } ElementAutoNumSchemeCommand *cmd = clash.isEmpty() ? ElementAutoNumSchemeCommand::create( m_project, title, nc, QUuid(item->data(Qt::UserRole + 3).toString()), false) : ElementAutoNumSchemeCommand::edit( m_project, clash, clash, nc, false); if (cmd) { relabelled += cmd->changedElementCount(); m_project->undoStack()->push(cmd); } break; } default: { const QString clash = AutoNumSchemeCommand::nameClash(m_project, SchemeKind::Folio, title); auto *cmd = clash.isEmpty() ? AutoNumSchemeCommand::create(m_project, SchemeKind::Folio, title, nc) : AutoNumSchemeCommand::edit(m_project, SchemeKind::Folio, clash, clash, nc); if (cmd) m_project->undoStack()->push(cmd); break; } } ++imported; } m_project->undoStack()->endMacro(); readValuesFromProject(); if (conductors) { m_project->conductorAutoNumAdded(); } QMessageBox::information( this, tr("Import complete"), (skipped ? tr("%1 numbering(s) imported, %2 " "kept unchanged.") .arg(imported).arg(skipped) : tr("%1 numbering(s) imported.").arg(imported)) + (blocked ? QStringLiteral("\n") + tr("%n numberings followed by elements with a frozen name were " "not replaced.", "", blocked) : QString()) + (relabelled ? QStringLiteral("\n") + tr("%n elements changed formula.", "", relabelled) : QString())); } /** @brief ProjectAutoNumConfigPage::removeContextElement Remove from project the current element numerotation context */ void ProjectAutoNumConfigPage::removeContextElement() { const QString title = m_saw_element->contextComboBox()->currentText(); if (m_project->isReadOnly() || !m_project->elementAutoNum().contains(title)) { return; } if (const int used = m_project->elementsUsingElementAutoNum(title).size()) { QMessageBox::information( this, tr("Delete numbering"), tr("%n elements follow the “%1” numbering, so it cannot be " "deleted.\n" "Give them another numbering or a fixed name first.", "", used) .arg(title)); return; } if (pushElementSchemeCommand(ElementAutoNumSchemeCommand::remove(m_project, title))) { refreshElementSchemes(m_project->elementCurrentAutoNum()); } } /** @brief ProjectAutoNumConfigPage::saveContext_conductor Save the current displayed conductor context in project */ void ProjectAutoNumConfigPage::saveContextConductor() { saveScheme(SchemeKind::Conductor); } /** @brief ProjectAutoNumConfigPage::saveContextFolio Apply the definition shown to the folio numbering shown */ void ProjectAutoNumConfigPage::saveContextFolio() { saveScheme(SchemeKind::Folio); } /** @brief ProjectAutoNumConfigPage::applyAutoNum Apply auto folio numbering, New Folios or Selected Folios */ void ProjectAutoNumConfigPage::applyAutoNum() { if (m_faw->newFolios){ int foliosRemaining = m_faw->newFoliosNumber(); emit (saveCurrentTbp()); emit (setAutoNum(m_faw->autoNumSelected())); while (foliosRemaining > 0){ project()->autoFolioNumberingNewFolios(); foliosRemaining = foliosRemaining-1; } emit (loadSavedTbp()); } else{ QString autoNum = m_faw->autoNumSelected(); int fromFolio = m_faw->fromFolio(); int toFolio = m_faw->toFolio(); m_project->autoFolioNumberingSelectedFolios(fromFolio,toFolio,autoNum); } } /** @brief ProjectAutoNumConfigPage::applyAutoManagement Apply Management Options in Selected Folios */ void ProjectAutoNumConfigPage::applyManagement() { // int from; // int to; // //Apply to Entire Project // if (m_amw->ui->m_apply_project_rb->isChecked()) { // from = 0; // to = project()->diagrams().size() - 1; // } // //Apply to selected Folios // else { // from = //m_amw->ui->m_from_folios_cb->itemData(m_amw->ui->m_from_folios_cb->currentIndex()).toInt(); // to = //m_amw->ui->m_to_folios_cb->itemData(m_amw->ui->m_to_folios_cb->currentIndex()).toInt(); // } // //Conductor Autonumbering Update Policy // //Allow Both Existent and New Conductors // if (m_amw->ui->m_both_conductor_rb->isChecked()) { // //Unfreeze Existent and New Conductors // project()->freezeExistentConductorLabel(false, from,to); // project()->freezeNewConductorLabel(false, from,to); // project()->setFreezeNewConductors(false); // } // //Allow Only New // else if (m_amw->ui->m_new_conductor_rb->isChecked()) { // //Freeze Existent and Unfreeze New Conductors // project()->freezeExistentConductorLabel(true, from,to); // project()->freezeNewConductorLabel(false, from,to); // project()->setFreezeNewConductors(false); // } // //Allow Only Existent // else if (m_amw->ui->m_existent_conductor_rb->isChecked()) { // //Freeze Existent and Unfreeze New Conductors // project()->freezeExistentConductorLabel(false, from,to); // project()->freezeNewConductorLabel(true, from,to); // project()->setFreezeNewConductors(true); // } // //Disable // else if (m_amw->ui->m_disable_conductor_rb->isChecked()) { // //Freeze Existent and New Elements, Set Freeze Element Project Wide // project()->freezeExistentConductorLabel(true, from,to); // project()->freezeNewConductorLabel(true, from,to); // project()->setFreezeNewConductors(true); // } // //Element Autonumbering Update Policy // //Allow Both Existent and New Elements // if (m_amw->ui->m_both_element_rb->isChecked()) { // //Unfreeze Existent and New Elements // project()->freezeExistentElementLabel(false, from,to); // project()->freezeNewElementLabel(false, from,to); // project()->setFreezeNewElements(false); // } // //Allow Only New // else if (m_amw->ui->m_new_element_rb->isChecked()) { // //Freeze Existent and Unfreeze New Elements // project()->freezeExistentElementLabel(true, from,to); // project()->freezeNewElementLabel(false, from,to); // project()->setFreezeNewElements(false); // } // //Allow Only Existent // else if (m_amw->ui->m_existent_element_rb->isChecked()) { // //Freeze New and Unfreeze Existent Elements, Set Freeze Element //Project Wide project()->freezeExistentElementLabel(false, from,to); // project()->freezeNewElementLabel(true, from,to); // project()->setFreezeNewElements(true); // } // //Disable // else if (m_amw->ui->m_disable_element_rb->isChecked()) { // //Freeze Existent and New Elements, Set Freeze Element Project Wide // project()->freezeExistentElementLabel(true, from,to); // project()->freezeNewElementLabel(true, from,to); // project()->setFreezeNewElements(true); // } // //Folio Autonumbering Status // if (m_amw->ui->m_both_folio_rb->isChecked()) { // } // else if (m_amw->ui->m_new_folio_rb->isChecked()) { // } // else if (m_amw->ui->m_existent_folio_rb->isChecked()) { // } // else if (m_amw->ui->m_disable_folio_rb->isChecked()) { // } } /** @brief ProjectAutoNumConfigPage::removeContext Remove from project the current conductor numerotation context */ void ProjectAutoNumConfigPage::removeContextConductor() { removeScheme(SchemeKind::Conductor); } /** @brief ProjectAutoNumConfigPage::removeContextFolio Remove from project the folio numerotation context shown */ void ProjectAutoNumConfigPage::removeContextFolio() { removeScheme(SchemeKind::Folio); } void ProjectAutoNumConfigPage::newContextConductor() {newScheme(SchemeKind::Conductor);} void ProjectAutoNumConfigPage::renameContextConductor() {renameScheme(SchemeKind::Conductor);} void ProjectAutoNumConfigPage::newContextFolio() {newScheme(SchemeKind::Folio);} void ProjectAutoNumConfigPage::renameContextFolio() {renameScheme(SchemeKind::Folio);} SelectAutonumW *ProjectAutoNumConfigPage::sawFor(SchemeKind kind) const { return kind == SchemeKind::Conductor ? m_saw_conductor : m_saw_folio; } /** @brief ProjectAutoNumConfigPage::refreshSchemes Fill the list of numberings of @p kind from the project and show @p selected, or the first one if there is no such numbering */ void ProjectAutoNumConfigPage::refreshSchemes(SchemeKind kind, const QString &selected) { QComboBox *cb = sawFor(kind)->contextComboBox(); { const QSignalBlocker blocker(cb); cb->clear(); cb->addItems(AutoNumSchemeCommand::titles(m_project, kind)); const int index = cb->findText(selected); cb->setCurrentIndex(index >= 0 ? index : 0); } sawFor(kind)->setContext(AutoNumSchemeCommand::contextOf(m_project, kind, cb->currentText())); refreshSchemeUsers(kind); } /** @brief ProjectAutoNumConfigPage::refreshSchemeUsers List the folios which follow the numbering of @p kind shown */ void ProjectAutoNumConfigPage::refreshSchemeUsers(SchemeKind kind) { QTableWidget *table = kind == SchemeKind::Conductor ? m_conductor_users : m_folio_users; QGroupBox *box = kind == SchemeKind::Conductor ? m_conductor_users_box : m_folio_users_box; if (!table || !box) { return; } const QString title = sawFor(kind)->contextComboBox()->currentText(); //A folio numbering is named by the title blocks it numbered, whose //folio field holds the number since: they are what is listed const QList users = AutoNumSchemeCommand::usersOf( m_project, kind, title, kind == SchemeKind::Folio); table->setRowCount(0); for (Diagram *d : users) { const int row = table->rowCount(); table->insertRow(row); table->setItem(row, 0, new QTableWidgetItem(QString::number(d->folioIndex() + 1))); table->setItem(row, 1, new QTableWidgetItem(d->border_and_titleblock.title())); } table->resizeColumnsToContents(); if (kind == SchemeKind::Folio) { box->setTitle(users.isEmpty() ? tr("No sheet names this numbering") : tr("%n sheets name this numbering", "", users.size())); } else { box->setTitle(users.isEmpty() ? tr("No sheet follows this numbering") : tr("%n sheets follow this numbering", "", users.size())); } } QString ProjectAutoNumConfigPage::askSchemeName(SchemeKind kind, const QString &title, QString name, const QString &ignored_title) { for (;;) { bool ok = false; name = QInputDialog::getText(this, title, tr("Numbering name:"), QLineEdit::Normal, name, &ok); if (!ok) { return QString(); } const QString problem = AutoNumSchemeCommand::nameProblem(m_project, kind, name, ignored_title); if (problem.isEmpty()) { return QETProject::normalizedAutoNumName(name); } QMessageBox::warning(this, title, problem); } } /** @brief ProjectAutoNumConfigPage::newScheme Create a numbering under a name asked to the user, and show it to be defined. */ void ProjectAutoNumConfigPage::newScheme(SchemeKind kind) { if (m_project->isReadOnly()) { return; } const QString name = askSchemeName(kind, tr("New numbering"), QString(), QString()); if (name.isEmpty()) { return; } sawFor(kind)->setContext(NumerotationContext()); if (auto *cmd = AutoNumSchemeCommand::create(m_project, kind, name, sawFor(kind)->toNumContext(), true)) { m_project->undoStack()->push(cmd); refreshSchemes(kind, name); } } /** @brief ProjectAutoNumConfigPage::renameScheme Rename the numbering shown; the folios which follow it follow it under its new name. */ void ProjectAutoNumConfigPage::renameScheme(SchemeKind kind) { const QString old_title = sawFor(kind)->contextComboBox()->currentText(); if (m_project->isReadOnly() || !AutoNumSchemeCommand::contains(m_project, kind, old_title)) { return; } const QString name = askSchemeName(kind, tr("Rename numbering"), old_title, old_title); if (name.isEmpty() || name == old_title) { return; } if (auto *cmd = AutoNumSchemeCommand::edit( m_project, kind, old_title, name, AutoNumSchemeCommand::contextOf(m_project, kind, old_title))) { m_project->undoStack()->push(cmd); refreshSchemes(kind, name); } } /** @brief ProjectAutoNumConfigPage::saveScheme Give the numbering shown the definition shown; with no numbering yet, create one under a name asked to the user. A conductor numbering applied becomes the one new conductors take. */ void ProjectAutoNumConfigPage::saveScheme(SchemeKind kind) { if (m_project->isReadOnly()) { return; } const QString title = sawFor(kind)->contextComboBox()->currentText(); const NumerotationContext wanted = sawFor(kind)->toNumContext(); QString shown = title; AutoNumSchemeCommand *cmd = nullptr; if (!AutoNumSchemeCommand::contains(m_project, kind, title)) { shown = askSchemeName(kind, tr("New numbering"), QString(), QString()); if (shown.isEmpty()) { return; } cmd = AutoNumSchemeCommand::create(m_project, kind, shown, wanted, true); } else { cmd = AutoNumSchemeCommand::edit(m_project, kind, title, title, wanted, true); } if (cmd) { m_project->undoStack()->push(cmd); } refreshSchemes(kind, shown); } /** @brief ProjectAutoNumConfigPage::removeScheme Remove the numbering shown, unless a folio still follows it */ void ProjectAutoNumConfigPage::removeScheme(SchemeKind kind) { const QString title = sawFor(kind)->contextComboBox()->currentText(); if (m_project->isReadOnly() || !AutoNumSchemeCommand::contains(m_project, kind, title)) { return; } if (const int used = AutoNumSchemeCommand::usersOf(m_project, kind, title).size()) { QMessageBox::information( this, tr("Delete numbering"), tr("%n sheets follow the “%1” numbering, so it cannot be deleted.\n" "Give them another numbering first.", "", used) .arg(title)); return; } if (auto *cmd = AutoNumSchemeCommand::remove(m_project, kind, title)) { m_project->undoStack()->push(cmd); refreshSchemes(kind, kind == SchemeKind::Conductor ? m_project->conductorCurrentAutoNum() : QString()); } } /** @brief ProjectAutoNumConfigPage::changeToTab @param i index Change to Selected Tab */ void ProjectAutoNumConfigPage::changeToTab(int i) { if (m_tab_widget && i >= 0 && i < m_tab_widget->count()) { m_tab_widget->setCurrentIndex(i); } }