Add cable management: drawing, cores, numbering, cross-references and cable list

Cables are drawn line objects (toolbar button next to the auto
break/reconnect button, click-move-click, right click cancels), not
components. The type comes from a CSV catalog following the material
list pattern (designation, cores, core colours, editable through the
entry dialog with "Nouvelle entrée" / "Modifier l'entrée").

Each core is bound to the wire its colour label stands on, and the
cable reference is generated per core and written into the Conductor
entry via Conductor::setCableReference(label, cable uuid, slot). The
conductor entry is where it has to live because the terminal strip
plan (Klemmenplan) consumes it in the next step.

Numbering: "Cables" rule under Programmeinstellungen/Neues
Projekt/Nummerierung auto (mirrored in project properties), literal
"W" fallback without a rule, French gate dialog when no rule exists,
Nummerierung menu with the renumber dialog (preferred axis, per-folio
counter, rule and counter state written back, hand-typed names ask,
whole-project scope).

Also included: label block and under-line texts with per-text font and
alignment plus the material-list cell margins, free-core placement and
right-click removal, claim questions for wires of other cables,
multi-selection drag as one undo step, type change with confirmation,
cross-references for type "Cable" (%f-%l%c, own font, clickable links
in exported PDFs), report propagation of the cable definition,
Listes menu (table of contents, material list, terminal strip manager,
terminal generator plugin, cable list), cable list with freely
selectable columns (installation/localisation of cable, start and end,
Blatt start/end, length, used cores...), CSV export dialog with column
pick and preview in the Projekt menu, script API (addTable kind
"cable_list", exportCableList) and a unit test for the type catalog.

sources/autoNum/assignvariables.cpp

@@ -642,6 +642,74 @@ namespace autonum
 		}
 	}
 
+	/**
+		@brief resetFolioCounters
+		@param nc the rule to read
+		@return the same rule, with the parts whose counter belongs to a
+		single folio put back to the beginning that folio is numbered
+		from -- the initial value the rule carries for it -- while the
+		parts counting over the whole project are left alone
+	*/
+	NumerotationContext resetFolioCounters(const NumerotationContext &nc)
+	{
+		NumerotationContext out = nc;
+		for (int i = 0; i < out.size(); ++i)
+		{
+			const QStringList parts = out.itemAt(i);
+			if (parts.isEmpty()) continue;
+
+			const QString &type = parts.at(0);
+			if (type == QLatin1String("unitfolio")
+					|| type == QLatin1String("tenfolio")
+					|| type == QLatin1String("hundredfolio"))
+			{
+					//The beginning a folio is numbered from is the one
+					//written into the rule, never a hard 1: a counter
+					//starting at 5 starts every folio at 5.
+				const bool has_start = parts.size() > 3
+						&& !parts.at(3).isEmpty();
+				out.replaceValue(i, has_start ? parts.at(3)
+											  : QStringLiteral("1"));
+			}
+		}
+		return out;
+	}
+
+	/**
+		@brief resetContextCounters
+		@param nc the rule to read
+		@return the same rule, with every part which counts set back to
+		the value it started from
+	*/
+	NumerotationContext resetContextCounters(const NumerotationContext &nc)
+	{
+		NumerotationContext out = resetFolioCounters(nc);
+		for (int i = 0; i < out.size(); ++i)
+		{
+			const QStringList parts = out.itemAt(i);
+			if (parts.isEmpty()) continue;
+
+			const QString &type = parts.at(0);
+			if (type == QLatin1String("unit")
+					|| type == QLatin1String("ten")
+					|| type == QLatin1String("hundred"))
+			{
+				out.replaceValue(i, QStringLiteral("1"));
+			}
+			else if (type == QLatin1String("wrap"))
+			{
+					//A cyclic part walks over [0, modulus), so it goes
+					//back to 0 rather than to 1
+				out.replaceValue(i, QStringLiteral("0"));
+			}
+			else if (type == QLatin1String("alpha"))
+			{
+				out.replaceValue(i, QStringLiteral("a"));
+			}
+		}
+		return out;
+	}
+
 	/**
 		@brief numerotationContextToFormula
 		@param nc

sources/autoNum/assignvariables.h

@@ -117,6 +117,31 @@ namespace autonum
 	void setFolioSequentialToHash(QStringList &list, QHash<QString, QStringList> &hash, const QString& autoNumName);
 	void setSequential(const QString& label, autonum::sequentialNumbers &seqStruct, NumerotationContext &context, Diagram *diagram, const QString& hashKey);
 	QString numerotationContextToFormula(const NumerotationContext &nc);
+	/**
+		Put back every part of a numbering rule whose counter belongs to
+		one single folio -- "Chiffre 1 - Folio" and its two longer forms
+		-- to the beginning that folio is numbered from, which is the
+		initial value written into the rule itself. The parts which count
+		over the whole project are left exactly as they are: a folio
+		starts again, the project does not.
+		@param nc the rule to read
+		@return the same rule, with its folio-bound counters restarted
+	*/
+	NumerotationContext resetFolioCounters(const NumerotationContext &nc);
+	/**
+		Set every part of a numbering rule which counts back to its very
+		first value, so that numbering starts at the beginning again --
+		which is what numbering a whole project over has to do, whatever
+		the last number handed out happened to be. A part which counts
+		from an initial value of its own goes back to that value, a plain
+		number goes back to 1, a cyclic one to 0 and an alphabetic one to
+		"a". The parts which do not count -- a fixed text, the number of
+		the folio, the plant -- are left exactly as they are: they say
+		what a number is made of, they are not the part which goes on.
+		@param nc the rule to read
+		@return the same rule, with its counters at their beginning
+	*/
+	NumerotationContext resetContextCounters(const NumerotationContext &nc);
 	QString elementPrefixForLocation(const ElementsLocation &location);
 }
 

