diff --git a/sources/cable/cablerenumber.cpp b/sources/cable/cablerenumber.cpp index 9e36998e6..31c6a5b4f 100644 --- a/sources/cable/cablerenumber.cpp +++ b/sources/cable/cablerenumber.cpp @@ -121,8 +121,18 @@ CableRenumberPlan CableRenumber::plan(QETProject *project, "être renumérotés."); return result; } - const QString key = project->cableCurrentAutoNum(); - if (key.isEmpty() || rule.isEmpty()) + //The rule may be one the numbering window is drawing right now + //and has not written into the project yet: the numbering writes + //it together with the numbers themselves, so the project does + //not have to hold it beforehand. What the counters are kept + //under is the name the rule is stored with, which for cables is + //fixed either way -- so numbering starts from a project which + //has no rule saved yet just as well. + QString key = project->cableCurrentAutoNum(); + if (key.isEmpty()) { + key = QETProject::cableAutoNumRuleName(); + } + if (rule.isEmpty()) { result.error = QCoreApplication::translate( "CableRenumber", diff --git a/sources/qetdiagrameditor.cpp b/sources/qetdiagrameditor.cpp index ef316fe88..5071aa5db 100644 --- a/sources/qetdiagrameditor.cpp +++ b/sources/qetdiagrameditor.cpp @@ -2331,11 +2331,20 @@ void QETDiagramEditor::selectGroupTriggered(QAction *action) bool QETDiagramEditor::cableNumberingGate(Diagram *diagram) { if (!diagram || !diagram->project()) return true; - if (diagram->project()->hasCableAutoNum()) return true; + QETProject *project = diagram->project(); + if (project->hasCableAutoNum()) return true; - QSettings settings; - const QString ask_key = QStringLiteral("cable-management/ask_numbering_rule"); - if (!settings.value(ask_key, true).toBool()) { + //A read-only project is left alone without a question: there is + //nowhere to define a rule in it, so asking whether he wants to + //would be a way to nowhere. Its cables are drawn called W, the + //same as any project without a rule. + if (project->isReadOnly()) return true; + + //Whether he has once answered no in THIS project. The answer is + //kept with the project rather than in the program settings, so + //one project being answered with no does not stop every other + //project from being asked. + if (!project->cableAskNumbering()) { return true; } @@ -2358,9 +2367,11 @@ bool QETDiagramEditor::cableNumberingGate(Diagram *diagram) box.exec(); if (box.clickedButton() == later_button) { - //For good, in the program settings: he has answered this - //once and should not be asked again at every start. - settings.setValue(ask_key, false); + //With this project only: he has answered once here and + //should not be asked again every time he picks the tool + //up in this project -- another project is free to ask. + project->setCableAskNumbering(false); + project->setModified(true); return true; } if (box.clickedButton() != define_button) { diff --git a/sources/qetproject.cpp b/sources/qetproject.cpp index 2ba2261fc..e2194a0ab 100644 --- a/sources/qetproject.cpp +++ b/sources/qetproject.cpp @@ -967,6 +967,32 @@ void QETProject::setCableXAxisFirst(bool x_axis_first) m_cable_axis_x_first = x_axis_first; } +/** + @brief QETProject::cableAskNumbering + @return true when the cable tool may still ask this project whether + a numbering rule should be defined. The answer to that question is + kept with the project rather than in the program settings, so that + one project being answered with no does not stop every other + project from asking. +*/ +bool QETProject::cableAskNumbering() const +{ + return m_cable_ask_numbering; +} + +/** + @brief QETProject::setCableAskNumbering + Take the answer he gave to the numbering question down with the + project. False means he has said no once here and is not to be + asked again in this project; taking the rule away puts it back to + true so the question comes again. + @param ask +*/ +void QETProject::setCableAskNumbering(bool ask) +{ + m_cable_ask_numbering = ask; +} + /** @brief QETProject::renumberElementsBySchemeTitle Renumber existing elements by element autonumbering scheme title. @@ -2597,6 +2623,13 @@ void QETProject::readDefaultPropertiesXml(QDomDocument &xml_project) m_cable_axis_x_first = cable_autonums.attribute( QStringLiteral("axis_priority"), QStringLiteral("x")) != QLatin1String("y"); + //Whether the numbering question was already answered with + //no in this project. A file which does not hold the answer + //yet asks again rather than staying silent: it is his own + //answer per project which is kept, not a default saying no. + m_cable_ask_numbering = cable_autonums.attribute( + QStringLiteral("ask_numbering_rule"), QStringLiteral("true")) + != QLatin1String("false"); for (auto elmt : QET::findInDomElement(cable_autonums, QStringLiteral("cable_autonum"))) { NumerotationContext nc; @@ -2865,6 +2898,12 @@ void QETProject::writeDefaultPropertiesXml(QDomElement &xml_element) cable_autonums.setAttribute("current_autonum", m_current_cable_autonum); cable_autonums.setAttribute("axis_priority", m_cable_axis_x_first ? "x" : "y"); + //Only the no is written down: a project which has not answered + //the numbering question yet asks again, so silence in the file + //means asking rather than holding back. + if (!m_cable_ask_numbering) { + cable_autonums.setAttribute("ask_numbering_rule", "false"); + } QStringList cable_autonum_keys = cableAutoNum().keys(); cable_autonum_keys.sort(); for (const QString &key : std::as_const(cable_autonum_keys)) { diff --git a/sources/qetproject.h b/sources/qetproject.h index 302226f7b..56b1fc517 100644 --- a/sources/qetproject.h +++ b/sources/qetproject.h @@ -206,6 +206,19 @@ class QETProject : public QObject */ bool cableXAxisFirst() const; void setCableXAxisFirst(bool x_axis_first); + /** + Whether the cable tool asks this project whether a + numbering rule should be defined, when he is picked up + and the project has none. Saying no in that question is + remembered with the project rather than in the program + settings, so one project saying no does not silence + every other one -- each project asks again until it + has answered for itself, and taking the rule away + brings the question back (see the cable tab of the + project properties and the numbering window). + */ + bool cableAskNumbering() const; + void setCableAskNumbering(bool ask); /** The name the single cable numbering rule is kept under. Fixed and never translated: it is a key which goes into @@ -449,6 +462,9 @@ class QETProject : public QObject QString m_current_cable_autonum; ///< which axis the cables are numbered along (see cableXAxisFirst) bool m_cable_axis_x_first = true; + ///< whether the cable tool still asks about a numbering rule + ///< for this project (see cableAskNumbering) + bool m_cable_ask_numbering = true; /// True when the loaded file had element numbering schemes /// saved without an id (written before ids existed) bool m_legacy_element_autonums = false; diff --git a/sources/ui/cablenumberingdialog.cpp b/sources/ui/cablenumberingdialog.cpp index 6c2fadb30..bdfcf93f9 100644 --- a/sources/ui/cablenumberingdialog.cpp +++ b/sources/ui/cablenumberingdialog.cpp @@ -30,7 +30,6 @@ #include #include #include -#include #include #include @@ -214,11 +213,9 @@ void CableNumberingDialog::removeRule() //No rule left, so the button which takes one away goes too. And //having just taken the rule away means numbering cables by hand //again: the question of defining one comes back the next time a - //cable is drawn, so it is not held back any more. + //cable is drawn, so it is not held back in this project any more. m_rule->setRuleRemovable(false); - QSettings settings; - settings.setValue(QStringLiteral("cable-management/ask_numbering_rule"), - true); + m_project->setCableAskNumbering(true); m_project->setModified(true); updateEnabling(); } diff --git a/sources/ui/configpage/configpages.cpp b/sources/ui/configpage/configpages.cpp index bd6c9ec7e..e4cf6421b 100644 --- a/sources/ui/configpage/configpages.cpp +++ b/sources/ui/configpage/configpages.cpp @@ -480,13 +480,11 @@ void NewDiagramPage::removeAutoNumContext(AutoNumTab &tab) //A tab which keeps one single rule has no list to delete it //from, so this is where the button of its own goes away too. //And having just taken the rule away means numbering cables by - //hand again: the question of defining one comes back the next - //time a cable is drawn, so it is not held back any more. + //hand again: every project of its own asks once more whether + //one should be defined -- that answer is kept per project, so + //there is nothing to take back here. if (!tab.fixed_name.isEmpty()) { tab.widget->setRuleRemovable(false); - QSettings settings; - settings.setValue(QStringLiteral("cable-management/ask_numbering_rule"), - true); } } diff --git a/sources/ui/configpage/projectconfigpages.cpp b/sources/ui/configpage/projectconfigpages.cpp index ed4ed3ac9..927e345f6 100644 --- a/sources/ui/configpage/projectconfigpages.cpp +++ b/sources/ui/configpage/projectconfigpages.cpp @@ -41,8 +41,6 @@ #include "../titleblockpropertieswidget.h" #include "../xrefpropertieswidget.h" -#include - //#include "ui_autonumberingmanagementw.h" #include @@ -1141,11 +1139,9 @@ void ProjectAutoNumConfigPage::removeContextCable() //No rule left, so the button which takes one away goes too. And //having just taken the rule away means numbering cables by hand //again: the question of defining one comes back the next time a - //cable is drawn, so it is not held back any more. + //cable is drawn, so it is not held back in this project any more. m_saw_cable->setRuleRemovable(false); - QSettings settings; - settings.setValue(QStringLiteral("cable-management/ask_numbering_rule"), - true); + m_project->setCableAskNumbering(true); m_project->setModified(true); }