Merge branch 'master' into qt6_cmake_joshua

sources/utils/conductorcreator.cpp

@@ -42,8 +42,10 @@ ConductorCreator::ConductorCreator(Diagram *d, QList<Terminal *> terminals_list)
 		return;
 	}
 	m_properties = m_terminals_list.first()->diagram()->defaultConductorProperties;
-	
-	setUpPropertieToUse();
+
+	if (!setUpPropertieToUse()) {
+		return;
+	}
 	Terminal *hub_terminal = hubTerminal();
 	
 	d->undoStack().beginMacro(QObject::tr("Création de conducteurs"));
@@ -95,12 +97,15 @@ void ConductorCreator::create(Diagram *d, const QPolygonF &polygon)
 
 /**
 	@brief ConductorCreator::propertieToUse
-	@return the conductor properties to use for the new conductors.
+	@return true if the caller should proceed with conductor creation,
+	false if the user cancelled the potential-selection dialog (in which
+	case no properties were chosen and creation must be aborted rather
+	than proceeding with blank/default properties).
 */
-void ConductorCreator::setUpPropertieToUse()
+bool ConductorCreator::setUpPropertieToUse()
 {
 	QList<Conductor *> potentials = existingPotential();
-	
+
 		//There is an existing potential
 		//we get one of them
 	if (!potentials.isEmpty())
@@ -111,8 +116,12 @@ void ConductorCreator::setUpPropertieToUse()
 			for(Conductor *c : potentials) {
 				cp_list.append(c->properties());
 			}
-			
-			m_properties = PotentialSelectorDialog::chosenProperties(cp_list);
+
+			bool cancelled = false;
+			m_properties = PotentialSelectorDialog::chosenProperties(cp_list, nullptr, &cancelled);
+			if (cancelled) {
+				return false;
+			}
 			for (Conductor *c : potentials) {
 				if (c->properties() == m_properties) {
 					m_sequential_number = c->sequenceNum();
@@ -124,11 +133,12 @@ void ConductorCreator::setUpPropertieToUse()
 			m_properties = potentials.first()->properties();
 			m_sequential_number = potentials.first()->sequenceNum();
 		}
-		return;
+		return true;
 	}
-	
+
 		//get a new properties
 	ConductorAutoNumerotation::newProperties(m_terminals_list.first()->diagram(), m_properties, m_sequential_number);
+	return true;
 }
 
 /**

sources/utils/conductorcreator.h

@@ -40,7 +40,7 @@ class ConductorCreator
 		static void create(Diagram *d, const QPolygonF &polygon);
 		
 	private:
-		void setUpPropertieToUse();
+		bool setUpPropertieToUse();
 		QList<Conductor *> existingPotential();
 		Terminal *hubTerminal();
 		

sources/utils/qetutils.cpp

@@ -150,3 +150,141 @@ void QETUtils::pixelSizedFont(QFont &font)
     auto px = font.pointSizeF()/72 * QFontMetrics{font}.fontDpi();
     font.setPixelSize(qRound(px));
 }
+
+namespace
+{
+	/**
+	 * Legacy (Qt 5) weight <- OpenType weight, closest match,
+	 * same table Qt uses when parsing a 10/11 field string.
+	 */
+	int legacyFontWeight(const int opentype_weight)
+	{
+		static const int weight_map[9][2] = {
+			{0, 100}, {12, 200}, {25, 300}, {50, 400}, {57, 500},
+			{63, 600}, {75, 700}, {81, 800}, {87, 900}
+		};
+		int legacy_weight = weight_map[0][0];
+		int closest_diff = qAbs(opentype_weight - weight_map[0][1]);
+		for (int i = 1 ; i < 9 ; ++i)
+		{
+			const int diff = qAbs(opentype_weight - weight_map[i][1]);
+			if (diff < closest_diff) {
+				closest_diff = diff;
+				legacy_weight = weight_map[i][0];
+			}
+		}
+		return legacy_weight;
+	}
+}
+
+/**
+ * @brief QETUtils::fontToString
+ * Serialize a font to the 10/11 field description format written by Qt 5,
+ * to be used instead of QFont::toString() everywhere a font description is
+ * stored in a project, element or settings file.
+ * The format of QFont::toString() is not stable across Qt versions : Qt 6.11
+ * switched to a 19 field format carrying OpenType weights, which
+ * QFont::fromString() of Qt 5.x and Qt <= 6.10 rejects, leaving a broken font.
+ * The 10/11 field form is parsed correctly by every Qt version (they convert
+ * the legacy weight scale as needed), so composing it ourselves keeps files
+ * readable by every QET build in circulation.
+ * See @link https://github.com/qelectrotech/qelectrotech-source-mirror/issues/553 @endlink
+ * @param font
+ * @return the font description string
+ */
+QString QETUtils::fontToString(const QFont &font)
+{
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
+	return font.toString();
+#else
+	const int legacy_weight = legacyFontWeight(font.weight());
+
+	const QChar comma(QLatin1Char(','));
+	QString description = font.family() + comma +
+		QString::number(font.pointSizeF()) + comma +
+		QString::number(font.pixelSize()) + comma +
+		QString::number(int(font.styleHint())) + comma +
+		QString::number(legacy_weight) + comma +
+		QString::number(int(font.style())) + comma +
+		QString::number(int(font.underline())) + comma +
+		QString::number(int(font.strikeOut())) + comma +
+		QString::number(int(font.fixedPitch())) + comma +
+		QString::number(0);
+	if (!font.styleName().isEmpty()) {
+		description += QChar(',') + font.styleName();
+	}
+	return description;
+#endif
+}
+
+/**
+ * @brief QETUtils::fontFromString
+ * Restore a font from a description string, tolerating descriptions written
+ * by any Qt version. QFont::fromString() of Qt 5.x and Qt <= 6.10 rejects the
+ * >= 19 field format QFont::toString() emits since Qt 6.11 (16 base fields
+ * plus style name, font-feature count and variable-axis count), leaving a
+ * broken font behind. When the native parser fails, salvage such a
+ * description by re-composing the 10/11 field form (OpenType weight mapped
+ * back to the legacy scale) and parsing that instead, so no font information
+ * stored in existing files is lost.
+ * See @link https://github.com/qelectrotech/qelectrotech-source-mirror/issues/553 @endlink
+ * @param font : font to restore into; left untouched on failure, so the
+ * caller's default keeps applying.
+ * @param description : font description string
+ * @return true if the description could be parsed
+ */
+bool QETUtils::fontFromString(QFont &font, const QString &description)
+{
+	QFont parsed(font);
+	if (parsed.fromString(description)) {
+		font = parsed;
+		return true;
+	}
+
+	const QStringList l = description.split(QLatin1Char(','));
+	const int count = l.size();
+	const QChar comma(QLatin1Char(','));
+
+		//16 base fields + style name + feature count + axis count; a family
+		//name containing commas adds leading fields. Descriptions actually
+		//using font features or variable axes append value groups whose
+		//layout we cannot anchor reliably, so only salvage the plain
+		//"...,0,0" case (the only one QET-edited files can contain).
+	if (count >= 19
+		&& l.at(count - 1).trimmed() == QLatin1String("0")
+		&& l.at(count - 2).trimmed() == QLatin1String("0"))
+	{
+		QString legacy = QStringList(l.mid(0, count - 18)).join(comma) + comma + // family
+			l.at(count - 18) + comma +                                       // pointSizeF
+			l.at(count - 17) + comma +                                       // pixelSize
+			l.at(count - 16) + comma +                                       // styleHint
+			QString::number(legacyFontWeight(l.at(count - 15).toInt())) + comma +
+			l.at(count - 14) + comma +                                       // style
+			l.at(count - 13) + comma +                                       // underline
+			l.at(count - 12) + comma +                                       // strikeOut
+			l.at(count - 11) + comma +                                       // fixedPitch
+			QString::number(0);
+		const QString style_name = l.at(count - 3);
+		if (!style_name.isEmpty()) {
+			legacy += comma + style_name;
+		}
+
+		if (parsed.fromString(legacy)) {
+			font = parsed;
+			return true;
+		}
+		return false;
+	}
+
+		//Some historical builds double-serialized fonts, embedding a complete
+		//legacy description as the family name of a second one (21 fields:
+		//"Caladea,9,-1,5,75,1,0,0,0,0,Bold Italic,9,-1,0,50,0,0,0,0,0,Regular").
+		//The embedded leading description carries the real font, and taking it
+		//matches what the lenient parser of Qt 6.11+ resolves such strings to.
+	if (count > 11
+		&& parsed.fromString(QStringList(l.mid(0, 11)).join(comma))) {
+		font = parsed;
+		return true;
+	}
+	return false;
+}

sources/utils/qetutils.h

@@ -32,6 +32,8 @@ namespace QETUtils
 	QMargins marginsFromString(const QString &string);
 	qreal graphicsHandlerSize(QGraphicsItem *item);
     void pixelSizedFont (QFont &font);
+    QString fontToString (const QFont &font);
+    bool fontFromString (QFont &font, const QString &description);
 
 	bool sortBeginIntString(const QString &str_a, const QString &str_b);