Add alphabetical auto-numbering (a, b, ... z, aa, ab, ...) (#579)

Adds a real base-26 incrementing part type to the autonumbering engine,
alongside the 14 existing NumStrategy leaves. Unlike StringNum (a fixed,
non-incrementing text segment), AlphaNum::next()/previous() carry/borrow
entirely within the part's own value -- the composition loop in
NumerotationContextCommands doesn't need to change, since (unlike #578's
wrap-and-carry) nothing here needs to signal an adjacent part.

- incrementAlpha()/decrementAlpha() implement the spreadsheet-column-name
  algorithm: increment carries right-to-left on 'z'/'Z' overflow,
  prepending a new leading letter if the whole value overflows (z -> aa,
  az -> ba). decrement is the exact inverse, including the symmetric
  shrink case (aa -> z) once every position has borrowed. A single letter
  already at "a"/"A" has no representable predecessor and is clamped
  rather than turned into "z" -- caught via manual testing, since the
  initial implementation mutated the string in the borrow loop before
  checking whether to clamp, silently discarding the original value.
- Registered in NumerotationContext::validRegExpNum() but deliberately
  not in validRegExpNumber(), so addValue() doesn't force alphabetic
  values through int conversion.
- New "Cyclique"-adjacent "Alphabétique" entry in numparteditorw's type
  dropdown, with its own letters-only QRegularExpressionValidator; the
  increase spinbox is disabled since the step is always exactly one
  letter, not a configurable amount.

Also wires the new part type through to actual element/conductor labels,
which turned out to be required for the feature to do anything visible
beyond folio numbering (which applies a NumerotationContext's
represented string directly). Element and conductor numbering instead
go through a separate formula-substitution layer
(autonum::sequentialNumbers + %sequ_/%seqt_/%seqh_-style placeholders in
AssignVariables::assignSequence()) that numerotationContextToFormula()
auto-populates. Without a matching placeholder, an "alpha" part would
silently vanish from the generated formula and never reach the label,
even though the underlying counter was advancing correctly:
- sequentialNumbers gained an `alpha` QStringList member (copy ctor,
  operator=, operator==, toXml/fromXml, clear()).
- numerotationContextToFormula() emits a new %seqa_N placeholder for
  alpha parts, the same way %sequ_N is emitted for unit parts.
- setSequential()/setSequentialToList() populate seqStruct.alpha,
  passing the raw string through as-is rather than the .toInt()-based
  formatting used for the numeric part types.
- AssignVariables::assignSequence() substitutes %seqa_N from
  seqStruct.alpha, mirroring the existing %sequ_N/%seqt_N/%seqh_N
  substitutions.
No "alphafolio" variant was added, matching the discussion's scope (only
unit/ten/hundred have folio-anchored variants).

Verified against production code via the numbering config dialog's own
Suivant/Précédent buttons: from "a", 25 clicks reached "z"; one more
produced "aa"; 25 more reached "az"; one more produced "ba" (carry).
Reversed: "ba"->"az"->(25 clicks)->"aa"->"z" (shrink)->(25 clicks)->"a".
One more "previous" at "a" correctly stayed at "a" after the clamp fix.
Also confirmed the Formule field auto-updates to "%seqa_1" the instant
the type is switched to "Alphabétique", confirming the formula-generation
wiring works live in the UI, not just at the engine level.

sources/autoNum/assignvariables.cpp

@@ -44,6 +44,7 @@ namespace autonum
 		ten_folio     = other.ten_folio;
 		hundred       = other.hundred;
 		hundred_folio = other.hundred_folio;
+		alpha         = other.alpha;
 	}
 
 	sequentialNumbers::~sequentialNumbers()
@@ -61,6 +62,7 @@ namespace autonum
 		ten_folio     = other.ten_folio;
 		hundred       = other.hundred;
 		hundred_folio = other.hundred_folio;
+		alpha         = other.alpha;
 
 		return (*this);
 	}
@@ -72,7 +74,8 @@ namespace autonum
 			ten           == other.ten && \
 			ten_folio     == other.ten_folio && \
 			hundred       == other.hundred && \