sources/autoNum/ui/numparteditorw.cpp

@@ -105,6 +105,16 @@ NumPartEditorW::NumPartEditorW (NumerotationContext &context,
 		if (strl.at(0)=="wrap" && strl.size() > 4)
 			ui -> modulus_spinBox -> setValue(strl.at(4).toInt());
 		ui -> format_le -> setText(NumerotationContext::formatOf(strl));
+			//A counter bound to the folio keeps the start it was
+			//configured with: value_field shows the live counter, and
+			//writing that back as the start would make every folio
+			//begin at the last number the previous numbering gave out
+		if ((strl.at(0)==QLatin1String("unitfolio")
+			 || strl.at(0)==QLatin1String("tenfolio")
+			 || strl.at(0)==QLatin1String("hundredfolio"))
+			 && strl.size() > 3 && !strl.at(3).isEmpty()) {
+			m_initial_value = strl.at(3).toInt();
+		}
 	}
 }
 
@@ -131,8 +141,12 @@ void NumPartEditorW::setVisibleItems()
 			<< tr("Alphabétique")
 			<< tr("Texte");
 	}
-	else if (m_edited_type == 1)
+	else if (m_edited_type == 1 || m_edited_type == 3)
 	{
+			//Type 3 is a cable: it is drawn along a folio just like a
+			//conductor is, so it takes the same kinds of variable and
+			//none of the ones an element has and a cable has not (its
+			//line, its column, its prefix).
 		items	<< tr("Chiffre 1")
 			<< tr("Chiffre 1 - Folio")
 			<< tr("Chiffre 01")
@@ -232,7 +246,8 @@ NumerotationContext NumPartEditorW::toNumContext()
 		nc.addValue(type_str,
 			    ui -> value_field -> displayText(),
 			    ui -> increase_spinBox -> value(),
-			    ui->value_field->displayText().toInt(),
+			    m_initial_value >= 0 ? m_initial_value
+					 : ui->value_field->displayText().toInt(),
 			    0,
 			    number_format);
 	else if (type_str == "wrap")
@@ -315,6 +330,10 @@ void NumPartEditorW::on_type_cb_activated(int) {
 */
 void NumPartEditorW::on_value_field_textEdited()
 {
+		//What the user types in is a deliberate start for a counter
+		//bound to the folio; merely showing the live counter (as
+		//setContext() does) never changes the start.
+	m_initial_value = ui -> value_field -> text().toInt();
 	emit changed();
 }
 

sources/autoNum/ui/numparteditorw.h

@@ -77,6 +77,14 @@ class NumPartEditorW : public QWidget
 		QValidator *intValidator;
 		QValidator *alphaValidator;
 		int m_edited_type = -1; ///<0 == element : 1 == conductor : 2 == folio
+			/**
+				The value a counter bound to the folio counts each folio
+				from (-1 while the row carries none): value_field shows
+				the live counter, which numbering a project over leaves
+				at the last number given out, so the start has to be
+				kept apart from what is on show.
+			*/
+		int m_initial_value = -1;
 	
 
 

sources/autoNum/ui/selectautonumw.cpp

@@ -25,6 +25,7 @@
 #include "ui_selectautonumw.h"
 
 #include <QMessageBox>
+#include <QPushButton>
 
 /**
 	@brief SelectAutonumW::SelectAutonumW
@@ -112,7 +113,11 @@ void SelectAutonumW::setContext(const NumerotationContext &context)
 	else {
 		for (int i=0; i<m_context.size(); ++i) { //build with the content of @context
 			NumPartEditorW *part= new NumPartEditorW(m_context, i, m_edited_type, this);
-			connect(part, &NumPartEditorW::changed, this, [this]() { applyEnable(); });
+			connect(part, &NumPartEditorW::changed, this, [this]() {
+				m_dirty = true;
+				applyEnable();
+				emit contextEdited();
+			});
 			num_part_list_ << part;
 			ui -> editor_layout -> addWidget(part);
 		}
@@ -123,6 +128,9 @@ void SelectAutonumW::setContext(const NumerotationContext &context)
 				ui -> remove_button -> setEnabled (true);
 
 	applyEnable(false);
+		//Everything the rule held before is read now, so nothing of it
+		//is left to write: what is on show is what there is.
+	m_dirty = false;
 }
 
 /**
@@ -144,11 +152,17 @@ NumerotationContext SelectAutonumW::toNumContext() const
 void SelectAutonumW::on_add_button_clicked()
 {
 	applyEnable(false);
+	m_dirty = true;
 	NumPartEditorW *part = new NumPartEditorW(m_edited_type, this);
-	connect(part, &NumPartEditorW::changed, this, [this]() { applyEnable(); });
+	connect(part, &NumPartEditorW::changed, this, [this]() {
+		m_dirty = true;
+		applyEnable();
+		emit contextEdited();
+	});
 	num_part_list_ << part;
 	ui -> editor_layout -> addWidget(part);
 	ui -> remove_button -> setEnabled(true);
+	emit contextEdited();
 }
 
 /**
@@ -159,6 +173,7 @@ void SelectAutonumW::on_remove_button_clicked()
 {
 	//remove if @num_part_list contains more than one item
 	if (num_part_list_.size() > 1) {
+		m_dirty = true;
 		NumPartEditorW *part = num_part_list_.takeLast();
 		// deliberately not disconnecting as not possible to resolve with lambda and will happen automatically when the object "part" is destroyed.
 		delete part;
@@ -167,6 +182,7 @@ void SelectAutonumW::on_remove_button_clicked()
 		}
 	}
 	applyEnable();
+	emit contextEdited();
 }
 
 /**
@@ -188,6 +204,78 @@ QComboBox *SelectAutonumW::contextComboBox() const
 	return ui->m_comboBox;
 }
 
+/**
+	@brief SelectAutonumW::setSingleRuleMode
+	@param single true to show this editor as the one and only rule of
+	its kind.
+
+	The row which lists the available numberings -- its label, its combo
+	box and the button which deletes one -- is hidden, so there is
+	nothing to name a rule with and nothing to choose between: the rule
+	being edited is all there is. The combo box itself stays where it is
+	and keeps holding the rule's name, so everything which reads or
+	writes the rule through contextComboBox() carries on untouched; he
+	just cannot see it.
+*/
+void SelectAutonumW::setSingleRuleMode(bool single)
+{
+	m_single_rule = single;
+	ui->label->setVisible(!single);
+	ui->m_comboBox->setVisible(!single);
+	ui->m_remove_pb->setVisible(!single);
+
+		//A single rule has no list to be deleted from, so it needs a
+		//button of its own to get out of the numbering again. It is
+		//only shown when there is really a rule to take away -- see
+		//setRuleRemovable.
+	if (single && !m_rule_remove_pb) {
+		m_rule_remove_pb = new QPushButton(tr("Supprimer la règle"), this);
+		m_rule_remove_pb->setToolTip(tr(
+			"Supprimer la règle de numérotation des câbles : les câbles "
+			"sont à nouveau numérotés comme avant, et la question d'en "
+			"définir une revient au prochain dessin."));
+		m_rule_remove_pb->setObjectName(QStringLiteral("m_rule_remove_pb"));
+		if (ui->m_definition_groupe && ui->m_definition_groupe->layout()) {
+			ui->m_definition_groupe->layout()->addWidget(m_rule_remove_pb);
+		}
+		connect(m_rule_remove_pb, &QPushButton::clicked,
+				this, &SelectAutonumW::removeClicked);
+	}
+	if (m_rule_remove_pb) {
+		m_rule_remove_pb->setVisible(m_single_rule && m_rule_removable);
+	}
+}
+
+/**
+	@brief SelectAutonumW::setRuleRemovable
+	Whether the button which takes the whole rule away is worth showing:
+	it has nothing to do while this editor holds no rule at all, and it
+	would only be a button which does nothing.
+	@param can_remove true when a rule is there to be taken away
+*/
+void SelectAutonumW::setRuleRemovable(bool can_remove)
+{
+	m_rule_removable = can_remove;
+	if (m_rule_remove_pb) {
+		m_rule_remove_pb->setVisible(m_single_rule && can_remove);
+	}
+}
+
+/**
+	@brief SelectAutonumW::isValid
+	@return true when there is at least one variable in the editor and
+	every one of them holds what it needs. An editor which has only just
+	been opened holds an empty rule, and an empty rule is not one.
+*/
+bool SelectAutonumW::isValid()
+{
+	if (num_part_list_.isEmpty()) return false;
+	for (NumPartEditorW *npe : num_part_list_) {
+		if (!npe || !npe->isValid()) return false;
+	}
+	return true;
+}
+
 /**
 	@brief SelectAutonumW::on_buttonBox_clicked
 	Action on button clicked
@@ -252,6 +340,32 @@ void SelectAutonumW::on_buttonBox_clicked(QAbstractButton *button)
 							   ));
 				break;
 			}
+			else if (m_edited_type == 3)
+			{
+				QMessageBox::information (
+							this,
+							tr("Câble Autonumérotation",
+							   "title window"),
+							tr("C'est ici que vous pouvez définir la manière dont seront numérotés les nouveaux câbles.\n"
+							   "-Une numérotation est composée d'une variable minimum.\n"
+							   "-Vous pouvez ajouter ou supprimer une variable de numérotation par le biais des boutons - et +.\n"
+							   "-Une variable de numérotation comprend : un type, une valeur et une incrémentation.\n"
+
+							   "\n-les types \"Chiffre 1\", \"Chiffre 01\" et \"Chiffre 001\", représentent un type numérique défini dans le champ \"Valeur\", "
+							   "qui s'incrémente à chaque nouveau câble de la valeur du champ \"Incrémentation\".\n"
+							   "-\"Chiffre 01\" et \"Chiffre 001\", sont respectivement représentés sur le schéma par deux et trois digits minimum.\n"
+							   "Si le chiffre défini dans le champ Valeur possède moins de digits que le type choisi,"
+							   "celui-ci sera précédé par un ou deux 0 afin de respecter son type.\n"
+
+							   "\n-Le type \"Texte\", représente un texte fixe.\nLe champ \"Incrémentation\" n'est pas utilisé.\n"
+
+							   "\n-Le type \"N° folio\" représente le n° du folio en cours.\nLes autres champs ne sont pas utilisés.\n"
+
+							   "\n-Le type \"Folio\" représente le nom du folio en cours.\nLes autres champs ne sont pas utilisés.",
+							   "help dialog about the cable autonumerotation"
+							   ));
+				break;
+			}
 			else
 			{
 				QMessageBox::information (
@@ -282,6 +396,9 @@ void SelectAutonumW::on_buttonBox_clicked(QAbstractButton *button)
 		case QDialogButtonBox::ApplyRole:
 			applyEnable(false);
 			emit applyPressed();
+				//Whatever was edited is written now, so there is
+				//nothing of it left for a later save to write again.
+			m_dirty = false;
 			break;
 	};
 }

sources/autoNum/ui/selectautonumw.h

@@ -27,6 +27,7 @@ class NumPartEditorW;
 class QAbstractButton;
 class FormulaAutonumberingW;
 class QComboBox;
+class QPushButton;
 
 namespace Ui {
 	class SelectAutonumW;
@@ -52,10 +53,54 @@ class SelectAutonumW : public QWidget
 		void contextToFormula ();
 		QString formula();
 		QComboBox *contextComboBox() const;
+		/**
+			Show this editor as the only numbering rule there is: the
+			row which lets several named numberings be kept and chosen
+			between is hidden, so the rule being edited is the one and
+			only. Everything else -- the definition itself, the buttons
+			around it -- stays exactly as it is for the other kinds.
+		*/
+		void setSingleRuleMode(bool single);
+		bool isSingleRuleMode() const { return m_single_rule; }
+		/**
+			True while everything the editor holds is filled in well
+			enough to be a rule -- no variable left with nothing in it.
+			The Apply button says the same thing; this is so that a page
+			which saves on its own way knows it too, rather than writing
+			a rule nobody has finished filling in.
+		*/
+		bool isValid();
+		/**
+			True while the rule on show has been touched since it was
+			read or since it was last applied: a page which saves on
+			its own way (the cable rule does) writes it only when there
+			is something to write, so that confirming a window with
+			nothing changed in it leaves the project alone.
+		*/
+		bool isModified() const { return m_dirty; }
+		/**
+			Show the button which takes the rule itself away, which is
+			the only way to stop numbering cables automatically again:
+			the row the other numberings delete from is hidden here, so
+			a single rule would have no way out at all. The page behind
+			the editor says whether there is a rule to take away at the
+			moment -- without one the button has nothing to do and is
+			kept out of sight.
+			@param can_remove true when a rule is really there
+		*/
+		void setRuleRemovable(bool can_remove);
 
 	signals:
 		void applyPressed();
 		void removeClicked();
+			/**
+				Sent whenever what the rule holds is edited -- a
+				field of a part changed, a part added, a part taken
+				away -- so that a window holding this editor can let
+				its own buttons say whether there is something to
+				write now.
+			*/
+		void contextEdited();
 
 		//SLOT
 	private slots:
@@ -76,7 +121,19 @@ class SelectAutonumW : public QWidget
 		NumerotationContext m_context;
 		FormulaAutonumberingW *m_feaw;
 		FormulaAutonumberingW *m_fcaw;
-		int m_edited_type = -1; ///<0 == element : 1 == conductor : 2 == folio
+		int m_edited_type = -1; ///<0 == element : 1 == conductor : 2 == folio : 3 == cable
+			///< when true, the row of available numberings is hidden and
+			///< this editor holds the one rule there is (see setSingleRuleMode)
+		bool m_single_rule = false;
+			///< true from the moment the rule on show is touched until
+			///< it is read again or applied (see isModified)
+		bool m_dirty = false;
+			///< the button which takes the whole rule away, built for
+			///< the one kind of numbering which has no list to delete
+			///< it from (see setRuleRemovable)
+		QPushButton *m_rule_remove_pb = nullptr;
+			///< whether such a rule is there to be taken away
+		bool m_rule_removable = false;
 };
 
 #endif // SELECTAUTONUMW_H