-			hundred_folio == other.hundred_folio)
+			hundred_folio == other.hundred_folio && \
+			alpha         == other.alpha)
 			return true;
 		else
 			return false;
@@ -129,6 +132,11 @@ namespace autonum
 						    document,
 						    "hundredFolio",
 						    hundred_folio.join(";")));
+		if(!alpha.isEmpty())
+			element.appendChild(QETXML::textToDomElement(
+						    document,
+						    "alpha",
+						    alpha.join(";")));
 
 		return element;
 	}
@@ -162,6 +170,9 @@ namespace autonum
 
 		from = element.firstChildElement("hundredFolio");
 		hundred_folio = from.text().split(";");
+
+		from = element.firstChildElement("alpha");
+		alpha = from.text().split(";");
 	}
 	
 		//Clear this sequence
@@ -173,6 +184,7 @@ namespace autonum
 		ten_folio.clear();
 		hundred.clear();
 		hundred_folio.clear();
+		alpha.clear();
 	}
 
 	/**
@@ -414,8 +426,10 @@ namespace autonum
 								 m_seq_struct.ten_folio.size()),
 							qMax(m_seq_struct.hundred_folio.size(),
 								 m_seq_struct.unit.size())),
+						qMax(
 							qMax(m_seq_struct.hundred.size(),
-							 m_seq_struct.ten.size())
+								 m_seq_struct.ten.size()),
+							m_seq_struct.alpha.size())
 					);
 
 		for (int i=1; i<=max ; i++)
@@ -438,6 +452,9 @@ namespace autonum
 			if (m_assigned_label.contains("%seqhf_" + QString::number(i)) && m_seq_struct.hundred_folio.size() >= i) {
 				m_assigned_label.replace("%seqhf_" + QString::number(i),m_seq_struct.hundred_folio.at(i-1));
 			}
+			if (m_assigned_label.contains("%seqa_" + QString::number(i)) && m_seq_struct.alpha.size() >= i) {
+				m_assigned_label.replace("%seqa_" + QString::number(i),m_seq_struct.alpha.at(i-1));
+			}
 		}
 	}
 
@@ -462,6 +479,9 @@ namespace autonum
 					number = QString("%1").arg(context.itemAt(i).at(1).toInt(), 2, 10, QChar('0'));
 				else if (type == "hundred" || type == "hundredfolio")
 					number = QString("%1").arg(context.itemAt(i).at(1).toInt(), 3, 10, QChar('0'));
+				else if (type == "alpha")
+						//Alphabetic value, not an integer -- used as-is.
+					number = context.itemAt(i).at(1);
 				else number = QString::number(context.itemAt(i).at(1).toInt());
 					list.append(number);
 			}
@@ -551,6 +571,10 @@ namespace autonum
 				autonum::setSequentialToList(seqStruct.hundred_folio, context,"hundredfolio");
 				autonum::setFolioSequentialToHash(seqStruct.hundred_folio, diagram->m_elmt_hundredfolio_max, hashKey);
 			}
+			if (label.contains("%seqa_"))
+			{
+				autonum::setSequentialToList(seqStruct.alpha, context,"alpha");
+			}
 		}
 	}
 
@@ -570,6 +594,7 @@ namespace autonum
 		int count_tenf = 0;
 		int count_hundred = 0;
 		int count_hundredf = 0;
+		int count_alpha = 0;
 
 		for(int i=0 ; i<nc.size() ; i++)
 		{
@@ -626,6 +651,10 @@ namespace autonum
 				count_hundredf++;
 				formula.append("%seqhf_" + QString::number(count_hundredf));
 			}
+			else if (type == "alpha") {
+				count_alpha++;
+				formula.append("%seqa_" + QString::number(count_alpha));
+			}
 		}
 
 		return formula;

sources/autoNum/assignvariables.h

@@ -52,6 +52,7 @@ namespace autonum
 			QStringList ten_folio;
 			QStringList hundred;
 			QStringList hundred_folio;
+			QStringList alpha;
 	};
 
 	/**

sources/autoNum/numerotationcontext.cpp

@@ -129,7 +129,7 @@ QStringList NumerotationContext::itemAt(const int i) const
 */
 QString NumerotationContext::validRegExpNum () const
 {
-	return ("unit|unitfolio|ten|tenfolio|hundred|hundredfolio|wrap|string|idfolio|folio|plant|locmach|elementline|elementcolumn|elementprefix");
+	return ("unit|unitfolio|ten|tenfolio|hundred|hundredfolio|wrap|alpha|string|idfolio|folio|plant|locmach|elementline|elementcolumn|elementprefix");
 }
 
 /**

sources/autoNum/numerotationcontextcommands.cpp

@@ -204,6 +204,10 @@ void NumerotationContextCommands::setNumStrategy(const QString &str) {
 		strategy_ = new StringNum (diagram_);
 		return;
 	}
+	else if (str == "alpha") {
+		strategy_ = new AlphaNum (diagram_);
+		return;
+	}
 	else if (str == "idfolio") {
 		strategy_ = new IdFolioNum (diagram_);
 		return;
@@ -604,6 +608,120 @@ NumerotationContext StringNum::previous(const NumerotationContext &nc, const int
 	return (nextString(nc, i));
 }
 
+namespace
+{
+	/**
+	 * @brief incrementAlpha
+	 * Base-26 letter increment (a, b, ... z, aa, ab, ... az, ba, ...),
+	 * the same algorithm as incrementing a spreadsheet column name.
+	 * Carries right-to-left on 'z'/'Z' overflow; if the whole string
+	 * overflows, a new leading letter is prepended (lowercase 'a').
+	 * @param value : current alphabetic value; treated as "a" if empty.
+	 * @return the next value.
+	 */
+	QString incrementAlpha(QString value)
+	{
+		if (value.isEmpty()) {
+			return QStringLiteral("a");
+		}
+
+		int i = value.length() - 1;
+		while (i >= 0 && (value.at(i) == QLatin1Char('z') || value.at(i) == QLatin1Char('Z'))) {
+			value[i] = value.at(i).isUpper() ? QLatin1Char('A') : QLatin1Char('a');
+			--i;
+		}
+		if (i < 0) {
+			value.prepend(QLatin1Char('a'));
+		} else {
+			value[i] = QChar(value.at(i).unicode() + 1);
+		}
+		return value;
+	}
+
+	/**
+	 * @brief decrementAlpha
+	 * Inverse of incrementAlpha(): borrows right-to-left on 'a'/'A'
+	 * underflow. Symmetric shrink case (e.g. "aa" -> "z"): once every
+	 * position has borrowed, the leading letter is dropped rather than
+	 * left as an extra 'z'. A single-letter value already at "a"/"A" has
+	 * no representable predecessor and is left unchanged, the same way
+	 * the numeric parts don't clamp but a blank label would be worse
+	 * here than a value that stops decreasing.
+	 * @param value : current alphabetic value; treated as "a" if empty.
+	 * @return the previous value.
+	 */
+	QString decrementAlpha(QString value)
+	{
+		if (value.isEmpty()) {
+			return QStringLiteral("a");
+		}
+		if (value.length() == 1) {
+				//A single letter has no representable predecessor once it
+				//reaches "a"/"A" -- clamp rather than mutate, since the loop
+				//below would otherwise turn it into "z"/"Z" (borrowing past
+				//the only position there is).
+			if (value.at(0) == QLatin1Char('a') || value.at(0) == QLatin1Char('A')) {
+				return value;
+			}
+			return QChar(value.at(0).unicode() - 1);
+		}
+
+		int i = value.length() - 1;
+		while (i >= 0 && (value.at(i) == QLatin1Char('a') || value.at(i) == QLatin1Char('A'))) {
+			value[i] = value.at(i).isUpper() ? QLatin1Char('Z') : QLatin1Char('z');
+			--i;
+		}
+		if (i < 0) {
+				//Every position borrowed: the whole value was "a...a", whose
+				//predecessor is one fewer "z" (e.g. "aa" -> "z").
+			value.remove(0, 1);
+		} else {
+			value[i] = QChar(value.at(i).unicode() - 1);
+		}
+		return value;
+	}
+}
+
+/**
+	Constructor
+*/
+AlphaNum::AlphaNum (Diagram *d):
+	NumStrategy (d)
+{}
+
+/**
+	@brief AlphaNum::toRepresentedString
+	@return the represented string of str
+*/
+QString AlphaNum::toRepresentedString(const QString str) const
+{
+	return (str);
+}
+
+/**
+	@brief AlphaNum::next
+	@return the next NumerotationContext nc at position i
+*/
+NumerotationContext AlphaNum::next (const NumerotationContext &nc, const int i) const
+{
+	QStringList strl = nc.itemAt(i);
+	NumerotationContext newnc;
+	newnc.addValue(strl.at(0), incrementAlpha(strl.at(1)), strl.at(2).toInt());
+	return (newnc);
+}
+
+/**
+	@brief AlphaNum::previous
+	@return the previous NumerotationContext nc at posiiton i
+*/
+NumerotationContext AlphaNum::previous(const NumerotationContext &nc, const int i) const
+{
+	QStringList strl = nc.itemAt(i);
+	NumerotationContext newnc;
+	newnc.addValue(strl.at(0), decrementAlpha(strl.at(1)), strl.at(2).toInt());
+	return (newnc);
+}
+
 /**
 	Constructor
 */

sources/autoNum/numerotationcontextcommands.h

@@ -144,6 +144,23 @@ class StringNum: public NumStrategy
 	NumerotationContext previous (const NumerotationContext &, const int) const override;
 };
 
+/**
+	@brief The AlphaNum class
+	Alphabetic auto-numbering (a, b, ... z, aa, ab, ...). Unlike StringNum
+	(a fixed, non-incrementing text segment), this is a real base-26
+	counter: next()/previous() carry/borrow entirely within this part's
+	own value, the same self-contained shape every other incrementing
+	NumStrategy already has.
+*/
+class AlphaNum: public NumStrategy
+{
+	public:
+	AlphaNum (Diagram *);
+	QString toRepresentedString(const QString) const override;
+	NumerotationContext next     (const NumerotationContext &, const int) const override;
+	NumerotationContext previous (const NumerotationContext &, const int) const override;
+};
+
 class IdFolioNum: public NumStrategy
 {
 	public:

sources/autoNum/ui/numparteditorw.cpp

@@ -18,6 +18,8 @@
 #include "numparteditorw.h"
 #include "ui_numparteditorw.h"
 
+#include <QRegularExpressionValidator>
+
 /**
 	@brief NumPartEditorW::NumPartEditorW
 	Constructor
@@ -28,6 +30,7 @@ NumPartEditorW::NumPartEditorW(int type, QWidget *parent) :
 	QWidget(parent),
 	ui(new Ui::NumPartEditorW),
 	intValidator (new QIntValidator(0,99999,this)),
+	alphaValidator (new QRegularExpressionValidator(QRegularExpression("[A-Za-z]+"), this)),
 	m_edited_type(type)
 {
 	ui -> setupUi(this);
@@ -51,6 +54,7 @@ NumPartEditorW::NumPartEditorW (NumerotationContext &context,
 	QWidget(parent),
 	ui(new Ui::NumPartEditorW),
 	intValidator (new QIntValidator(0,99999,this)),
+	alphaValidator (new QRegularExpressionValidator(QRegularExpression("[A-Za-z]+"), this)),
 	m_edited_type(type)
 {
 	ui -> setupUi(this);
@@ -73,6 +77,8 @@ NumPartEditorW::NumPartEditorW (NumerotationContext &context,
 			setType(NumPartEditorW::hundredfolio, true);
 		else if (strl.at(0)=="wrap")
 			setType(NumPartEditorW::wrap, true);
+		else if (strl.at(0)=="alpha")
+			setType(NumPartEditorW::alpha);
 		else if (strl.at(0)=="string")
 			setType(NumPartEditorW::string);
 		else if (strl.at(0)=="idfolio")
@@ -102,6 +108,7 @@ NumPartEditorW::NumPartEditorW (NumerotationContext &context,
 NumPartEditorW::~NumPartEditorW()
 {
 	delete intValidator;
+	delete alphaValidator;
 	delete ui;
 }
 
@@ -115,6 +122,7 @@ void NumPartEditorW::setVisibleItems()
 			<< tr("Chiffre 01")
 			<< tr("Chiffre 001")
 			<< tr("Cyclique (modulo)")
+			<< tr("Alphabétique")
 			<< tr("Texte");
 	}
 	else if (m_edited_type == 1)
@@ -126,6 +134,7 @@ void NumPartEditorW::setVisibleItems()
 			<< tr("Chiffre 001")
 			<< tr("Chiffre 001 - Folio")
 			<< tr("Cyclique (modulo)")
+			<< tr("Alphabétique")
 			<< tr("Texte")
 			<< tr("N° folio")
 			<< tr("Folio")
@@ -140,6 +149,7 @@ void NumPartEditorW::setVisibleItems()
 		      << tr("Chiffre 001")
 		      << tr("Chiffre 001 - Folio")
 		      << tr("Cyclique (modulo)")
+		      << tr("Alphabétique")
 		      << tr("Texte")
 		      << tr("N° folio")
 		      << tr("Folio")
@@ -205,6 +215,9 @@ NumerotationContext NumPartEditorW::toNumContext()
 		case wrap:
 			type_str = "wrap";
 			break;
+		case alpha:
+			type_str = "alpha";
+			break;
 	}
 	if (type_str == "unitfolio"
 			|| type_str == "tenfolio"
@@ -278,6 +291,8 @@ void NumPartEditorW::on_type_cb_activated(int) {
 		setType(elementprefix);
 	else if (ui->type_cb->currentText() == tr("Cyclique (modulo)"))
 		setType(wrap);
+	else if (ui->type_cb->currentText() == tr("Alphabétique"))
+		setType(alpha);
 	emit changed();
 }
 
@@ -349,6 +364,7 @@ void NumPartEditorW::setType(NumPartEditorW::type t, bool fnum) {
 	}
 	//@t isn't a numeric type
 	else if (t == string
+		 || t == alpha
 		 || t == folio
 		 || t == idfolio
 		 || t == elementline
@@ -362,6 +378,13 @@ void NumPartEditorW::setType(NumPartEditorW::type t, bool fnum) {
 			ui -> value_field -> setValidator(nullptr);
 			ui -> value_field -> setEnabled(true);
 		}
+		else if (t==alpha) {
+				//Alphabetic step is always exactly one letter (a, b, ...);
+				//there is no numeric "increase" to configure, unlike the
+				//digit-based part types.
+			ui -> value_field -> setValidator(alphaValidator);
+			ui -> value_field -> setEnabled(true);
+		}
 		else if (t==folio) {
 			ui -> value_field -> setDisabled(true);
 			ui -> increase_spinBox -> setDisabled(true);
@@ -414,6 +437,8 @@ void NumPartEditorW::setCurrentIndex(NumPartEditorW::type t) {
 		i = ui->type_cb->findText(tr("Chiffre 001"));
 	else if (t == hundredfolio)
 		i = ui->type_cb->findText(tr("Chiffre 001 - Folio"));
+	else if (t == alpha)
+		i = ui->type_cb->findText(tr("Alphabétique"));
 	else if (t == string)
 		i = ui->type_cb->findText(tr("Texte"));
 	else if (t == idfolio)

sources/autoNum/ui/numparteditorw.h

@@ -47,6 +47,7 @@ class NumPartEditorW : public QWidget
 		~NumPartEditorW() override;
 
 		enum type {unit,unitfolio,ten,tenfolio, hundred, hundredfolio,
+				   alpha,
 				   string,idfolio,folio,plant,locmach,
 				   elementline,elementcolumn,elementprefix,
 				   wrap,
@@ -73,6 +74,7 @@ class NumPartEditorW : public QWidget
 	private:
 		Ui::NumPartEditorW *ui;
 		QValidator *intValidator;
+		QValidator *alphaValidator;
 		int m_edited_type = -1; ///<0 == element : 1 == conductor : 2 == folio