Lupdate.

Fix code style.

.clang-format

@@ -35,3 +35,4 @@ IndentAccessModifiers: false
 AccessModifierOffset: -4
 SpaceBeforeParens: ControlStatementsExceptControlMacros
 IndentCaseLabels: true
+StatementMacros: ['Q_OBJECT', 'Q_UNUSED']

ChangeLog.txt

@@ -28,6 +28,7 @@
 - New notch type - Check Notch.
 - Control a notch width and angle with formulas.
 - Independent translation for piece labels.
+- Piece labels line break.
 
 # Valentina 0.7.52 September 12, 2022
 - Fix crash when default locale is ru.

src/app/puzzle/scene/vpgraphicspiece.cpp

@@ -28,32 +28,32 @@
 
 #include "vpgraphicspiece.h"
 
-#include <QPen>
-#include <QBrush>
-#include <QPainter>
-#include <QGraphicsSceneMouseEvent>
-#include <QStyleOptionGraphicsItem>
-#include <QGraphicsSceneContextMenuEvent>
-#include <QMenu>
-#include <QtMath>
-#include <QGraphicsScene>
 #include <QApplication>
+#include <QBrush>
+#include <QGraphicsScene>
+#include <QGraphicsSceneContextMenuEvent>
+#include <QGraphicsSceneMouseEvent>
+#include <QMenu>
+#include <QPainter>
+#include <QPen>
+#include <QStyleOptionGraphicsItem>
+#include <QtMath>
 
-#include "../layout/vppiece.h"
 #include "../layout/vplayout.h"
+#include "../layout/vppiece.h"
 #include "../layout/vpsheet.h"
-#include "../vlayout/vtextmanager.h"
 #include "../vlayout/vgraphicsfillitem.h"
+#include "../vlayout/vtextmanager.h"
 
 #include "../vpapplication.h"
 
-#include "compatibility.h"
 #include "../vlayout/vlayoutpiecepath.h"
+#include "compatibility.h"
 
 #include "../vgeometry/vlayoutplacelabel.h"
 
-#include "undocommands/vpundopiecemove.h"
 #include "undocommands/vpundomovepieceonsheet.h"
+#include "undocommands/vpundopiecemove.h"
 #include "vpiecegrainline.h"
 
 #include <QLoggingCategory>
@@ -69,7 +69,7 @@ QT_WARNING_POP
 namespace
 {
 Q_GLOBAL_STATIC_WITH_ARGS(QColor, mainColor, (Qt::black)) // NOLINT
-Q_GLOBAL_STATIC_WITH_ARGS(QColor, errorColor, (Qt::red)) // NOLINT
+Q_GLOBAL_STATIC_WITH_ARGS(QColor, errorColor, (Qt::red))  // NOLINT
 
 //---------------------------------------------------------------------------------------------------------------------
 inline auto LineMatrix(const VPPiecePtr &piece, const QPointF &topLeft, qreal angle, const QPointF &linePos,
@@ -101,30 +101,17 @@ inline auto LineMatrix(const VPPiecePtr &piece, const QPointF &topLeft, qreal an
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-inline auto LineFont(const TextLine& tl, const QFont &base) -> QFont
+inline auto LineFont(const TextLine &tl, const QFont &base) -> QFont
 {
     QFont fnt = base;
-    fnt.setPixelSize(base.pixelSize() + tl.m_iFontSize);
+    fnt.setPointSize(base.pointSize() + tl.m_iFontSize);
     fnt.setBold(tl.m_bold);
     fnt.setItalic(tl.m_italic);
     return fnt;
 }
 
-
 //---------------------------------------------------------------------------------------------------------------------
-inline auto LineText(const TextLine& tl, const QFontMetrics &fm, qreal width) -> QString
-{
-    QString qsText = tl.m_qsText;
-    if (TextWidth(fm, qsText) > width)
-    {
-        qsText = fm.elidedText(qsText, Qt::ElideMiddle, static_cast<int>(width));
-    }
-
-    return qsText;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-inline auto LineAlign(const TextLine& tl, const QString &text, const QFontMetrics &fm, qreal width) -> qreal
+inline auto LineAlign(const TextLine &tl, const QString &text, const QFontMetrics &fm, qreal width) -> qreal
 {
     const int lineWidth = TextWidth(fm, text);
 
@@ -135,7 +122,7 @@ inline auto LineAlign(const TextLine& tl, const QString &text, const QFontMetric
     }
     else if ((tl.m_eAlign & Qt::AlignHCenter) > 0)
     {
-        dX = (width - lineWidth)/2;
+        dX = (width - lineWidth) / 2;
     }
     else if ((tl.m_eAlign & Qt::AlignRight) > 0)
     {
@@ -150,11 +137,11 @@ inline auto SelectionBrush() -> QBrush
 {
     return {QColor(255, 160, 160, 60)};
 }
-}  // namespace
+} // namespace
 
 //---------------------------------------------------------------------------------------------------------------------
-VPGraphicsPiece::VPGraphicsPiece(const VPPiecePtr &piece, QGraphicsItem *parent) :
-    QGraphicsObject(parent),
+VPGraphicsPiece::VPGraphicsPiece(const VPPiecePtr &piece, QGraphicsItem *parent)
+  : QGraphicsObject(parent),
     m_piece(piece)
 {
     // set some infos
@@ -190,7 +177,7 @@ auto VPGraphicsPiece::boundingRect() const -> QRectF
     shape.addPath(m_stickyPath);
 
     VPSettings *settings = VPApplication::VApp()->PuzzleSettings();
-    const qreal halfPenWidth = settings->GetLayoutLineWidth()/2.;
+    const qreal halfPenWidth = settings->GetLayoutLineWidth() / 2.;
 
     return shape.boundingRect().adjusted(-halfPenWidth, -halfPenWidth, halfPenWidth, halfPenWidth);
 }
@@ -198,7 +185,7 @@ auto VPGraphicsPiece::boundingRect() const -> QRectF
 //---------------------------------------------------------------------------------------------------------------------
 auto VPGraphicsPiece::shape() const -> QPainterPath
 {
-    if(!m_cuttingLine.isEmpty())
+    if (!m_cuttingLine.isEmpty())
     {
         return m_cuttingLine;
     }
@@ -222,11 +209,11 @@ void VPGraphicsPiece::paint(QPainter *painter, const QStyleOptionGraphicsItem *o
 //---------------------------------------------------------------------------------------------------------------------
 void VPGraphicsPiece::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
-    //perform the default behaviour
+    // perform the default behaviour
     QGraphicsObject::mousePressEvent(event);
 
     // change the cursor when clicking the left button
-    if(event->button() == Qt::LeftButton)
+    if (event->button() == Qt::LeftButton)
     {
         setCursor(Qt::ClosedHandCursor);
 
@@ -250,7 +237,7 @@ void VPGraphicsPiece::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 //---------------------------------------------------------------------------------------------------------------------
 void VPGraphicsPiece::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 {
-    //perform the default behaviour
+    // perform the default behaviour
     QGraphicsItem::mouseReleaseEvent(event);
 
     // change the cursor when clicking left button
@@ -267,8 +254,8 @@ void VPGraphicsPiece::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             {
                 if (layout->LayoutSettings().GetStickyEdges() && m_hasStickyPosition)
                 {
-                    auto *command = new VPUndoPieceMove(piece, m_stickyTranslateX, m_stickyTranslateY,
-                                                        m_allowChangeMerge);
+                    auto *command =
+                        new VPUndoPieceMove(piece, m_stickyTranslateX, m_stickyTranslateY, m_allowChangeMerge);
                     layout->UndoStack()->push(command);
 
                     SetStickyPoints(QVector<QPointF>());
@@ -314,7 +301,7 @@ void VPGraphicsPiece::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
     QList<VPSheetPtr> sheets = layout->GetSheets();
     sheets.removeAll(piece->Sheet());
 
-    QVector<QAction*> moveToActions;
+    QVector<QAction *> moveToActions;
 
     if (not sheets.isEmpty())
     {
@@ -324,7 +311,7 @@ void VPGraphicsPiece::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
         {
             if (not sheet.isNull())
             {
-                QAction* moveToSheet = moveMenu->addAction(sheet->GetName());
+                QAction *moveToSheet = moveMenu->addAction(sheet->GetName());
                 moveToSheet->setData(QVariant::fromValue(sheet));
                 moveToActions.append(moveToSheet);
             }
@@ -399,29 +386,37 @@ void VPGraphicsPiece::InitPieceLabel(const QVector<QPointF> &labelShape, const V
 
     const qreal dW = QLineF(labelShape.at(0), labelShape.at(1)).length();
     const qreal dH = QLineF(labelShape.at(1), labelShape.at(2)).length();
-    const qreal angle = - QLineF(labelShape.at(0), labelShape.at(1)).angle();
+    const qreal angle = -QLineF(labelShape.at(0), labelShape.at(1)).angle();
     const QColor color = PieceColor();
     const int maxLineWidth = tm.MaxLineWidth(static_cast<int>(dW));
 
     qreal dY = 0;
 
-    for (int i = 0; i < tm.GetSourceLinesCount(); ++i)
+    const QVector<TextLine> labelLines = tm.GetLabelSourceLines(qFloor(dW), tm.GetFont());
+
+    for (const auto &tl : labelLines)
     {
-        const TextLine& tl = tm.GetSourceLine(i);
         const QFont fnt = LineFont(tl, tm.GetFont());
         const QFontMetrics fm(fnt);
 
         if (m_textAsPaths)
         {
             dY += fm.height();
-        }
 
-        if (dY > dH)
+            if (dY > dH)
+            {
+                break;
+            }
+        }
+        else
         {
-            break;
+            if (dY + fm.height() > dH)
+            {
+                break;
+            }
         }
 
-        const QString qsText = LineText(tl, fm, dW);
+        const QString qsText = tl.m_qsText;
         const qreal dX = LineAlign(tl, qsText, fm, dW);
         // set up the rotation around top-left corner matrix
         const QTransform lineMatrix = LineMatrix(piece, labelShape.at(0), angle, QPointF(dX, dY), maxLineWidth);
@@ -429,9 +424,9 @@ void VPGraphicsPiece::InitPieceLabel(const QVector<QPointF> &labelShape, const V
         if (m_textAsPaths)
         {
             QPainterPath path;
-            path.addText(0, - static_cast<qreal>(fm.ascent())/6., fnt, qsText);
+            path.addText(0, -static_cast<qreal>(fm.ascent()) / 6., fnt, qsText);
 
-            auto* item = new QGraphicsPathItem(this);
+            auto *item = new QGraphicsPathItem(this);
             item->setPath(path);
             item->setBrush(QBrush(color));
             item->setTransform(lineMatrix);
@@ -441,7 +436,7 @@ void VPGraphicsPiece::InitPieceLabel(const QVector<QPointF> &labelShape, const V
         }
         else
         {
-            auto* item = new QGraphicsSimpleTextItem(this);
+            auto *item = new QGraphicsSimpleTextItem(this);
             item->setFont(fnt);
             item->setText(qsText);
             item->setBrush(QBrush(color));
@@ -464,7 +459,7 @@ void VPGraphicsPiece::InitGrainlineItem()
         return;
     }
 
-    if(piece->IsGrainlineEnabled())
+    if (piece->IsGrainlineEnabled())
     {
         m_grainlineItem = new VGraphicsFillItem(this);
         m_grainlineItem->setPath(VLayoutPiece::GrainlinePath(piece->GetMappedGrainlineShape()));
@@ -516,7 +511,7 @@ void VPGraphicsPiece::PaintSeamLine(QPainter *painter, const VPPiecePtr &piece)
     if (not piece->IsHideMainPath() || not piece->IsSeamAllowance())
     {
         QVector<VLayoutPoint> seamLinePoints = piece->GetMappedContourPoints();
-        if(!seamLinePoints.isEmpty())
+        if (!seamLinePoints.isEmpty())
         {
             m_seamLine.moveTo(ConstFirst(seamLinePoints));
             for (int i = 1; i < seamLinePoints.size(); i++)
@@ -541,7 +536,7 @@ void VPGraphicsPiece::PaintCuttingLine(QPainter *painter, const VPPiecePtr &piec
     if (piece->IsSeamAllowance() && not piece->IsSeamAllowanceBuiltIn())
     {
         QVector<VLayoutPoint> cuttingLinepoints = piece->GetMappedSeamAllowancePoints();
-        if(!cuttingLinepoints.isEmpty())
+        if (!cuttingLinepoints.isEmpty())
         {
             m_cuttingLine.moveTo(ConstFirst(cuttingLinepoints));
             for (int i = 1; i < cuttingLinepoints.size(); i++)
@@ -564,7 +559,7 @@ void VPGraphicsPiece::PaintCuttingLine(QPainter *painter, const VPPiecePtr &piec
 void VPGraphicsPiece::PaintInternalPaths(QPainter *painter, const VPPiecePtr &piece)
 {
     QVector<VLayoutPiecePath> internalPaths = piece->GetInternalPaths();
-    for (const auto& piecePath : internalPaths)
+    for (const auto &piecePath : internalPaths)
     {
         QPainterPath path = piece->GetMatrix().map(piecePath.GetPainterPath());
 
@@ -585,7 +580,7 @@ void VPGraphicsPiece::PaintInternalPaths(QPainter *painter, const VPPiecePtr &pi
 void VPGraphicsPiece::PaintPassmarks(QPainter *painter, const VPPiecePtr &piece)
 {
     QVector<VLayoutPassmark> passmarks = piece->GetMappedPassmarks();
-    for(auto &passmark : passmarks)
+    for (auto &passmark : passmarks)
     {
         QPainterPath passmarkPath;
         for (auto &line : passmark.lines)
@@ -610,7 +605,7 @@ void VPGraphicsPiece::PaintPassmarks(QPainter *painter, const VPPiecePtr &piece)
 void VPGraphicsPiece::PaintPlaceLabels(QPainter *painter, const VPPiecePtr &piece)
 {
     QVector<VLayoutPlaceLabel> placeLabels = piece->GetPlaceLabels();
-    for(auto &placeLabel : placeLabels)
+    for (auto &placeLabel : placeLabels)
     {
         QPainterPath path =
             VAbstractPiece::LabelShapePath(piece->MapPlaceLabelShape(VAbstractPiece::PlaceLabelShape(placeLabel)));
@@ -807,7 +802,7 @@ auto VPGraphicsPiece::itemChange(GraphicsItemChange change, const QVariant &valu
 {
     if (scene() != nullptr)
     {
-        if(change == ItemSelectedHasChanged)
+        if (change == ItemSelectedHasChanged)
         {
             VPPiecePtr piece = m_piece.toStrongRef();
             if (not piece.isNull())
@@ -825,4 +820,3 @@ auto VPGraphicsPiece::itemChange(GraphicsItemChange change, const QVariant &valu
 
     return QGraphicsObject::itemChange(change, value);
 }
-

src/app/puzzle/xml/vplayoutfilereader.cpp

@@ -26,23 +26,24 @@
  **
  ** *************************************************************************/
 
-#include <Qt>
-#include <QFont>
-#include <QXmlStreamAttributes>
-#include <ciso646>
-#include "vpiecegrainline.h"
 #include "vplayoutfilereader.h"
-#include "vplayoutliterals.h"
-#include "../layout/vpsheet.h"
-#include "../vlayout/vlayoutpiecepath.h"
-#include "../vlayout/vtextmanager.h"
 #include "../ifc/exception/vexception.h"
 #include "../ifc/exception/vexceptionconversionerror.h"
-#include "../vpatterndb/floatItemData/floatitemdef.h"
-#include "../vgeometry/vgeometrydef.h"
-#include "../vgeometry/vlayoutplacelabel.h"
 #include "../layout/vplayout.h"
 #include "../layout/vppiece.h"
+#include "../layout/vpsheet.h"
+#include "../vgeometry/vgeometrydef.h"
+#include "../vgeometry/vlayoutplacelabel.h"
+#include "../vlayout/vlayoutpiecepath.h"
+#include "../vlayout/vtextmanager.h"
+#include "../vmisc/vcommonsettings.h"
+#include "../vpatterndb/floatItemData/floatitemdef.h"
+#include "vpiecegrainline.h"
+#include "vplayoutliterals.h"
+#include <QFont>
+#include <QXmlStreamAttributes>
+#include <Qt>
+#include <ciso646>
 
 QT_WARNING_PUSH
 QT_WARNING_DISABLE_CLANG("-Wmissing-prototypes")
@@ -99,7 +100,7 @@ auto StringToPath(const QString &path) -> QVector<QPointF>
 
     QStringList points = path.split(ML::pointsSep);
     p.reserve(points.size());
-    for (const auto& point : points)
+    for (const auto &point : points)
     {
         p.append(StringToPoint(point));
     }
@@ -188,7 +189,7 @@ auto StringToLines(const QString &string) -> QVector<QLineF>
     QVector<QLineF> path;
     path.reserve(lines.size());
 
-    for (const auto& line : lines)
+    for (const auto &line : lines)
     {
         QLineF l = StringToLine(line);
         if (not l.isNull())
@@ -211,7 +212,7 @@ auto StringToRect(const QString &string) -> QRectF
 
     return {};
 }
-}  // namespace
+} // namespace
 
 //---------------------------------------------------------------------------------------------------------------------
 auto VPLayoutFileReader::ReadFile(const VPLayoutPtr &layout, QFile *file) -> bool
@@ -225,7 +226,7 @@ auto VPLayoutFileReader::ReadFile(const VPLayoutPtr &layout, QFile *file) -> boo
             ReadLayout(layout);
         }
     }
-    catch(const VException &e)
+    catch (const VException &e)
     {
         raiseError(e.ErrorMessage());
     }
@@ -238,8 +239,7 @@ void VPLayoutFileReader::ReadLayout(const VPLayoutPtr &layout)
 {
     AssertRootTag(ML::TagLayout);
 
-    const QStringList tags
-    {
+    const QStringList tags{
         ML::TagProperties,     // 0
         ML::TagUnplacedPieces, // 1
         ML::TagSheets          // 2
@@ -271,8 +271,7 @@ void VPLayoutFileReader::ReadProperties(const VPLayoutPtr &layout)
 {
     AssertRootTag(ML::TagProperties);
 
-    const QStringList tags
-    {
+    const QStringList tags{
         ML::TagUnit,        // 0
         ML::TagTitle,       // 1
         ML::TagDescription, // 2
@@ -288,15 +287,15 @@ void VPLayoutFileReader::ReadProperties(const VPLayoutPtr &layout)
 
         switch (tags.indexOf(name().toString()))
         {
-            case 0:// unit
+            case 0: // unit
                 qDebug("read unit");
                 layout->LayoutSettings().SetUnit(StrToUnits(readElementText()));
                 break;
-            case 1:// title
+            case 1: // title
                 qDebug("read title");
                 layout->LayoutSettings().SetTitle(readElementText());
                 break;
-            case 2:// description
+            case 2: // description
                 qDebug("read description");
                 layout->LayoutSettings().SetDescription(readElementText());
                 break;
@@ -331,7 +330,7 @@ void VPLayoutFileReader::ReadControl(const VPLayoutPtr &layout)
 
     QXmlStreamAttributes attribs = attributes();
     layout->LayoutSettings().SetWarningSuperpositionOfPieces(
-                ReadAttributeBool(attribs, ML::AttrWarningSuperposition, trueStr));
+        ReadAttributeBool(attribs, ML::AttrWarningSuperposition, trueStr));
     layout->LayoutSettings().SetWarningPiecesOutOfBound(ReadAttributeBool(attribs, ML::AttrWarningOutOfBound, trueStr));
     layout->LayoutSettings().SetStickyEdges(ReadAttributeBool(attribs, ML::AttrStickyEdges, trueStr));
     layout->LayoutSettings().SetPiecesGap(qMax(ReadAttributeDouble(attribs, ML::AttrPiecesGap, QChar('0')), 0.0));
@@ -357,10 +356,9 @@ void VPLayoutFileReader::ReadTiles(const VPLayoutPtr &layout)
     layout->LayoutSettings().SetShowTiles(ReadAttributeBool(attribs, ML::AttrVisible, falseStr));
     layout->LayoutSettings().SetPrintTilesScheme(ReadAttributeBool(attribs, ML::AttrPrintScheme, falseStr));
     layout->LayoutSettings().SetShowTileNumber(ReadAttributeBool(attribs, ML::AttrTileNumber, falseStr));
-//    attribs.value(ML::AttrMatchingMarks); // TODO
+    //    attribs.value(ML::AttrMatchingMarks); // TODO
 
-    const QStringList tags
-    {
+    const QStringList tags{
         ML::TagSize,  // 0
         ML::TagMargin // 1
     };
@@ -426,8 +424,7 @@ void VPLayoutFileReader::ReadSheet(const VPLayoutPtr &layout)
     QXmlStreamAttributes attribs = attributes();
     sheet->SetGrainlineType(StrToGrainlineType(ReadAttributeEmptyString(attribs, ML::AttrGrainlineType)));
 
-    const QStringList tags
-    {
+    const QStringList tags{
         ML::TagName,   // 0
         ML::TagSize,   // 1
         ML::TagMargin, // 2
@@ -462,7 +459,6 @@ void VPLayoutFileReader::ReadSheet(const VPLayoutPtr &layout)
     layout->AddSheet(sheet);
 }
 
-
 //---------------------------------------------------------------------------------------------------------------------
 void VPLayoutFileReader::ReadPieces(const VPLayoutPtr &layout, const VPSheetPtr &sheet)
 {
@@ -513,8 +509,7 @@ void VPLayoutFileReader::ReadPiece(const VPPiecePtr &piece)
     piece->SetSewLineOnDrawing(ReadAttributeBool(attribs, ML::AttrSewLineOnDrawing, falseStr));
     piece->SetMatrix(StringToTransfrom(ReadAttributeEmptyString(attribs, ML::AttrTransform)));
 
-    const QStringList tags
-    {
+    const QStringList tags{
         ML::TagSeamLine,      // 0
         ML::TagSeamAllowance, // 1
         ML::TagGrainline,     // 2
@@ -905,7 +900,8 @@ auto VPLayoutFileReader::ReadLabelLine() -> TextLine
 
     QXmlStreamAttributes attribs = attributes();
 
-    line.m_iFontSize = ReadAttributeInt(attribs, ML::AttrFontSize, QString::number(MIN_FONT_SIZE));
+    line.m_iFontSize =
+        ReadAttributeInt(attribs, ML::AttrFontSize, QString::number(VCommonSettings::MinPieceLabelFontPointSize()));
     line.m_bold = ReadAttributeBool(attribs, ML::AttrBold, falseStr);
     line.m_italic = ReadAttributeBool(attribs, ML::AttrItalic, falseStr);
     int alignment = ReadAttributeInt(attribs, ML::AttrAlignment, QString::number(static_cast<int>(Qt::AlignCenter)));
@@ -976,7 +972,7 @@ auto VPLayoutFileReader::ReadSize() -> QSizeF
 //---------------------------------------------------------------------------------------------------------------------
 void VPLayoutFileReader::AssertRootTag(const QString &tag) const
 {
-    if (not (isStartElement() && name() == tag))
+    if (not(isStartElement() && name() == tag))
     {
         throw VException(tr("Unexpected tag %1 in line %2").arg(name().toString()).arg(lineNumber()));
     }
@@ -984,7 +980,7 @@ void VPLayoutFileReader::AssertRootTag(const QString &tag) const
 
 //---------------------------------------------------------------------------------------------------------------------
 auto VPLayoutFileReader::ReadAttributeString(const QXmlStreamAttributes &attribs, const QString &name,
-                                                const QString &defValue) -> QString
+                                             const QString &defValue) -> QString
 {
     const QString parameter = attribs.value(name).toString();
     if (parameter.isEmpty())
@@ -1016,7 +1012,7 @@ auto VPLayoutFileReader::ReadAttributeBool(const QXmlStreamAttributes &attribs,
     {
         parametr = ReadAttributeString(attribs, name, defValue);
 
-        const QStringList bools {trueStr, falseStr, QChar('1'), QChar('0')};
+        const QStringList bools{trueStr, falseStr, QChar('1'), QChar('0')};
         switch (bools.indexOf(parametr))
         {
             case 0: // true
@@ -1027,7 +1023,7 @@ auto VPLayoutFileReader::ReadAttributeBool(const QXmlStreamAttributes &attribs,
             case 3: // 0
                 val = false;
                 break;
-            default:// others
+            default: // others
                 throw VExceptionConversionError(message, name);
         }
     }

src/app/valentina/dialogs/configpages/preferencespatternpage.cpp

@@ -27,19 +27,19 @@
  *************************************************************************/
 
 #include "preferencespatternpage.h"
-#include "ui_preferencespatternpage.h"
 #include "../dialogdatetimeformats.h"
 #include "../dialogknownmaterials.h"
-#include "../vmisc/vvalentinasettings.h"
 #include "../vmisc/vabstractvalapplication.h"
+#include "../vmisc/vvalentinasettings.h"
+#include "ui_preferencespatternpage.h"
 #if QT_VERSION < QT_VERSION_CHECK(5, 7, 0)
 #include "../vmisc/backport/qoverload.h"
 #endif // QT_VERSION < QT_VERSION_CHECK(5, 7, 0)
-#include "../vwidgets/vmaingraphicsview.h"
 #include "../ifc/xml/vabstractpattern.h"
+#include "../vwidgets/vmaingraphicsview.h"
 
-#include <QMessageBox>
 #include <QDate>
+#include <QMessageBox>
 #include <QTime>
 
 namespace
@@ -57,12 +57,12 @@ auto ComboBoxAllStrings(QComboBox *combo) -> QStringList
 
     return itemsInComboBox;
 }
-}  // namespace
+} // namespace
 
 //---------------------------------------------------------------------------------------------------------------------
 PreferencesPatternPage::PreferencesPatternPage(QWidget *parent)
-    : QWidget(parent),
-      ui(new Ui::PreferencesPatternPage)
+  : QWidget(parent),
+    ui(new Ui::PreferencesPatternPage)
 {
     ui->setupUi(this);
     RetranslateUi();
@@ -85,18 +85,19 @@ PreferencesPatternPage::PreferencesPatternPage(QWidget *parent)
         ui->comboBoxLineWidthUnit->setCurrentIndex(indexUnit);
     }
 
-    connect(ui->comboBoxLineWidthUnit, QOverload<int>::of(&QComboBox::currentIndexChanged), this, [this]()
-    {
-        const Unit lineUnit = static_cast<Unit>(ui->comboBoxLineWidthUnit->currentData().toInt());
-        const qreal value = UnitConvertor(ui->doubleSpinBoxLineWidth->value(), m_oldLineUnit, lineUnit);
-        ui->doubleSpinBoxLineWidth->setDecimals(lineUnit == Unit::Mm ? 1 : 6);
-        ui->doubleSpinBoxLineWidth->setMinimum(UnitConvertor(ui->doubleSpinBoxLineWidth->minimum(), m_oldLineUnit,
-                                                             lineUnit));
-        ui->doubleSpinBoxLineWidth->setMaximum(UnitConvertor(ui->doubleSpinBoxLineWidth->maximum(), m_oldLineUnit,
-                                                             lineUnit));
-        ui->doubleSpinBoxLineWidth->setValue(value);
-        m_oldLineUnit = lineUnit;
-    });
+    connect(ui->comboBoxLineWidthUnit, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
+            [this]()
+            {
+                const Unit lineUnit = static_cast<Unit>(ui->comboBoxLineWidthUnit->currentData().toInt());
+                const qreal value = UnitConvertor(ui->doubleSpinBoxLineWidth->value(), m_oldLineUnit, lineUnit);
+                ui->doubleSpinBoxLineWidth->setDecimals(lineUnit == Unit::Mm ? 1 : 6);
+                ui->doubleSpinBoxLineWidth->setMinimum(
+                    UnitConvertor(ui->doubleSpinBoxLineWidth->minimum(), m_oldLineUnit, lineUnit));
+                ui->doubleSpinBoxLineWidth->setMaximum(
+                    UnitConvertor(ui->doubleSpinBoxLineWidth->maximum(), m_oldLineUnit, lineUnit));
+                ui->doubleSpinBoxLineWidth->setValue(value);
+                m_oldLineUnit = lineUnit;
+            });
 
     m_oldLineUnit = static_cast<Unit>(ui->comboBoxLineWidthUnit->currentData().toInt());
     ui->doubleSpinBoxLineWidth->setDecimals(m_oldLineUnit == Unit::Mm ? 1 : 6);
@@ -111,7 +112,19 @@ PreferencesPatternPage::PreferencesPatternPage(QWidget *parent)
     ui->checkBoxSewLineOnDrawing->setChecked(settings->GetSewLineOnDrawing());
     ui->doublePassmarkCheck->setChecked(settings->IsDoublePassmark());
     ui->checkBoxHideMainPath->setChecked(settings->IsHideMainPath());
-    ui->fontComboBoxLabelFont->setCurrentFont(settings->GetLabelFont());
+
+    QFont labelFont = settings->GetLabelFont();
+    int pointSize = settings->GetPieceLabelFontPointSize();
+    labelFont.setPointSize(pointSize);
+
+    ui->fontComboBoxLabelFont->setCurrentFont(labelFont);
+
+    InitLabelFontSizes();
+    const qint32 indexSize = ui->comboBoxLabelFontSize->findData(pointSize);
+    if (indexSize != -1)
+    {
+        ui->comboBoxLabelFontSize->setCurrentIndex(indexSize);
+    }
 
     ui->checkBoxRemeberPatternMaterials->setChecked(settings->IsRememberPatternMaterials());
     m_knownMaterials = settings->GetKnownMaterials();
@@ -166,6 +179,7 @@ auto PreferencesPatternPage::Apply() -> QStringList
     settings->SetSewLineOnDrawing(ui->checkBoxSewLineOnDrawing->isChecked());
     settings->SetHideMainPath(ui->checkBoxHideMainPath->isChecked());
     settings->SetLabelFont(ui->fontComboBoxLabelFont->currentFont());
+    settings->SetPieceLabelFontPointSize(ui->comboBoxLabelFontSize->currentData().toInt());
 
     if (settings->IsDoublePassmark() != ui->doublePassmarkCheck->isChecked())
     {
@@ -192,7 +206,7 @@ void PreferencesPatternPage::InitDefaultSeamAllowance()
 {
     ui->defaultSeamAllowance->setValue(VAbstractValApplication::VApp()->ValentinaSettings()->GetDefaultSeamAllowance());
     ui->defaultSeamAllowance->setSuffix(
-                UnitsToStr(StrToUnits(VAbstractValApplication::VApp()->ValentinaSettings()->GetUnit()), true));
+        UnitsToStr(StrToUnits(VAbstractValApplication::VApp()->ValentinaSettings()->GetUnit()), true));
 }
 
 //---------------------------------------------------------------------------------------------------------------------
@@ -217,12 +231,12 @@ void PreferencesPatternPage::EditDateTimeFormats()
     if (button == ui->pushButtonEditDateFormats)
     {
         CallDateTimeFormatEditor(QDate::currentDate(), VCommonSettings::PredefinedDateFormats(),
-                           settings->GetUserDefinedDateFormats(), ui->comboBoxDateFormats);
+                                 settings->GetUserDefinedDateFormats(), ui->comboBoxDateFormats);
     }
     else if (button == ui->pushButtonEditTimeFormats)
     {
         CallDateTimeFormatEditor(QTime::currentTime(), VCommonSettings::PredefinedTimeFormats(),
-                           settings->GetUserDefinedTimeFormats(), ui->comboBoxTimeFormats);
+                                 settings->GetUserDefinedTimeFormats(), ui->comboBoxTimeFormats);
     }
 }
 
@@ -254,6 +268,21 @@ void PreferencesPatternPage::InitLabelDateTimeFormats()
     connect(ui->pushButtonEditTimeFormats, &QPushButton::clicked, this, &PreferencesPatternPage::EditDateTimeFormats);
 }
 
+//---------------------------------------------------------------------------------------------------------------------
+void PreferencesPatternPage::InitLabelFontSizes()
+{
+    ui->comboBoxLabelFontSize->clear();
+
+    // Get the available font sizes
+    for (auto size : QFontDatabase::standardSizes())
+    {
+        if (size >= VCommonSettings::MinPieceLabelFontPointSize())
+        {
+            ui->comboBoxLabelFontSize->addItem(QString::number(size), size);
+        }
+    }
+}
+
 //---------------------------------------------------------------------------------------------------------------------
 void PreferencesPatternPage::InitComboBoxFormats(QComboBox *box, const QStringList &items, const QString &currentFormat)
 {

src/app/valentina/dialogs/configpages/preferencespatternpage.h

@@ -29,12 +29,12 @@
 #ifndef PREFERENCESPATTERNPAGE_H
 #define PREFERENCESPATTERNPAGE_H
 
-#include <QWidget>
 #include "../vmisc/def.h"
+#include <QWidget>
 
 namespace Ui
 {
-    class PreferencesPatternPage;
+class PreferencesPatternPage;
 }
 
 class QComboBox;
@@ -51,7 +51,7 @@ public:
     void InitDefaultSeamAllowance();
 
 protected:
-    void changeEvent(QEvent* event) override;
+    void changeEvent(QEvent *event) override;
 
 private slots:
     void EditDateTimeFormats();
@@ -65,6 +65,7 @@ private:
     Unit m_oldLineUnit{Unit::Mm};
 
     void InitLabelDateTimeFormats();
+    void InitLabelFontSizes();
     static void InitComboBoxFormats(QComboBox *box, const QStringList &items, const QString &currentFormat);
     void InitUnits();
     void RetranslateUi();

src/app/valentina/dialogs/configpages/preferencespatternpage.ui

@@ -238,6 +238,29 @@ This option will take an affect after restart.</string>
             <item>
              <widget class="QFontComboBox" name="fontComboBoxLabelFont"/>
             </item>
+            <item>
+             <widget class="QLabel" name="label_8">
+              <property name="text">
+               <string>Size:</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QComboBox" name="comboBoxLabelFontSize"/>
+            </item>
+            <item>
+             <spacer name="horizontalSpacer_4">
+              <property name="orientation">
+               <enum>Qt::Horizontal</enum>
+              </property>
+              <property name="sizeHint" stdset="0">
+               <size>
+                <width>40</width>
+                <height>20</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
            </layout>
           </item>
          </layout>

src/app/valentina/mainwindow.cpp

@@ -2975,7 +2975,7 @@ void MainWindow::ToolBarTools()
     connect(ui->actionIncreaseLabelFont, &QAction::triggered, this, [this]()
     {
         VValentinaSettings *settings = VAbstractValApplication::VApp()->ValentinaSettings();
-        settings->SetLabelFontSize(settings->GetLabelFontSize() + 1);
+        settings->SetPatternLabelFontSize(settings->GetPatternLabelFontSize() + 1);
         if (m_sceneDraw)
         {
             m_sceneDraw->update();
@@ -2996,7 +2996,7 @@ void MainWindow::ToolBarTools()
     connect(ui->actionDecreaseLabelFont, &QAction::triggered, this, [this]()
     {
         VValentinaSettings *settings = VAbstractValApplication::VApp()->ValentinaSettings();
-        settings->SetLabelFontSize(settings->GetLabelFontSize() - 1);
+        settings->SetPatternLabelFontSize(settings->GetPatternLabelFontSize() - 1);
         if (m_sceneDraw)
         {
             m_sceneDraw->update();
@@ -3017,7 +3017,7 @@ void MainWindow::ToolBarTools()
     connect(ui->actionOriginalLabelFont, &QAction::triggered, this, [this]()
     {
         VValentinaSettings *settings = VAbstractValApplication::VApp()->ValentinaSettings();
-        settings->SetLabelFontSize(VCommonSettings::GetDefLabelFontSize());
+        settings->SetPatternLabelFontSize(VCommonSettings::GetDefPatternLabelFontSize());
         if (m_sceneDraw)
         {
             m_sceneDraw->update();

src/libs/vlayout/vlayoutpiece.cpp

@@ -33,7 +33,6 @@
 #include <QFont>
 #include <QFontMetrics>
 #include <QFuture>
-#include <QtConcurrent/QtConcurrentRun>
 #include <QGraphicsPathItem>
 #include <QList>
 #include <QMessageLogger>
@@ -41,9 +40,10 @@
 #include <QPoint>
 #include <QPolygonF>
 #include <QTransform>
-#include <Qt>
-#include <QtDebug>
 #include <QUuid>
+#include <Qt>
+#include <QtConcurrent/QtConcurrentRun>
+#include <QtDebug>
 #include <QtMath>
 
 #include "../vgeometry/vlayoutplacelabel.h"
@@ -106,7 +106,7 @@ auto FindLabelGeometry(const VPatternLabelData &labelData, const VContainer *pat
         Calculator cal1;
         rotationAngle = cal1.EvalFormula(pattern->DataVariables(), labelData.GetRotation());
     }
-    catch(qmu::QmuParserError &e)
+    catch (qmu::QmuParserError &e)
     {
         Q_UNUSED(e);
         return false;
@@ -122,8 +122,8 @@ auto FindLabelGeometry(const VPatternLabelData &labelData, const VContainer *pat
             const auto topLeftPinPoint = pattern->GeometricObject<VPointF>(topLeftPin);
             const auto bottomRightPinPoint = pattern->GeometricObject<VPointF>(bottomRightPin);
 
-            const QRectF labelRect = QRectF(static_cast<QPointF>(*topLeftPinPoint),
-                                            static_cast<QPointF>(*bottomRightPinPoint));
+            const QRectF labelRect =
+                QRectF(static_cast<QPointF>(*topLeftPinPoint), static_cast<QPointF>(*bottomRightPinPoint));
             labelWidth = qAbs(labelRect.width());
             labelHeight = qAbs(labelRect.height());
 
@@ -131,7 +131,7 @@ auto FindLabelGeometry(const VPatternLabelData &labelData, const VContainer *pat
 
             return true;
         }
-        catch(const VExceptionBadId &)
+        catch (const VExceptionBadId &)
         {
             // do nothing.
         }
@@ -147,7 +147,7 @@ auto FindLabelGeometry(const VPatternLabelData &labelData, const VContainer *pat
         labelHeight = cal2.EvalFormula(pattern->DataVariables(), labelData.GetLabelHeight());
         labelHeight = ToPixel(labelHeight, *pattern->GetPatternUnit());
     }
-    catch(qmu::QmuParserError &e)
+    catch (qmu::QmuParserError &e)
     {
         Q_UNUSED(e);
         return false;
@@ -161,7 +161,7 @@ auto FindLabelGeometry(const VPatternLabelData &labelData, const VContainer *pat
             const auto centerPinPoint = pattern->GeometricObject<VPointF>(centerPin);
             pos = static_cast<QPointF>(*centerPinPoint) - QRectF(0, 0, labelWidth, labelHeight).center();
         }
-        catch(const VExceptionBadId &)
+        catch (const VExceptionBadId &)
         {
             pos = labelData.GetPos();
         }
@@ -182,12 +182,12 @@ auto FindLabelGeometry(const VPatternLabelData &labelData, const VContainer *pat
  * @param dAng angle of rotation
  * @return position of point pt after rotating it around the center for dAng radians
  */
-auto RotatePoint(const QPointF &ptCenter, const QPointF& pt, qreal dAng) -> QPointF
+auto RotatePoint(const QPointF &ptCenter, const QPointF &pt, qreal dAng) -> QPointF
 {
     QPointF ptDest;
     QPointF ptRel = pt - ptCenter;
-    ptDest.setX(cos(dAng)*ptRel.x() - sin(dAng)*ptRel.y());
-    ptDest.setY(sin(dAng)*ptRel.x() + cos(dAng)*ptRel.y());
+    ptDest.setX(cos(dAng) * ptRel.x() - sin(dAng) * ptRel.y());
+    ptDest.setY(sin(dAng) * ptRel.x() + cos(dAng) * ptRel.y());
 
     return ptDest + ptCenter;
 }
@@ -214,7 +214,7 @@ auto ConvertPlaceLabels(const VPiece &piece, const VContainer *pattern) -> QVect
     QVector<VLayoutPlaceLabel> labels;
     const auto placeLabels = piece.GetPlaceLabels();
     labels.reserve(placeLabels.size());
-    for(const auto &placeLabel : placeLabels)
+    for (const auto &placeLabel : placeLabels)
     {
         const auto label = pattern->GeometricObject<VPlaceLabelItem>(placeLabel);
         if (label->IsVisible())
@@ -232,8 +232,8 @@ auto ConvertPlaceLabels(const VPiece &piece, const VContainer *pattern) -> QVect
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-auto PrepareSAPassmark(const VPiece &piece, const VContainer *pattern, const VPassmark &passmark,
-                       PassmarkSide side, bool &ok) -> VLayoutPassmark
+auto PrepareSAPassmark(const VPiece &piece, const VContainer *pattern, const VPassmark &passmark, PassmarkSide side,
+                       bool &ok) -> VLayoutPassmark
 {
     QT_WARNING_PUSH
     QT_WARNING_DISABLE_GCC("-Wnoexcept")
@@ -249,10 +249,10 @@ auto PrepareSAPassmark(const VPiece &piece, const VContainer *pattern, const VPa
     if (nodeIndex == -1)
     {
         const QString errorMsg =
-            QObject::tr("Passmark '%1' is not part of piece '%2'.")
-                .arg(pData.nodeName, piece.GetName());
-        VAbstractApplication::VApp()->IsPedantic() ? throw VException(errorMsg) :
-            qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
+            QObject::tr("Passmark '%1' is not part of piece '%2'.").arg(pData.nodeName, piece.GetName());
+        VAbstractApplication::VApp()->IsPedantic()
+            ? throw VException(errorMsg)
+            : qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
         ok = false;
         return {};
     }
@@ -263,8 +263,9 @@ auto PrepareSAPassmark(const VPiece &piece, const VContainer *pattern, const VPa
         const QString errorMsg =
             QObject::tr("Cannot prepare passmark '%1' for piece '%2'. Passmark base line is empty.")
                 .arg(pData.nodeName, piece.GetName());
-        VAbstractApplication::VApp()->IsPedantic() ? throw VException(errorMsg) :
-            qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
+        VAbstractApplication::VApp()->IsPedantic()
+            ? throw VException(errorMsg)
+            : qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
         ok = false;
         return {};
     }
@@ -281,11 +282,11 @@ auto PrepareSAPassmark(const VPiece &piece, const VContainer *pattern, const VPa
     const QVector<QLineF> lines = passmark.SAPassmark(piece, pattern, side);
     if (lines.isEmpty())
     {
-        const QString errorMsg =
-            QObject::tr("Cannot prepare passmark '%1' for piece '%2'. Passmark is empty.")
-                .arg(pData.nodeName, piece.GetName());
-        VAbstractApplication::VApp()->IsPedantic() ? throw VException(errorMsg) :
-            qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
+        const QString errorMsg = QObject::tr("Cannot prepare passmark '%1' for piece '%2'. Passmark is empty.")
+                                     .arg(pData.nodeName, piece.GetName());
+        VAbstractApplication::VApp()->IsPedantic()
+            ? throw VException(errorMsg)
+            : qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
         ok = false;
         return {};
     }
@@ -300,8 +301,8 @@ auto PrepareSAPassmark(const VPiece &piece, const VContainer *pattern, const VPa
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-auto PreapreBuiltInSAPassmark(const VPiece &piece, const VContainer *pattern, const VPassmark &passmark,
-                              bool &ok) -> VLayoutPassmark
+auto PreapreBuiltInSAPassmark(const VPiece &piece, const VContainer *pattern, const VPassmark &passmark, bool &ok)
+    -> VLayoutPassmark
 {
     QT_WARNING_PUSH
     QT_WARNING_DISABLE_GCC("-Wnoexcept")
@@ -317,10 +318,10 @@ auto PreapreBuiltInSAPassmark(const VPiece &piece, const VContainer *pattern, co
     if (nodeIndex == -1)
     {
         const QString errorMsg =
-            QObject::tr("Passmark '%1' is not part of piece '%2'.")
-                .arg(pData.nodeName, piece.GetName());
-        VAbstractApplication::VApp()->IsPedantic() ? throw VException(errorMsg) :
-            qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
+            QObject::tr("Passmark '%1' is not part of piece '%2'.").arg(pData.nodeName, piece.GetName());
+        VAbstractApplication::VApp()->IsPedantic()
+            ? throw VException(errorMsg)
+            : qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
         ok = false;
         return {};
     }
@@ -328,11 +329,11 @@ auto PreapreBuiltInSAPassmark(const VPiece &piece, const VContainer *pattern, co
     const QVector<QLineF> lines = passmark.BuiltInSAPassmark(piece, pattern);
     if (lines.isEmpty())
     {
-        const QString errorMsg =
-            QObject::tr("Cannot prepare builtin passmark '%1' for piece '%2'. Passmark is empty.")
-                .arg(pData.nodeName, piece.GetName());
-        VAbstractApplication::VApp()->IsPedantic() ? throw VException(errorMsg) :
-            qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
+        const QString errorMsg = QObject::tr("Cannot prepare builtin passmark '%1' for piece '%2'. Passmark is empty.")
+                                     .arg(pData.nodeName, piece.GetName());
+        VAbstractApplication::VApp()->IsPedantic()
+            ? throw VException(errorMsg)
+            : qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
         ok = false;
         return {};
     }
@@ -346,13 +347,14 @@ auto PreapreBuiltInSAPassmark(const VPiece &piece, const VContainer *pattern, co
             QObject::tr("Cannot prepare builtin  passmark '%1' for piece '%2'. Passmark base line is "
                         "empty.")
                 .arg(pData.nodeName, piece.GetName());
-        VAbstractApplication::VApp()->IsPedantic() ? throw VException(errorMsg) :
-            qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
+        VAbstractApplication::VApp()->IsPedantic()
+            ? throw VException(errorMsg)
+            : qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
         ok = false;
         return {};
     }
 
-    layoutPassmark.baseLine = ConstFirst (baseLines);
+    layoutPassmark.baseLine = ConstFirst(baseLines);
     layoutPassmark.type = pData.passmarkLineType;
     layoutPassmark.isBuiltIn = true;
     layoutPassmark.isClockwiseOpening = pData.passmarkSAPoint.IsPassmarkClockwiseOpening();
@@ -368,7 +370,7 @@ auto ConvertPassmarks(const VPiece &piece, const VContainer *pattern) -> QVector
     QVector<VLayoutPassmark> layoutPassmarks;
     layoutPassmarks.reserve(passmarks.size());
 
-    for(const auto &passmark : passmarks)
+    for (const auto &passmark : passmarks)
     {
         if (passmark.IsNull())
         {
@@ -403,7 +405,7 @@ auto ConvertPassmarks(const VPiece &piece, const VContainer *pattern) -> QVector
 
         VPiecePassmarkData pData = passmark.Data();
 
-        switch(pData.passmarkAngleType)
+        switch (pData.passmarkAngleType)
         {
             case PassmarkAngleType::Straightforward:
             case PassmarkAngleType::Bisector:
@@ -426,17 +428,14 @@ auto ConvertPassmarks(const VPiece &piece, const VContainer *pattern) -> QVector
                 break;
         }
 
-        if (VAbstractApplication::VApp()->Settings()->IsDoublePassmark()
-                && (VAbstractApplication::VApp()->Settings()->IsPieceShowMainPath() ||
-                    not piece.IsHideMainPath())
-                && pData.isMainPathNode
-                && pData.passmarkAngleType != PassmarkAngleType::Intersection
-                && pData.passmarkAngleType != PassmarkAngleType::IntersectionOnlyLeft
-                && pData.passmarkAngleType != PassmarkAngleType::IntersectionOnlyRight
-                && pData.passmarkAngleType != PassmarkAngleType::Intersection2
-                && pData.passmarkAngleType != PassmarkAngleType::Intersection2OnlyLeft
-                && pData.passmarkAngleType != PassmarkAngleType::Intersection2OnlyRight
-                && pData.isShowSecondPassmark)
+        if (VAbstractApplication::VApp()->Settings()->IsDoublePassmark() &&
+            (VAbstractApplication::VApp()->Settings()->IsPieceShowMainPath() || not piece.IsHideMainPath()) &&
+            pData.isMainPathNode && pData.passmarkAngleType != PassmarkAngleType::Intersection &&
+            pData.passmarkAngleType != PassmarkAngleType::IntersectionOnlyLeft &&
+            pData.passmarkAngleType != PassmarkAngleType::IntersectionOnlyRight &&
+            pData.passmarkAngleType != PassmarkAngleType::Intersection2 &&
+            pData.passmarkAngleType != PassmarkAngleType::Intersection2OnlyLeft &&
+            pData.passmarkAngleType != PassmarkAngleType::Intersection2OnlyRight && pData.isShowSecondPassmark)
         {
             AddBuiltInPassmark();
         }
@@ -487,7 +486,7 @@ auto PrepareGradationPlaceholders(const VContainer *data) -> QMap<QString, QStri
     }
 
     {
-        const QMap<QString, QSharedPointer<VMeasurement> > measurements = data->DataMeasurements();
+        const QMap<QString, QSharedPointer<VMeasurement>> measurements = data->DataMeasurements();
         auto i = measurements.constBegin();
         while (i != measurements.constEnd())
         {
@@ -506,11 +505,11 @@ auto ReplacePlaceholders(const QMap<QString, QString> &placeholders, QString lin
 
     auto TestDimension = [per, placeholders, line](const QString &placeholder, const QString &errorMsg)
     {
-        if (line.contains(per+placeholder+per) && placeholders.value(placeholder) == QChar('0'))
+        if (line.contains(per + placeholder + per) && placeholders.value(placeholder) == QChar('0'))
         {
             VAbstractApplication::VApp()->IsPedantic()
-                    ? throw VException(errorMsg)
-                    : qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
+                ? throw VException(errorMsg)
+                : qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
         }
     };
 
@@ -527,7 +526,7 @@ auto ReplacePlaceholders(const QMap<QString, QString> &placeholders, QString lin
     auto i = placeholders.constBegin();
     while (i != placeholders.constEnd())
     {
-        line.replace(per+i.key()+per, i.value());
+        line.replace(per + i.key() + per, i.value());
         ++i;
     }
     return line;
@@ -539,7 +538,7 @@ auto PrepareGradationId(const QString &label, const VContainer *pattern) -> QStr
     const QMap<QString, QString> placeholders = PrepareGradationPlaceholders(pattern);
     return ReplacePlaceholders(placeholders, label);
 }
-}  // namespace
+} // namespace
 
 // Friend functions
 //---------------------------------------------------------------------------------------------------------------------
@@ -586,18 +585,21 @@ auto operator>>(QDataStream &dataStream, VLayoutPiece &piece) -> QDataStream &
 
 //---------------------------------------------------------------------------------------------------------------------
 VLayoutPiece::VLayoutPiece()
-    :d(new VLayoutPieceData)
-{}
+  : d(new VLayoutPieceData)
+{
+}
 
 //---------------------------------------------------------------------------------------------------------------------
 VLayoutPiece::VLayoutPiece(const VLayoutPiece &detail) // NOLINT(modernize-use-equals-default)
-    :VAbstractPiece(detail), d(detail.d)
-{}
+  : VAbstractPiece(detail),
+    d(detail.d)
+{
+}
 
 //---------------------------------------------------------------------------------------------------------------------
 auto VLayoutPiece::operator=(const VLayoutPiece &detail) -> VLayoutPiece &
 {
-    if ( &detail == this )
+    if (&detail == this)
     {
         return *this;
     }
@@ -608,12 +610,13 @@ auto VLayoutPiece::operator=(const VLayoutPiece &detail) -> VLayoutPiece &
 
 #ifdef Q_COMPILER_RVALUE_REFS
 //---------------------------------------------------------------------------------------------------------------------
-VLayoutPiece::VLayoutPiece(VLayoutPiece &&detail) Q_DECL_NOTHROW
-    :VAbstractPiece(std::move(detail)), d(std::move(detail.d))
-{}
+VLayoutPiece::VLayoutPiece(VLayoutPiece &&detail) Q_DECL_NOTHROW : VAbstractPiece(std::move(detail)),
+                                                                   d(std::move(detail.d))
+{
+}
 
 //---------------------------------------------------------------------------------------------------------------------
-auto VLayoutPiece::operator=(VLayoutPiece &&detail) Q_DECL_NOTHROW -> VLayoutPiece &
+auto VLayoutPiece::operator=(VLayoutPiece &&detail) Q_DECL_NOTHROW->VLayoutPiece &
 {
     VAbstractPiece::operator=(detail);
     std::swap(d, detail.d);
@@ -622,21 +625,22 @@ auto VLayoutPiece::operator=(VLayoutPiece &&detail) Q_DECL_NOTHROW -> VLayoutPie
 #endif
 
 //---------------------------------------------------------------------------------------------------------------------
-VLayoutPiece::~VLayoutPiece() //NOLINT(modernize-use-equals-default)
-{}
+VLayoutPiece::~VLayoutPiece() // NOLINT(modernize-use-equals-default)
+{
+}
 
 //---------------------------------------------------------------------------------------------------------------------
 auto VLayoutPiece::Create(const VPiece &piece, vidtype id, const VContainer *pattern) -> VLayoutPiece
 {
-    QFuture<QVector<VLayoutPoint> > futureSeamAllowance =
-        QtConcurrent::run([piece, pattern](){return piece.SeamAllowancePoints(pattern);});
+    QFuture<QVector<VLayoutPoint>> futureSeamAllowance =
+        QtConcurrent::run([piece, pattern]() { return piece.SeamAllowancePoints(pattern); });
     QFuture<bool> futureSeamAllowanceValid =
-        QtConcurrent::run([piece, pattern](){return piece.IsSeamAllowanceValid(pattern);});
-    QFuture<QVector<VLayoutPoint> > futureMainPath =
-        QtConcurrent::run([piece, pattern](){return piece.MainPathPoints(pattern);});
-    QFuture<QVector<VLayoutPiecePath> > futureInternalPaths = QtConcurrent::run(ConvertInternalPaths, piece, pattern);
-    QFuture<QVector<VLayoutPassmark> > futurePassmarks = QtConcurrent::run(ConvertPassmarks, piece, pattern);
-    QFuture<QVector<VLayoutPlaceLabel> > futurePlaceLabels = QtConcurrent::run(ConvertPlaceLabels, piece, pattern);
+        QtConcurrent::run([piece, pattern]() { return piece.IsSeamAllowanceValid(pattern); });
+    QFuture<QVector<VLayoutPoint>> futureMainPath =
+        QtConcurrent::run([piece, pattern]() { return piece.MainPathPoints(pattern); });
+    QFuture<QVector<VLayoutPiecePath>> futureInternalPaths = QtConcurrent::run(ConvertInternalPaths, piece, pattern);
+    QFuture<QVector<VLayoutPassmark>> futurePassmarks = QtConcurrent::run(ConvertPassmarks, piece, pattern);
+    QFuture<QVector<VLayoutPlaceLabel>> futurePlaceLabels = QtConcurrent::run(ConvertPlaceLabels, piece, pattern);
 
     VLayoutPiece det;
 
@@ -655,15 +659,15 @@ auto VLayoutPiece::Create(const VPiece &piece, vidtype id, const VContainer *pat
 
     if (not futureSeamAllowanceValid.result())
     {
-        const QString errorMsg = QObject::tr("Piece '%1'. Seam allowance is not valid.")
-                .arg(piece.GetName());
-        VAbstractApplication::VApp()->IsPedantic() ? throw VException(errorMsg) :
-                                              qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
+        const QString errorMsg = QObject::tr("Piece '%1'. Seam allowance is not valid.").arg(piece.GetName());
+        VAbstractApplication::VApp()->IsPedantic()
+            ? throw VException(errorMsg)
+            : qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
     }
 
-    det.SetContourPoints(futureMainPath.result(),
-                          VAbstractApplication::VApp()->Settings()->IsPieceShowMainPath() ? false
-                                                                                          : piece.IsHideMainPath());
+    det.SetContourPoints(futureMainPath.result(), VAbstractApplication::VApp()->Settings()->IsPieceShowMainPath()
+                                                      ? false
+                                                      : piece.IsHideMainPath());
     det.SetSeamAllowancePoints(futureSeamAllowance.result(), piece.IsSeamAllowance(), piece.IsSeamAllowanceBuiltIn());
     det.SetInternalPaths(futureInternalPaths.result());
     det.SetPassmarks(futurePassmarks.result());
@@ -673,24 +677,24 @@ auto VLayoutPiece::Create(const VPiece &piece, vidtype id, const VContainer *pat
     // Very important to set main path first!
     if (det.MappedContourPath().isEmpty())
     {
-        throw VException (tr("Piece %1 doesn't have shape.").arg(piece.GetName()));
+        throw VException(tr("Piece %1 doesn't have shape.").arg(piece.GetName()));
     }
 
-    const VPieceLabelData& data = piece.GetPieceLabelData();
+    const VPieceLabelData &data = piece.GetPieceLabelData();
     det.SetQuantity(data.GetQuantity());
     if (data.IsVisible())
     {
         det.SetPieceText(piece.GetName(), data, VAbstractApplication::VApp()->Settings()->GetLabelFont(), pattern);
     }
 
-    const VPatternLabelData& geom = piece.GetPatternLabelData();
+    const VPatternLabelData &geom = piece.GetPatternLabelData();
     if (geom.IsVisible())
     {
-        VAbstractPattern* pDoc = VAbstractValApplication::VApp()->getCurrentDocument();
+        VAbstractPattern *pDoc = VAbstractValApplication::VApp()->getCurrentDocument();
         det.SetPatternInfo(pDoc, geom, VAbstractApplication::VApp()->Settings()->GetLabelFont(), pattern);
     }
 
-    const VGrainlineData& grainlineGeom = piece.GetGrainlineGeometry();
+    const VGrainlineData &grainlineGeom = piece.GetGrainlineGeometry();
     if (grainlineGeom.IsVisible())
     {
         det.SetGrainline(grainlineGeom, pattern);
@@ -713,8 +717,7 @@ auto VLayoutPiece::GetUniqueID() const -> QString
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-template <class T>
-auto VLayoutPiece::Map(QVector<T> points) const -> QVector<T>
+template <class T> auto VLayoutPiece::Map(QVector<T> points) const -> QVector<T>
 {
     std::transform(points.begin(), points.end(), points.begin(),
                    [this](const T &point) { return d->m_matrix.map(point); });
@@ -729,7 +732,7 @@ auto VLayoutPiece::Map(QVector<T> points) const -> QVector<T>
 template <> // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name)
 auto VLayoutPiece::Map<VLayoutPassmark>(QVector<VLayoutPassmark> passmarks) const -> QVector<VLayoutPassmark>
 {
-    for (auto & passmark : passmarks)
+    for (auto &passmark : passmarks)
     {
         passmark.lines = Map(passmark.lines);
         passmark.baseLine = d->m_matrix.map(passmark.baseLine);
@@ -739,17 +742,17 @@ auto VLayoutPiece::Map<VLayoutPassmark>(QVector<VLayoutPassmark> passmarks) cons
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-template <>
-auto VLayoutPiece::Map<VLayoutPoint>(QVector<VLayoutPoint> points) const -> QVector<VLayoutPoint>
+template <> auto VLayoutPiece::Map<VLayoutPoint>(QVector<VLayoutPoint> points) const -> QVector<VLayoutPoint>
 {
-    std::transform(points.begin(), points.end(), points.begin(), [this](VLayoutPoint point)
-    {
-        auto p = static_cast<QPointF>(point); // NOLINT(cppcoreguidelines-slicing)
-        p = d->m_matrix.map(p);
-        point.rx() = p.x();
-        point.ry() = p.y();
-        return point;
-    });
+    std::transform(points.begin(), points.end(), points.begin(),
+                   [this](VLayoutPoint point)
+                   {
+                       auto p = static_cast<QPointF>(point); // NOLINT(cppcoreguidelines-slicing)
+                       p = d->m_matrix.map(p);
+                       point.rx() = p.x();
+                       point.ry() = p.y();
+                       return point;
+                   });
     if (d->m_mirror)
     {
         std::reverse(points.begin(), points.end());
@@ -818,7 +821,7 @@ void VLayoutPiece::SetSeamAllowancePoints(const QVector<VLayoutPoint> &points, b
         }
         else if (not IsSeamAllowanceBuiltIn())
         {
-            qWarning()<<"Seam allowance is empty.";
+            qWarning() << "Seam allowance is empty.";
             SetSeamAllowance(false);
         }
     }
@@ -854,7 +857,7 @@ auto VLayoutPiece::GetPieceText() const -> QStringList
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-void VLayoutPiece::SetPieceText(const QString& qsName, const VPieceLabelData& data, const QFont &font,
+void VLayoutPiece::SetPieceText(const QString &qsName, const VPieceLabelData &data, const QFont &font,
                                 const VContainer *pattern)
 {
     QPointF ptPos;
@@ -866,14 +869,12 @@ void VLayoutPiece::SetPieceText(const QString& qsName, const VPieceLabelData& da
         return;
     }
 
-    QVector<QPointF> v;
-    v << ptPos
-      << QPointF(ptPos.x() + labelWidth, ptPos.y())
-      << QPointF(ptPos.x() + labelWidth, ptPos.y() + labelHeight)
-      << QPointF(ptPos.x(), ptPos.y() + labelHeight);
+    QVector<QPointF> v{ptPos, QPointF(ptPos.x() + labelWidth, ptPos.y()),
+                       QPointF(ptPos.x() + labelWidth, ptPos.y() + labelHeight),
+                       QPointF(ptPos.x(), ptPos.y() + labelHeight)};
 
     const qreal dAng = qDegreesToRadians(-labelAngle);
-    const QPointF ptCenter(ptPos.x() + labelWidth/2, ptPos.y() + labelHeight/2);
+    const QPointF ptCenter(ptPos.x() + labelWidth / 2, ptPos.y() + labelHeight / 2);
 
     for (int i = 0; i < v.count(); ++i)
     {
@@ -885,11 +886,15 @@ void VLayoutPiece::SetPieceText(const QString& qsName, const VPieceLabelData& da
 
     // generate text
     d->m_tmDetail.SetFont(font);
-    d->m_tmDetail.SetFontSize(data.GetFontSize());
+
+    int fntSize = data.GetFontSize();
+    if (fntSize == 0)
+    {
+        fntSize = VAbstractApplication::VApp()->Settings()->GetPieceLabelFontPointSize();
+    }
+    d->m_tmDetail.SetFontSize(fntSize);
+
     d->m_tmDetail.Update(qsName, data, pattern);
-    // this will generate the lines of text
-    d->m_tmDetail.SetFontSize(data.GetFontSize());
-    d->m_tmDetail.FitFontSize(labelWidth, labelHeight);
 }
 
 //---------------------------------------------------------------------------------------------------------------------
@@ -934,7 +939,7 @@ auto VLayoutPiece::GetPatternText() const -> QStringList
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-void VLayoutPiece::SetPatternInfo(VAbstractPattern* pDoc, const VPatternLabelData& geom, const QFont &font,
+void VLayoutPiece::SetPatternInfo(VAbstractPattern *pDoc, const VPatternLabelData &geom, const QFont &font,
                                   const VContainer *pattern)
 {
     QPointF ptPos;
@@ -946,14 +951,12 @@ void VLayoutPiece::SetPatternInfo(VAbstractPattern* pDoc, const VPatternLabelDat
         return;
     }
 
-    QVector<QPointF> v;
-    v << ptPos
-      << QPointF(ptPos.x() + labelWidth, ptPos.y())
-      << QPointF(ptPos.x() + labelWidth, ptPos.y() + labelHeight)
-      << QPointF(ptPos.x(), ptPos.y() + labelHeight);
+    QVector<QPointF> v{ptPos, QPointF(ptPos.x() + labelWidth, ptPos.y()),
+                       QPointF(ptPos.x() + labelWidth, ptPos.y() + labelHeight),
+                       QPointF(ptPos.x(), ptPos.y() + labelHeight)};
 
     const qreal dAng = qDegreesToRadians(-labelAngle);
-    const QPointF ptCenter(ptPos.x() + labelWidth/2, ptPos.y() + labelHeight/2);
+    const QPointF ptCenter(ptPos.x() + labelWidth / 2, ptPos.y() + labelHeight / 2);
     for (int i = 0; i < v.count(); ++i)
     {
         v[i] = RotatePoint(ptCenter, v.at(i), dAng);
@@ -963,13 +966,15 @@ void VLayoutPiece::SetPatternInfo(VAbstractPattern* pDoc, const VPatternLabelDat
 
     // Generate text
     d->m_tmPattern.SetFont(font);
-    d->m_tmPattern.SetFontSize(geom.GetFontSize());
+
+    int fntSize = geom.GetFontSize();
+    if (fntSize == 0)
+    {
+        fntSize = VAbstractApplication::VApp()->Settings()->GetPieceLabelFontPointSize();
+    }
+    d->m_tmPattern.SetFontSize(fntSize);
 
     d->m_tmPattern.Update(pDoc, pattern);
-
-    // generate lines of text
-    d->m_tmPattern.SetFontSize(geom.GetFontSize());
-    d->m_tmPattern.FitFontSize(labelWidth, labelHeight);
 }
 
 //---------------------------------------------------------------------------------------------------------------------
@@ -1003,7 +1008,7 @@ void VLayoutPiece::SetGrainline(const VPieceGrainline &grainline)
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-void VLayoutPiece::SetGrainline(const VGrainlineData& geom, const VContainer* pattern)
+void VLayoutPiece::SetGrainline(const VGrainlineData &geom, const VContainer *pattern)
 {
     QScopedPointer<QGraphicsItem> item(GetMainPathItem());
 
@@ -1154,13 +1159,13 @@ void VLayoutPiece::Mirror(const QLineF &edge)
 
     m.reset();
     m.translate(p2.x(), p2.y());
-    m.scale(m.m11(), m.m22()*-1);
+    m.scale(m.m11(), m.m22() * -1);
     m.translate(-p2.x(), -p2.y());
     d->m_matrix *= m;
 
     m.reset();
     m.translate(p2.x(), p2.y());
-    m.rotate(-(360-angle));
+    m.rotate(-(360 - angle));
     m.translate(-p2.x(), -p2.y());
     d->m_matrix *= m;
 
@@ -1235,7 +1240,7 @@ auto VLayoutPiece::isNull() const -> bool
 {
     if (not d->m_contour.isEmpty() && d->m_layoutWidth > 0)
     {
-        return not (IsSeamAllowance() && not IsSeamAllowanceBuiltIn() && not d->m_seamAllowance.isEmpty());
+        return not(IsSeamAllowance() && not IsSeamAllowanceBuiltIn() && not d->m_seamAllowance.isEmpty());
     }
     return true;
 }
@@ -1264,7 +1269,7 @@ void VLayoutPiece::SetLayoutAllowancePoints()
 
                 QVector<QPointF> points;
                 CastTo(GetSeamAllowancePoints(), points);
-                d->m_square = qFloor(qAbs(SumTrapezoids(points)/2.0));
+                d->m_square = qFloor(qAbs(SumTrapezoids(points) / 2.0));
             }
         }
         else
@@ -1278,7 +1283,7 @@ void VLayoutPiece::SetLayoutAllowancePoints()
 
                 QVector<QPointF> points;
                 CastTo(GetContourPoints(), points);
-                d->m_square = qFloor(qAbs(SumTrapezoids(points)/2.0));
+                d->m_square = qFloor(qAbs(SumTrapezoids(points) / 2.0));
             }
         }
     }
@@ -1291,15 +1296,14 @@ void VLayoutPiece::SetLayoutAllowancePoints()
 //---------------------------------------------------------------------------------------------------------------------
 auto VLayoutPiece::GetMappedExternalContourPoints() const -> QVector<VLayoutPoint>
 {
-    return IsSeamAllowance() && not IsSeamAllowanceBuiltIn() ? GetMappedSeamAllowancePoints() :
-                                                               GetMappedContourPoints();
+    return IsSeamAllowance() && not IsSeamAllowanceBuiltIn() ? GetMappedSeamAllowancePoints()
+                                                             : GetMappedContourPoints();
 }
 
 //---------------------------------------------------------------------------------------------------------------------
 auto VLayoutPiece::GetExternalContourPoints() const -> QVector<VLayoutPoint>
 {
-    return IsSeamAllowance() && not IsSeamAllowanceBuiltIn() ? GetSeamAllowancePoints() :
-                                                               GetContourPoints();
+    return IsSeamAllowance() && not IsSeamAllowanceBuiltIn() ? GetSeamAllowancePoints() : GetContourPoints();
 }
 
 //---------------------------------------------------------------------------------------------------------------------
@@ -1336,9 +1340,9 @@ void VLayoutPiece::SetPlaceLabels(const QVector<VLayoutPlaceLabel> &labels)
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-auto VLayoutPiece::MappedInternalPathsForCut(bool cut) const -> QVector<QVector<VLayoutPoint> >
+auto VLayoutPiece::MappedInternalPathsForCut(bool cut) const -> QVector<QVector<VLayoutPoint>>
 {
-    QVector<QVector<VLayoutPoint> > paths;
+    QVector<QVector<VLayoutPoint>> paths;
     paths.reserve(d->m_internalPaths.size());
 
     for (const auto &path : d->m_internalPaths)
@@ -1391,7 +1395,7 @@ auto VLayoutPiece::ContourPath() const -> QPainterPath
 
             if (ConstLast(points).toPoint() != ConstFirst(points).toPoint())
             {
-                points.append(points.at(0));// Should be always closed
+                points.append(points.at(0)); // Should be always closed
             }
 
             QPainterPath ekv;
@@ -1407,7 +1411,7 @@ auto VLayoutPiece::ContourPath() const -> QPainterPath
         // Draw passmarks
         QPainterPath passmaksPath;
         const QVector<VLayoutPassmark> passmarks = GetPassmarks();
-        for(const auto &passmark : passmarks)
+        for (const auto &passmark : passmarks)
         {
             for (const auto &line : passmark.lines)
             {
@@ -1462,7 +1466,7 @@ auto VLayoutPiece::GetItem(bool textAsPaths) const -> QGraphicsItem *
 
     for (const auto &path : d->m_internalPaths)
     {
-        auto* pathItem = new QGraphicsPathItem(item);
+        auto *pathItem = new QGraphicsPathItem(item);
         pathItem->setPath(d->m_matrix.map(path.GetPainterPath()));
 
         QPen pen = pathItem->pen();
@@ -1473,7 +1477,7 @@ auto VLayoutPiece::GetItem(bool textAsPaths) const -> QGraphicsItem *
 
     for (const auto &label : d->m_placeLabels)
     {
-        auto* pathItem = new QGraphicsPathItem(item);
+        auto *pathItem = new QGraphicsPathItem(item);
         QPen pen = pathItem->pen();
         pen.setWidthF(VAbstractApplication::VApp()->Settings()->WidthHairLine());
         pathItem->setPen(pen);
@@ -1490,8 +1494,8 @@ auto VLayoutPiece::GetItem(bool textAsPaths) const -> QGraphicsItem *
 //---------------------------------------------------------------------------------------------------------------------
 auto VLayoutPiece::IsLayoutAllowanceValid() const -> bool
 {
-    QVector<VLayoutPoint> base = (IsSeamAllowance() && not IsSeamAllowanceBuiltIn()) ?
-                                     d->m_seamAllowance : d->m_contour;
+    QVector<VLayoutPoint> base =
+        (IsSeamAllowance() && not IsSeamAllowanceBuiltIn()) ? d->m_seamAllowance : d->m_contour;
     QVector<QPointF> points;
     CastTo(base, points);
     return VAbstractPiece::IsAllowanceValid(points, d->m_layoutAllowance);
@@ -1519,11 +1523,10 @@ auto VLayoutPiece::BiggestEdge() const -> qreal
     return edge;
 }
 
-
 //---------------------------------------------------------------------------------------------------------------------
 auto VLayoutPiece::MapPlaceLabelShape(PlaceLabelImg shape) const -> PlaceLabelImg
 {
-    for (auto & i : shape)
+    for (auto &i : shape)
     {
         i = Map(i);
     }
@@ -1556,8 +1559,8 @@ auto VLayoutPiece::GrainlinePath(const GrainlineShape &shape) -> QPainterPath
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-void VLayoutPiece::CreateLabelStrings(QGraphicsItem *parent, const QVector<QPointF> &labelShape,
-                                      const VTextManager &tm, bool textAsPaths) const
+void VLayoutPiece::CreateLabelStrings(QGraphicsItem *parent, const QVector<QPointF> &labelShape, const VTextManager &tm,
+                                      bool textAsPaths) const
 {
     SCASSERT(parent != nullptr)
 
@@ -1568,14 +1571,15 @@ void VLayoutPiece::CreateLabelStrings(QGraphicsItem *parent, const QVector<QPoin
 
     const qreal dW = QLineF(labelShape.at(0), labelShape.at(1)).length();
     const qreal dH = QLineF(labelShape.at(1), labelShape.at(2)).length();
-    const qreal angle = - QLineF(labelShape.at(0), labelShape.at(1)).angle();
+    const qreal angle = -QLineF(labelShape.at(0), labelShape.at(1)).angle();
     qreal dY = 0;
 
-    for (int i = 0; i < tm.GetSourceLinesCount(); ++i)
+    const QVector<TextLine> labelLines = tm.GetLabelSourceLines(qFloor(dW), tm.GetFont());
+
+    for (const auto &tl : labelLines)
     {
-        const TextLine& tl = tm.GetSourceLine(i);
         QFont fnt = tm.GetFont();
-        fnt.setPixelSize(tm.GetFont().pixelSize() + tl.m_iFontSize);
+        fnt.setPointSize(tm.GetFont().pointSize() + tl.m_iFontSize);
         fnt.setBold(tl.m_bold);
         fnt.setItalic(tl.m_italic);
 
@@ -1584,19 +1588,21 @@ void VLayoutPiece::CreateLabelStrings(QGraphicsItem *parent, const QVector<QPoin
         if (textAsPaths)
         {
             dY += fm.height();
-        }
 
-        if (dY > dH)
+            if (dY > dH)
+            {
+                break;
+            }
+        }
+        else
         {
-            break;
+            if (dY + fm.height() > dH)
+            {
+                break;
+            }
         }
 
         QString qsText = tl.m_qsText;
-        if (TextWidth(fm, qsText) > dW)
-        {
-            qsText = fm.elidedText(qsText, Qt::ElideMiddle, static_cast<int>(dW));
-        }
-
         qreal dX = 0;
         if (tl.m_eAlign == 0 || (tl.m_eAlign & Qt::AlignLeft) > 0)
         {
@@ -1604,7 +1610,7 @@ void VLayoutPiece::CreateLabelStrings(QGraphicsItem *parent, const QVector<QPoin
         }
         else if ((tl.m_eAlign & Qt::AlignHCenter) > 0)
         {
-            dX = (dW - TextWidth(fm, qsText))/2;
+            dX = (dW - TextWidth(fm, qsText)) / 2;
         }
         else if ((tl.m_eAlign & Qt::AlignRight) > 0)
         {
@@ -1632,9 +1638,9 @@ void VLayoutPiece::CreateLabelStrings(QGraphicsItem *parent, const QVector<QPoin
         if (textAsPaths)
         {
             QPainterPath path;
-            path.addText(0, - static_cast<qreal>(fm.ascent())/6., fnt, qsText);
+            path.addText(0, -static_cast<qreal>(fm.ascent()) / 6., fnt, qsText);
 
-            auto* item = new QGraphicsPathItem(parent);
+            auto *item = new QGraphicsPathItem(parent);
             item->setPath(path);
             item->setBrush(QBrush(Qt::black));
             item->setTransform(labelMatrix);
@@ -1643,7 +1649,7 @@ void VLayoutPiece::CreateLabelStrings(QGraphicsItem *parent, const QVector<QPoin
         }
         else
         {
-            auto* item = new QGraphicsSimpleTextItem(parent);
+            auto *item = new QGraphicsSimpleTextItem(parent);
             item->setFont(fnt);
             item->setText(qsText);
             item->setTransform(labelMatrix);
@@ -1772,12 +1778,12 @@ auto VLayoutPiece::Edge(const QVector<QPointF> &path, int i) const -> QLineF
     vsizetype i1, i2;
     if (i < path.count())
     {
-        i1 = i-1;
+        i1 = i - 1;
         i2 = i;
     }
     else
     {
-        i1 = path.count()-1;
+        i1 = path.count() - 1;
         i2 = 0;
     }
 
@@ -1799,7 +1805,7 @@ auto VLayoutPiece::EdgeByPoint(const QVector<QPointF> &path, const QPointF &p1)
 
     const QVector<QPointF> points = Map(path);
     auto posIter = std::find_if(points.cbegin(), points.cend(),
-                                [&p1](const QPointF &point){ return VFuzzyComparePoints(point, p1); });
+                                [&p1](const QPointF &point) { return VFuzzyComparePoints(point, p1); });
     if (posIter != points.cend())
     {
         return static_cast<int>(posIter - points.cbegin() + 1);

src/libs/vlayout/vtextmanager.cpp

@@ -38,7 +38,9 @@
 #include <QtMath>
 
 #include "../ifc/xml/vabstractpattern.h"
+#include "../vmisc/compatibility.h"
 #include "../vmisc/vabstractvalapplication.h"
+#include "../vmisc/vcommonsettings.h"
 #include "../vpatterndb/floatItemData/vpiecelabeldata.h"
 
 #if QT_VERSION < QT_VERSION_CHECK(5, 9, 0)
@@ -50,6 +52,49 @@
 #include "../vpatterndb/vcontainer.h"
 #include "vtextmanager.h"
 
+namespace
+{
+auto SplitTextByWidth(const QString &text, const QFont &font, int maxWidth) -> QStringList
+{
+    QFontMetrics fontMetrics(font);
+    if (TextWidth(fontMetrics, text) <= maxWidth)
+    {
+        return {text};
+    }
+
+    QStringList substrings;
+    substrings.reserve(2);
+
+    const int textLength = static_cast<int>(text.length());
+    int lineWidth = 0;
+
+    for (int endIndex = 0; endIndex < textLength; ++endIndex)
+    {
+        QChar currentChar = text.at(endIndex);
+        const int charWidth = TextWidth(fontMetrics, currentChar);
+
+        if (lineWidth + charWidth > maxWidth)
+        {
+            if (endIndex > 0)
+            {
+                substrings.append(text.mid(0, endIndex));
+            }
+
+            if (endIndex < textLength)
+            {
+                substrings.append(text.mid(endIndex));
+            }
+
+            break;
+        }
+
+        lineWidth += charWidth;
+    }
+
+    return substrings;
+}
+} // namespace
+
 const quint32 TextLine::streamHeader = 0xA3881E49; // CRC-32Q string "TextLine"
 const quint16 TextLine::classVersion = 1;
 
@@ -117,7 +162,7 @@ const quint16 VTextManager::classVersion = 1;
 
 namespace
 {
-Q_GLOBAL_STATIC(QVector<TextLine>, m_patternLabelLines) // NOLINT
+Q_GLOBAL_STATIC(QVector<TextLine>, m_patternLabelLinesCache) // NOLINT
 }
 
 // Friend functions
@@ -487,7 +532,9 @@ auto VTextManager::GetFont() const -> const QFont &
  */
 void VTextManager::SetFontSize(int iFS)
 {
-    iFS < MIN_FONT_SIZE ? m_font.setPixelSize(MIN_FONT_SIZE) : m_font.setPixelSize(iFS);
+    iFS < VCommonSettings::MinPieceLabelFontPointSize()
+        ? m_font.setPointSize(VCommonSettings::MinPieceLabelFontPointSize())
+        : m_font.setPointSize(iFS);
 }
 
 //---------------------------------------------------------------------------------------------------------------------
@@ -525,6 +572,40 @@ auto VTextManager::GetSourceLine(vsizetype i) const -> const TextLine &
     return m_liLines.at(i);
 }
 
+//---------------------------------------------------------------------------------------------------------------------
+auto VTextManager::GetLabelSourceLines(int width, const QFont &font) const -> QVector<TextLine>
+{
+    QVector<TextLine> lines;
+    lines.reserve(m_liLines.size());
+    QFont fnt = font;
+    int fSize = m_font.pointSize();
+
+    for (const auto &tl : m_liLines)
+    {
+        fnt.setPointSize(fSize + tl.m_iFontSize);
+        fnt.setBold(tl.m_bold);
+        fnt.setItalic(tl.m_italic);
+
+        QString qsText = tl.m_qsText;
+        QFontMetrics fm(fnt);
+        if (TextWidth(fm, qsText) > width)
+        {
+            const QStringList brokeLines = BreakTextIntoLines(qsText, fnt, width);
+            for (const auto &lineText : brokeLines)
+            {
+                TextLine line = tl;
+                line.m_qsText = lineText;
+                lines.append(line);
+            }
+        }
+        else
+        {
+            lines.append(tl);
+        }
+    }
+    return lines;
+}
+
 //---------------------------------------------------------------------------------------------------------------------
 auto VTextManager::MaxLineWidth(int width) const -> int
 {
@@ -534,7 +615,7 @@ auto VTextManager::MaxLineWidth(int width) const -> int
         const TextLine &tl = m_liLines.at(i);
 
         QFont fnt = m_font;
-        fnt.setPixelSize(fnt.pixelSize() + tl.m_iFontSize);
+        fnt.setPointSize(fnt.pointSize() + tl.m_iFontSize);
         fnt.setBold(tl.m_bold);
         fnt.setItalic(tl.m_italic);
 
@@ -553,64 +634,6 @@ auto VTextManager::MaxLineWidth(int width) const -> int
     return maxWidth;
 }
 
-//---------------------------------------------------------------------------------------------------------------------
-/**
- * @brief VTextManager::FitFontSize sets the font size just big enough, so that the text fits into rectangle of
- * size (fW, fH)
- * @param fW rectangle width
- * @param fH rectangle height
- */
-void VTextManager::FitFontSize(qreal fW, qreal fH)
-{
-    int iFS = 0;
-    if (GetSourceLinesCount() > 0)
-    { // division by zero
-        iFS = 3 * qFloor(fH / static_cast<int>(GetSourceLinesCount())) / 4;
-    }
-
-    if (iFS < MIN_FONT_SIZE)
-    {
-        iFS = MIN_FONT_SIZE;
-    }
-
-    // get ratio between char width and height
-
-    int iMaxLen = 0;
-    TextLine maxLine;
-    QFont fnt;
-    for (vsizetype i = 0; i < GetSourceLinesCount(); ++i)
-    {
-        const TextLine &tl = GetSourceLine(i);
-        fnt = m_font;
-        fnt.setPixelSize(iFS + tl.m_iFontSize);
-        fnt.setBold(tl.m_bold);
-        fnt.setItalic(tl.m_italic);
-        QFontMetrics fm(fnt);
-        const int iTW = TextWidth(fm, tl.m_qsText);
-        if (iTW > iMaxLen)
-        {
-            iMaxLen = iTW;
-            maxLine = tl;
-        }
-    }
-    if (iMaxLen > fW)
-    {
-        QFont fnt = m_font;
-        fnt.setBold(maxLine.m_bold);
-        fnt.setItalic(maxLine.m_italic);
-
-        int lineLength = 0;
-        do
-        {
-            --iFS;
-            fnt.setPixelSize(iFS + maxLine.m_iFontSize);
-            QFontMetrics fm(fnt);
-            lineLength = TextWidth(fm, maxLine.m_qsText);
-        } while (lineLength > fW && iFS > MIN_FONT_SIZE);
-    }
-    SetFontSize(iFS);
-}
-
 //---------------------------------------------------------------------------------------------------------------------
 /**
  * @brief VTextManager::Update updates the text lines with detail data
@@ -644,10 +667,10 @@ void VTextManager::Update(VAbstractPattern *pDoc, const VContainer *pattern)
 {
     m_liLines.clear();
 
-    if (m_patternLabelLines->isEmpty() || pDoc->GetPatternWasChanged())
+    if (m_patternLabelLinesCache->isEmpty() || pDoc->GetPatternWasChanged())
     {
         QVector<VLabelTemplateLine> lines = pDoc->GetPatternLabelTemplate();
-        if (lines.isEmpty() && m_patternLabelLines->isEmpty())
+        if (lines.isEmpty() && m_patternLabelLinesCache->isEmpty())
         {
             return; // Nothing to parse
         }
@@ -660,8 +683,98 @@ void VTextManager::Update(VAbstractPattern *pDoc, const VContainer *pattern)
         }
 
         pDoc->SetPatternWasChanged(false);
-        *m_patternLabelLines = PrepareLines(lines);
+        *m_patternLabelLinesCache = PrepareLines(lines);
     }
 
-    m_liLines = *m_patternLabelLines;
+    m_liLines = *m_patternLabelLinesCache;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VTextManager::BreakTextIntoLines(const QString &text, const QFont &font, int maxWidth) const -> QStringList
+{
+    QFontMetrics fontMetrics(font);
+    QStringList words = text.split(' ');
+
+    QString currentLine;
+    int currentLineWidth = 0;
+    const int spaceWidth = TextWidth(fontMetrics, QChar(' '));
+    const float tolerance = 0.3F;
+
+    QStringList lines;
+    lines.reserve(words.size());
+    QMutableListIterator<QString> iterator(words);
+
+    auto AppendWord = [&currentLine, &currentLineWidth](const QString &word, int totalWidth)
+    {
+        if (!currentLine.isEmpty())
+        {
+            currentLine += QChar(' ');
+        }
+        currentLine += word;
+        currentLineWidth = totalWidth;
+    };
+
+    while (iterator.hasNext())
+    {
+        const QString &word = iterator.next();
+        int wordWidth = TextWidth(fontMetrics, word);
+        int totalWidth = !currentLine.isEmpty() ? currentLineWidth + spaceWidth + wordWidth : wordWidth;
+
+        if (totalWidth <= maxWidth)
+        {
+            // Append the word to the current line
+            AppendWord(word, totalWidth);
+        }
+        else if ((maxWidth - currentLineWidth) <= qRound(static_cast<float>(maxWidth) * tolerance) &&
+                 maxWidth >= wordWidth)
+        {
+            // Start a new line with the word if it doesn't exceed the tolerance
+            lines.append(currentLine);
+            currentLine = word;
+            currentLineWidth = wordWidth;
+        }
+        else
+        {
+            // Word is too long, force line break
+            if (currentLineWidth + spaceWidth + TextWidth(fontMetrics, word.at(0)) > maxWidth)
+            {
+                lines.append(currentLine);
+                currentLine.clear();
+                currentLineWidth = 0;
+            }
+
+            const int subWordWidth = !currentLine.isEmpty() ? maxWidth - (currentLineWidth + spaceWidth) : maxWidth;
+            const QStringList subWords = SplitTextByWidth(word, font, subWordWidth);
+
+            if (subWords.isEmpty() || subWords.size() > 2)
+            {
+                AppendWord(word, totalWidth);
+            }
+            else
+            {
+                const int width = TextWidth(fontMetrics, ConstFirst(subWords));
+                const int tWidth = !currentLine.isEmpty() ? currentLineWidth + spaceWidth + width : width;
+                AppendWord(ConstFirst(subWords), tWidth);
+                lines.append(currentLine);
+
+                if (subWords.size() == 2)
+                {
+                    currentLine.clear();
+                    currentLineWidth = 0;
+
+                    // Insert the item after the current item
+                    iterator.insert(ConstLast(subWords));
+                    iterator.previous();
+                }
+            }
+        }
+    }
+
+    // Add the last line
+    if (!currentLine.isEmpty())
+    {
+        lines.append(currentLine);
+    }
+
+    return lines;
 }

src/libs/vlayout/vtextmanager.h

@@ -45,16 +45,13 @@ class VPieceLabelData;
 class VAbstractPattern;
 class VContainer;
 
-#define MIN_FONT_SIZE 5
-#define MAX_FONT_SIZE 128
-
 /**
  * @brief The TextLine struct holds the information about one text line
  */
 struct TextLine
 {
     QString m_qsText{};
-    int m_iFontSize{MIN_FONT_SIZE}; // 0 means default
+    int m_iFontSize{0}; // 0 means default
     bool m_bold{false};
     bool m_italic{false};
     Qt::Alignment m_eAlign{Qt::AlignCenter};
@@ -92,13 +89,14 @@ public:
     void SetFont(const QFont &font);
     auto GetFont() const -> const QFont &;
     void SetFontSize(int iFS);
-    void FitFontSize(qreal fW, qreal fH);
 
     auto GetAllSourceLines() const -> QVector<TextLine>;
     void SetAllSourceLines(const QVector<TextLine> &lines);
     auto GetSourceLinesCount() const -> vsizetype;
     auto GetSourceLine(vsizetype i) const -> const TextLine &;
 
+    auto GetLabelSourceLines(int width, const QFont &font) const -> QVector<TextLine>;
+
     auto MaxLineWidth(int width) const -> int;
 
     void Update(const QString &qsName, const VPieceLabelData &data, const VContainer *pattern);
@@ -113,6 +111,8 @@ private:
 
     static const quint32 streamHeader;
     static const quint16 classVersion;
+
+    auto BreakTextIntoLines(const QString &text, const QFont &font, int maxWidth) const -> QStringList;
 };
 
 #endif // VTEXTMANAGER_H

src/libs/vmisc/vcommonsettings.cpp

@@ -129,6 +129,8 @@ Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingDoublePassmark, (QLatin1String("
 Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingPatternDefaultSeamAllowance,
                           (QLatin1String("pattern/defaultSeamAllowance")))                              // NOLINT
 Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingPatternLabelFont, (QLatin1String("pattern/labelFont"))) // NOLINT
+Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingPieceLabelFontPointSize,                                // NOLINT
+                          (QLatin1String("pattern/pieceLabelFontPointSize")))
 Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingPatternLineWidth, (QLatin1String("pattern/lineWidth"))) // NOLINT
 Q_GLOBAL_STATIC_WITH_ARGS(const QString, settingPatternCurveApproximationScale,
                           (QLatin1String("pattern/curveApproximationScale"))) // NOLINT
@@ -1188,15 +1190,49 @@ void VCommonSettings::SetLabelFont(const QFont &f)
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-auto VCommonSettings::GetLabelFontSize() const -> int
+auto VCommonSettings::GetPieceLabelFontPointSize() const -> int
+{
+    bool ok = false;
+    int val = value(*settingPieceLabelFontPointSize, VCommonSettings::MinPieceLabelFontPointSize()).toInt(&ok);
+    if (not ok)
+    {
+        qDebug() << "Could not convert value"
+                 << value(*settingPieceLabelFontPointSize, VCommonSettings::MinPieceLabelFontPointSize())
+                 << "to int. Return default value for label font size.";
+        val = 12;
+    }
+    else
+    {
+        if (val < VCommonSettings::MinPieceLabelFontPointSize())
+        {
+            return VCommonSettings::MinPieceLabelFontPointSize();
+        }
+    }
+    return val;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VCommonSettings::SetPieceLabelFontPointSize(int size)
+{
+    setValue(*settingPieceLabelFontPointSize, size);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VCommonSettings::MinPieceLabelFontPointSize() -> int
+{
+    return 5;
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+auto VCommonSettings::GetPatternLabelFontSize() const -> int
 {
     if (labelFontSizeCached <= 0)
     {
         bool ok = false;
-        labelFontSizeCached = value(*settingPatternLabelFontSize, GetDefLabelFontSize()).toInt(&ok);
+        labelFontSizeCached = value(*settingPatternLabelFontSize, GetDefPatternLabelFontSize()).toInt(&ok);
         if (not ok)
         {
-            labelFontSizeCached = GetDefLabelFontSize();
+            labelFontSizeCached = GetDefPatternLabelFontSize();
         }
         labelFontSizeCached = qBound(minLabelFontSize, labelFontSizeCached, maxLabelFontSize);
     }
@@ -1204,7 +1240,7 @@ auto VCommonSettings::GetLabelFontSize() const -> int
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-void VCommonSettings::SetLabelFontSize(int size)
+void VCommonSettings::SetPatternLabelFontSize(int size)
 {
     size = qBound(minLabelFontSize, size, maxLabelFontSize);
     setValue(*settingPatternLabelFontSize, size);
@@ -1212,7 +1248,7 @@ void VCommonSettings::SetLabelFontSize(int size)
 }
 
 //---------------------------------------------------------------------------------------------------------------------
-auto VCommonSettings::GetDefLabelFontSize() -> int
+auto VCommonSettings::GetDefPatternLabelFontSize() -> int
 {
     return 32;
 }

src/libs/vmisc/vcommonsettings.h

@@ -46,8 +46,10 @@ class QMarginsF;
 class VCommonSettings : public QSettings
 {
     Q_OBJECT // NOLINT
-        public : VCommonSettings(Format format, Scope scope, const QString &organization,
-                                 const QString &application = QString(), QObject *parent = nullptr);
+
+public:
+    VCommonSettings(Format format, Scope scope, const QString &organization, const QString &application = QString(),
+                    QObject *parent = nullptr);
     VCommonSettings(const QString &fileName, Format format, QObject *parent = nullptr);
     ~VCommonSettings() override = default;
 
@@ -211,9 +213,13 @@ class VCommonSettings : public QSettings
     auto GetLabelFont() const -> QFont;
     void SetLabelFont(const QFont &f);
 
-    auto GetLabelFontSize() const -> int;
-    void SetLabelFontSize(int size);
-    static auto GetDefLabelFontSize() -> int;
+    auto GetPieceLabelFontPointSize() const -> int;
+    void SetPieceLabelFontPointSize(int size);
+    static auto MinPieceLabelFontPointSize() -> int;
+
+    auto GetPatternLabelFontSize() const -> int;
+    void SetPatternLabelFontSize(int size);
+    static auto GetDefPatternLabelFontSize() -> int;
 
     auto GetHideLabels() const -> bool;
     void SetHideLabels(bool value);

src/libs/vpatterndb/floatItemData/vpatternlabeldata_p.h

@@ -33,8 +33,8 @@
 #include <QSharedData>
 #include <QString>
 
-#include "../vmisc/typedef.h"
 #include "../vmisc/defglobal.h"
+#include "../vmisc/typedef.h"
 #if QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
 #include "../vmisc/diagnostic.h"
 #endif // QT_VERSION < QT_VERSION_CHECK(5, 5, 0)
@@ -46,43 +46,24 @@ QT_WARNING_DISABLE_GCC("-Wnon-virtual-dtor")
 class VPatternLabelDataPrivate : public QSharedData
 {
 public:
-    VPatternLabelDataPrivate()
-        : m_dLabelWidth(),
-          m_dLabelHeight(),
-          m_dLabelAngle(),
-          m_iFontSize(0),
-          m_centerPin(NULL_ID),
-          m_topLeftPin(NULL_ID),
-          m_bottomRightPin(NULL_ID)
-    {}
-
-    VPatternLabelDataPrivate(const VPatternLabelDataPrivate &data)
-        : QSharedData(data),
-          m_dLabelWidth(data.m_dLabelWidth),
-          m_dLabelHeight(data.m_dLabelHeight),
-          m_dLabelAngle(data.m_dLabelAngle),
-          m_iFontSize(data.m_iFontSize),
-          m_centerPin(data.m_centerPin),
-          m_topLeftPin(data.m_topLeftPin),
-          m_bottomRightPin(data.m_bottomRightPin)
-    {}
-
+    VPatternLabelDataPrivate() = default;
+    VPatternLabelDataPrivate(const VPatternLabelDataPrivate &data) = default;
     ~VPatternLabelDataPrivate() = default;
 
     /** @brief m_dLabelWidth formula to calculate the width of label */
-    QString m_dLabelWidth;
+    QString m_dLabelWidth{}; // NOLINT(misc-non-private-member-variables-in-classes)
     /** @brief m_dLabelHeight formula to calculate the height of label */
-    QString m_dLabelHeight;
+    QString m_dLabelHeight{}; // NOLINT(misc-non-private-member-variables-in-classes)
     /** @brief m_dLabelAngle formula to calculate the rotation angle of label */
-    QString m_dLabelAngle;
+    QString m_dLabelAngle{}; // NOLINT(misc-non-private-member-variables-in-classes)
     /** @brief m_iFontSize label text base font size */
-    int     m_iFontSize;
+    int m_iFontSize{0}; // NOLINT(misc-non-private-member-variables-in-classes)
     /** @brief m_centerPin center pin id */
-    quint32 m_centerPin;
+    quint32 m_centerPin{NULL_ID}; // NOLINT(misc-non-private-member-variables-in-classes)
     /** @brief m_topLeftPin top left corner pin id */
-    quint32 m_topLeftPin;
+    quint32 m_topLeftPin{NULL_ID}; // NOLINT(misc-non-private-member-variables-in-classes)
     /** @brief m_bottomRightPin bottom right corner pin id */
-    quint32 m_bottomRightPin;
+    quint32 m_bottomRightPin{NULL_ID}; // NOLINT(misc-non-private-member-variables-in-classes)
 
 private:
     Q_DISABLE_ASSIGN_MOVE(VPatternLabelDataPrivate) // NOLINT
@@ -91,4 +72,3 @@ private:
 QT_WARNING_POP
 
 #endif // VPATTERNLABELDATA_P_H
-

src/libs/vtools/dialogs/tools/piece/dialogseamallowance.h

@@ -36,14 +36,14 @@
 
 namespace Ui
 {
-    class DialogSeamAllowance;
-    class TabPaths;
-    class TabLabels;
-    class TabGrainline;
-    class TabPins;
-    class TabPassmarks;
-    class TabPlaceLabels;
-}
+class DialogSeamAllowance;
+class TabPaths;
+class TabLabels;
+class TabGrainline;
+class TabPins;
+class TabPassmarks;
+class TabPlaceLabels;
+} // namespace Ui
 
 class VisPieceSpecialPoints;
 class FancyTabBar;
@@ -54,8 +54,7 @@ class DialogSeamAllowance : public DialogTool
     Q_OBJECT // NOLINT
 
 public:
-    DialogSeamAllowance(const VContainer *data, VAbstractPattern *doc, quint32 toolId,
-                        QWidget *parent = nullptr);
+    DialogSeamAllowance(const VContainer *data, VAbstractPattern *doc, quint32 toolId, QWidget *parent = nullptr);
     DialogSeamAllowance(const VContainer *data, quint32 toolId, QWidget *parent = nullptr);
     ~DialogSeamAllowance() override;
 
@@ -177,11 +176,11 @@ private:
     Q_DISABLE_COPY_MOVE(DialogSeamAllowance) // NOLINT
 
     Ui::DialogSeamAllowance *ui;
-    Ui::TabPaths            *uiTabPaths;
-    Ui::TabLabels           *uiTabLabels;
-    Ui::TabGrainline        *uiTabGrainline;
-    Ui::TabPins             *uiTabPins;
-    Ui::TabPassmarks        *uiTabPassmarks;
+    Ui::TabPaths *uiTabPaths;
+    Ui::TabLabels *uiTabLabels;
+    Ui::TabGrainline *uiTabGrainline;
+    Ui::TabPins *uiTabPins;
+    Ui::TabPassmarks *uiTabPassmarks;
     Ui::TabPlaceLabels *uiTabPlaceLabels;
 
     QWidget *m_tabPaths{nullptr};
@@ -302,6 +301,7 @@ private:
     void InitPassmarksTab();
     void InitPlaceLabelsTab();
     void InitAllPinComboboxes();
+    void InitLabelFontSize(QComboBox *box);
 
     void SetFormulaSAWidth(const QString &formula);
     void SetFormulaPassmarkLength(const QString &formula);

src/libs/vtools/dialogs/tools/piece/tabs/tablabels.ui

@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>628</width>
-    <height>516</height>
+    <width>550</width>
+    <height>534</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -28,8 +28,8 @@
        <rect>
         <x>0</x>
         <y>0</y>
-        <width>608</width>
-        <height>496</height>
+        <width>530</width>
+        <height>514</height>
        </rect>
       </property>
       <layout class="QVBoxLayout" name="verticalLayout">
@@ -455,7 +455,28 @@
               <property name="checked">
                <bool>false</bool>
               </property>
-              <layout class="QVBoxLayout" name="verticalLayout_8">
+              <layout class="QVBoxLayout" name="verticalLayout_7">
+               <item>
+                <layout class="QFormLayout" name="formLayout_8">
+                 <item row="0" column="0">
+                  <widget class="QLabel" name="label_19">
+                   <property name="text">
+                    <string>Font size:</string>
+                   </property>
+                  </widget>
+                 </item>
+                 <item row="0" column="1">
+                  <widget class="QComboBox" name="comboBoxPieceLabelSize"/>
+                 </item>
+                </layout>
+               </item>
+               <item>
+                <widget class="Line" name="line_2">
+                 <property name="orientation">
+                  <enum>Qt::Horizontal</enum>
+                 </property>
+                </widget>
+               </item>
                <item>
                 <layout class="QHBoxLayout" name="horizontalLayout_18">
                  <item alignment="Qt::AlignLeft">
@@ -987,7 +1008,7 @@
                    </property>
                   </widget>
                  </item>
-                 <item alignment="Qt::AlignRight">
+                 <item>
                   <widget class="QLabel" name="labelDLAngle">
                    <property name="sizePolicy">
                     <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
@@ -1112,7 +1133,28 @@
               <property name="checked">
                <bool>false</bool>
               </property>
-              <layout class="QVBoxLayout" name="verticalLayout_14">
+              <layout class="QVBoxLayout" name="verticalLayout_6">
+               <item>
+                <layout class="QFormLayout" name="formLayout_13">
+                 <item row="0" column="0">
+                  <widget class="QLabel" name="label_20">
+                   <property name="text">
+                    <string>Font size:</string>
+                   </property>
+                  </widget>
+                 </item>
+                 <item row="0" column="1">
+                  <widget class="QComboBox" name="comboBoxPatternLabelSize"/>
+                 </item>
+                </layout>
+               </item>
+               <item>
+                <widget class="Line" name="line">
+                 <property name="orientation">
+                  <enum>Qt::Horizontal</enum>
+                 </property>
+                </widget>
+               </item>
                <item>
                 <layout class="QHBoxLayout" name="horizontalLayout_25">
                  <item alignment="Qt::AlignLeft">

src/libs/vtools/tools/vtoolseamallowance.cpp

@@ -505,7 +505,8 @@ void VToolSeamAllowance::AddPatternPieceData(VAbstractPattern *doc, QDomElement
     doc->SetAttribute(domData, AttrMy, data.GetPos().y());
     doc->SetAttribute(domData, AttrWidth, data.GetLabelWidth());
     doc->SetAttribute(domData, AttrHeight, data.GetLabelHeight());
-    doc->SetAttribute(domData, AttrFont, data.GetFontSize());
+    doc->SetAttributeOrRemoveIf<int>(domData, AttrFont, data.GetFontSize(),
+                                     [](int size) noexcept { return size == 0; });
     doc->SetAttribute(domData, VAbstractPattern::AttrRotation, data.GetRotation());
     doc->SetAttributeOrRemoveIf<quint32>(domData, AttrCenterPin, data.CenterPin(),
                                          [](quint32 pin) noexcept { return pin == NULL_ID; });
@@ -528,7 +529,8 @@ void VToolSeamAllowance::AddPatternInfo(VAbstractPattern *doc, QDomElement &domE
     doc->SetAttribute(domData, AttrMy, geom.GetPos().y());
     doc->SetAttribute(domData, AttrWidth, geom.GetLabelWidth());
     doc->SetAttribute(domData, AttrHeight, geom.GetLabelHeight());
-    doc->SetAttribute(domData, AttrFont, geom.GetFontSize());
+    doc->SetAttributeOrRemoveIf<int>(domData, AttrFont, geom.GetFontSize(),
+                                     [](int size) noexcept { return size == 0; });
     doc->SetAttribute(domData, VAbstractPattern::AttrRotation, geom.GetRotation());
     doc->SetAttributeOrRemoveIf<quint32>(domData, AttrCenterPin, geom.CenterPin(),
                                          [](quint32 pin) noexcept { return pin <= NULL_ID; });
@@ -767,6 +769,7 @@ void VToolSeamAllowance::UpdateDetailLabel()
 
         if (PrepareLabelData(labelData, pins, m_dataLabel, pos, labelAngle))
         {
+            m_dataLabel->SetPieceName(detail.GetName());
             m_dataLabel->UpdateData(detail.GetName(), labelData, getData());
             UpdateLabelItem(m_dataLabel, pos, labelAngle);
         }
@@ -794,6 +797,7 @@ void VToolSeamAllowance::UpdatePatternInfo()
 
         if (PrepareLabelData(geom, pins, m_patternInfo, pos, labelAngle))
         {
+            m_patternInfo->SetPieceName(detail.GetName());
             m_patternInfo->UpdateData(doc, getData());
             UpdateLabelItem(m_patternInfo, pos, labelAngle);
         }
@@ -872,7 +876,7 @@ void VToolSeamAllowance::SaveMoveDetail(const QPointF &ptPos)
 /**
  * @brief SaveResizeDetail saves the resize detail label operation to the undo stack
  */
-void VToolSeamAllowance::SaveResizeDetail(qreal dLabelW, int iFontSize)
+void VToolSeamAllowance::SaveResizeDetail(qreal dLabelW)
 {
     VPiece oldDet = VAbstractTool::data.GetPiece(m_id);
     VPiece newDet = oldDet;
@@ -881,7 +885,6 @@ void VToolSeamAllowance::SaveResizeDetail(qreal dLabelW, int iFontSize)
     newDet.GetPieceLabelData().SetLabelWidth(QString().setNum(dLabelW));
     const qreal height = FromPixel(m_dataLabel->boundingRect().height(), *VDataTool::data.GetPatternUnit());
     newDet.GetPieceLabelData().SetLabelHeight(QString().setNum(height));
-    newDet.GetPieceLabelData().SetFontSize(iFontSize);
 
     auto *resizeCommand = new SavePieceOptions(oldDet, newDet, doc, m_id);
     resizeCommand->setText(tr("resize pattern piece label"));
@@ -928,7 +931,7 @@ void VToolSeamAllowance::SaveMovePattern(const QPointF &ptPos)
 /**
  * @brief: SaveResizePattern saves the pattern label width and font size
  */
-void VToolSeamAllowance::SaveResizePattern(qreal dLabelW, int iFontSize)
+void VToolSeamAllowance::SaveResizePattern(qreal dLabelW)
 {
     VPiece oldDet = VAbstractTool::data.GetPiece(m_id);
     VPiece newDet = oldDet;
@@ -937,7 +940,6 @@ void VToolSeamAllowance::SaveResizePattern(qreal dLabelW, int iFontSize)
     newDet.GetPatternLabelData().SetLabelWidth(QString().setNum(dLabelW));
     qreal height = FromPixel(m_patternInfo->boundingRect().height(), *VDataTool::data.GetPatternUnit());
     newDet.GetPatternLabelData().SetLabelHeight(QString().setNum(height));
-    newDet.GetPatternLabelData().SetFontSize(iFontSize);
 
     auto *resizeCommand = new SavePieceOptions(oldDet, newDet, doc, m_id);
     resizeCommand->setText(tr("resize pattern info label"));
@@ -1372,8 +1374,8 @@ VToolSeamAllowance::VToolSeamAllowance(const VToolSeamAllowanceInitData &initDat
     m_sceneDetails(initData.scene),
     m_drawName(initData.drawName),
     m_seamAllowance(new VNoBrushScalePathItem(this)),
-    m_dataLabel(new VTextGraphicsItem(this)),
-    m_patternInfo(new VTextGraphicsItem(this)),
+    m_dataLabel(new VTextGraphicsItem(VTextGraphicsItem::ItemType::PieceLabel, this)),
+    m_patternInfo(new VTextGraphicsItem(VTextGraphicsItem::ItemType::PatternLabel, this)),
     m_grainLine(new VGrainlineItem(this)),
     m_passmarks(new QGraphicsPathItem(this)),
     m_placeLabels(new QGraphicsPathItem(this))
@@ -2116,10 +2118,12 @@ auto VToolSeamAllowance::PrepareLabelData(const VPatternLabelData &labelData, co
     }
     labelItem->SetMoveType(type);
 
-    QFont fnt = VAbstractApplication::VApp()->Settings()->GetLabelFont();
+    VCommonSettings *settings = VAbstractApplication::VApp()->Settings();
+    QFont fnt = settings->GetLabelFont();
     {
         const int iFS = labelData.GetFontSize();
-        iFS < MIN_FONT_SIZE ? fnt.setPixelSize(MIN_FONT_SIZE) : fnt.setPixelSize(iFS);
+        iFS < VCommonSettings::MinPieceLabelFontPointSize() ? fnt.setPointSize(settings->GetPieceLabelFontPointSize())
+                                                            : fnt.setPointSize(iFS);
     }
     labelItem->SetFont(fnt);
     labelItem->SetSize(ToPixel(labelWidth, *VDataTool::data.GetPatternUnit()),

src/libs/vtools/tools/vtoolseamallowance.h

@@ -57,14 +57,11 @@ class VToolSeamAllowance : public VInteractiveTool, public QGraphicsPathItem
 public:
     ~VToolSeamAllowance() override = default;
 
-    static auto Create(const QPointer<DialogTool> &dialog,
-                       VMainGraphicsScene *scene,
-                       VAbstractPattern *doc,
+    static auto Create(const QPointer<DialogTool> &dialog, VMainGraphicsScene *scene, VAbstractPattern *doc,
                        VContainer *data) -> VToolSeamAllowance *;
     static auto Create(VToolSeamAllowanceInitData &initData) -> VToolSeamAllowance *;
-    static auto Duplicate(const QPointer<DialogTool> &dialog,
-                          VMainGraphicsScene *scene,
-                          VAbstractPattern *doc) -> VToolSeamAllowance *;
+    static auto Duplicate(const QPointer<DialogTool> &dialog, VMainGraphicsScene *scene, VAbstractPattern *doc)
+        -> VToolSeamAllowance *;
     static auto Duplicate(VToolSeamAllowanceInitData &initData) -> VToolSeamAllowance *;
 
     static const quint8 pieceVersion;
@@ -89,32 +86,16 @@ public:
 
     void RemoveWithConfirm(bool ask);
 
-    static void InsertNodes(const QVector<VPieceNode> &nodes,
-                            quint32 pieceId,
-                            VMainGraphicsScene *scene,
-                            VContainer *data,
-                            VAbstractPattern *doc);
+    static void InsertNodes(const QVector<VPieceNode> &nodes, quint32 pieceId, VMainGraphicsScene *scene,
+                            VContainer *data, VAbstractPattern *doc);
 
-    static void AddAttributes(VAbstractPattern *doc,
-                              QDomElement &domElement,
-                              quint32 id,
-                              const VPiece &piece);
+    static void AddAttributes(VAbstractPattern *doc, QDomElement &domElement, quint32 id, const VPiece &piece);
     static void AddCSARecord(VAbstractPattern *doc, QDomElement &domElement, CustomSARecord record);
-    static void AddCSARecords(VAbstractPattern *doc,
-                              QDomElement &domElement,
-                              const QVector<CustomSARecord> &records);
-    static void AddInternalPaths(VAbstractPattern *doc,
-                                 QDomElement &domElement,
-                                 const QVector<quint32> &paths);
-    static void AddPins(VAbstractPattern *doc,
-                        QDomElement &domElement,
-                        const QVector<quint32> &pins);
-    static void AddPlaceLabels(VAbstractPattern *doc,
-                               QDomElement &domElement,
-                               const QVector<quint32> &placeLabels);
-    static void AddPatternPieceData(VAbstractPattern *doc,
-                                    QDomElement &domElement,
-                                    const VPiece &piece);
+    static void AddCSARecords(VAbstractPattern *doc, QDomElement &domElement, const QVector<CustomSARecord> &records);
+    static void AddInternalPaths(VAbstractPattern *doc, QDomElement &domElement, const QVector<quint32> &paths);
+    static void AddPins(VAbstractPattern *doc, QDomElement &domElement, const QVector<quint32> &pins);
+    static void AddPlaceLabels(VAbstractPattern *doc, QDomElement &domElement, const QVector<quint32> &placeLabels);
+    static void AddPatternPieceData(VAbstractPattern *doc, QDomElement &domElement, const VPiece &piece);
     static void AddPatternInfo(VAbstractPattern *doc, QDomElement &domElement, const VPiece &piece);
     static void AddGrainline(VAbstractPattern *doc, QDomElement &domElement, const VPiece &piece);
 
@@ -126,7 +107,10 @@ public:
     void RefreshGeometry(bool updateChildren = true);
 
     auto type() const -> int override { return Type; }
-    enum { Type = UserType + static_cast<int>(Tool::Piece) };
+    enum
+    {
+        Type = UserType + static_cast<int>(Tool::Piece)
+    };
 
     auto getTagName() const -> QString override;
     void ShowVisualization(bool show) override;
@@ -152,10 +136,10 @@ public slots:
 protected slots:
     void UpdateGrainline();
     void SaveMoveDetail(const QPointF &ptPos);
-    void SaveResizeDetail(qreal dLabelW, int iFontSize);
+    void SaveResizeDetail(qreal dLabelW);
     void SaveRotationDetail(qreal dRot);
     void SaveMovePattern(const QPointF &ptPos);
-    void SaveResizePattern(qreal dLabelW, int iFontSize);
+    void SaveResizePattern(qreal dLabelW);
     void SaveRotationPattern(qreal dRot);
     void SaveMoveGrainline(const QPointF &ptPos);
     void SaveResizeGrainline(qreal dLength);
@@ -211,66 +195,45 @@ private:
     /** @brief m_geometryIsReady is true when a piece's geometry is ready and checks for validity can be enabled. */
     bool m_geometryIsReady{false};
 
-    explicit VToolSeamAllowance(const VToolSeamAllowanceInitData &initData,
-                                QGraphicsItem *parent = nullptr);
+    explicit VToolSeamAllowance(const VToolSeamAllowanceInitData &initData, QGraphicsItem *parent = nullptr);
 
     void UpdateExcludeState();
     void UpdateInternalPaths();
 
-    auto FindLabelGeometry(const VPatternLabelData &labelData,
-                           const QVector<quint32> &pins,
-                           qreal &rotationAngle,
-                           qreal &labelWidth,
-                           qreal &labelHeight,
-                           QPointF &pos) -> VPieceItem::MoveTypes;
-    auto FindGrainlineGeometry(const VGrainlineData &geom,
-                               const QVector<quint32> &pins,
-                               qreal &length,
-                               qreal &rotationAngle,
-                               QPointF &pos) -> VPieceItem::MoveTypes;
+    auto FindLabelGeometry(const VPatternLabelData &labelData, const QVector<quint32> &pins, qreal &rotationAngle,
+                           qreal &labelWidth, qreal &labelHeight, QPointF &pos) -> VPieceItem::MoveTypes;
+    auto FindGrainlineGeometry(const VGrainlineData &geom, const QVector<quint32> &pins, qreal &length,
+                               qreal &rotationAngle, QPointF &pos) -> VPieceItem::MoveTypes;
 
     void InitNodes(const VPiece &detail, VMainGraphicsScene *scene);
-    static void InitNode(const VPieceNode &node,
-                         VMainGraphicsScene *scene,
-                         VToolSeamAllowance *parent);
+    static void InitNode(const VPieceNode &node, VMainGraphicsScene *scene, VToolSeamAllowance *parent);
     void InitCSAPaths(const VPiece &detail) const;
     void InitInternalPaths(const VPiece &detail);
     void InitSpecialPoints(const QVector<quint32> &points) const;
 
-    auto PrepareLabelData(const VPatternLabelData &labelData,
-                          const QVector<quint32> &pins,
-                          VTextGraphicsItem *labelItem,
-                          QPointF &pos,
-                          qreal &labelAngle) -> bool;
+    auto PrepareLabelData(const VPatternLabelData &labelData, const QVector<quint32> &pins,
+                          VTextGraphicsItem *labelItem, QPointF &pos, qreal &labelAngle) -> bool;
 
     auto SelectedTools() const -> QList<VToolSeamAllowance *>;
 
     auto IsGrainlinePositionValid() const -> bool;
 
-    static void AddPointRecords(VAbstractPattern *doc,
-                                QDomElement &domElement,
-                                const QVector<quint32> &records,
+    static void AddPointRecords(VAbstractPattern *doc, QDomElement &domElement, const QVector<quint32> &records,
                                 const QString &tag);
 
-    static auto DuplicateNodes(const VPiecePath &path,
-                               const VToolSeamAllowanceInitData &initData,
+    static auto DuplicateNodes(const VPiecePath &path, const VToolSeamAllowanceInitData &initData,
                                QMap<quint32, quint32> &replacements) -> QVector<VPieceNode>;
-    static auto DuplicateNode(const VPieceNode &node, const VToolSeamAllowanceInitData &initData)
-        -> quint32;
+    static auto DuplicateNode(const VPieceNode &node, const VToolSeamAllowanceInitData &initData) -> quint32;
 
-    static auto DuplicatePiecePath(quint32 id, const VToolSeamAllowanceInitData &initData)
-        -> quint32;
+    static auto DuplicatePiecePath(quint32 id, const VToolSeamAllowanceInitData &initData) -> quint32;
 
     static auto DuplicateCustomSARecords(const QVector<CustomSARecord> &records,
                                          const VToolSeamAllowanceInitData &initData,
-                                         const QMap<quint32, quint32> &replacements)
-        -> QVector<CustomSARecord>;
+                                         const QMap<quint32, quint32> &replacements) -> QVector<CustomSARecord>;
 
-    static auto DuplicateInternalPaths(const QVector<quint32> &iPaths,
-                                       const VToolSeamAllowanceInitData &initData)
+    static auto DuplicateInternalPaths(const QVector<quint32> &iPaths, const VToolSeamAllowanceInitData &initData)
         -> QVector<quint32>;
-    static auto DuplicatePlaceLabels(const QVector<quint32> &placeLabels,
-                                     const VToolSeamAllowanceInitData &initData)
+    static auto DuplicatePlaceLabels(const QVector<quint32> &placeLabels, const VToolSeamAllowanceInitData &initData)
         -> QVector<quint32>;
 };
 

src/libs/vwidgets/vgraphicssimpletextitem.cpp

@@ -85,16 +85,16 @@ void VGraphicsSimpleTextItem::paint(QPainter *painter, const QStyleOptionGraphic
 {
     auto UpdateLine = [this]()
     {
-        if (VScenePoint *parent = dynamic_cast<VScenePoint *>(parentItem()))
+        if (auto *parent = dynamic_cast<VScenePoint *>(parentItem()))
         {
             parent->RefreshLine();
         }
     };
 
     QFont font = this->font();
-    if (font.pointSize() != VAbstractApplication::VApp()->Settings()->GetLabelFontSize())
+    if (font.pointSize() != VAbstractApplication::VApp()->Settings()->GetPatternLabelFontSize())
     {
-        font.setPointSize(VAbstractApplication::VApp()->Settings()->GetLabelFontSize());
+        font.setPointSize(VAbstractApplication::VApp()->Settings()->GetPatternLabelFontSize());
         setFont(font);
     }
 
@@ -373,8 +373,8 @@ void VGraphicsSimpleTextItem::Init()
     this->setFlag(QGraphicsItem::ItemIsFocusable, true);// For keyboard input focus
     this->setAcceptHoverEvents(true);
     QFont font = this->font();
-    font.setPointSize(VAbstractApplication::VApp()->Settings()->GetLabelFontSize());
+    font.setPointSize(VAbstractApplication::VApp()->Settings()->GetPatternLabelFontSize());
     setFont(font);
-    m_oldScale = minVisibleFontSize / VAbstractApplication::VApp()->Settings()->GetLabelFontSize();
+    m_oldScale = minVisibleFontSize / VAbstractApplication::VApp()->Settings()->GetPatternLabelFontSize();
     setScale(m_oldScale);
 }

src/libs/vwidgets/vscenepoint.cpp

@@ -82,8 +82,8 @@ void VScenePoint::paint(QPainter *painter, const QStyleOptionGraphicsItem *optio
         painter->drawEllipse(PointRect(accuracyPointOnLine));
         painter->restore();
     }
-
-    if (settings->GetLabelFontSize()*scale < minVisibleFontSize || settings->GetHideLabels())
+    
+    if (settings->GetPatternLabelFontSize()*scale < minVisibleFontSize || settings->GetHideLabels())
     {
         m_namePoint->setVisible(false);
         m_lineName->setVisible(false);

src/libs/vwidgets/vtextgraphicsitem.cpp

@@ -27,6 +27,7 @@
  *************************************************************************/
 
 #include <QColor>
+#include <QDebug>
 #include <QFlags>
 #include <QFont>
 #include <QGraphicsItem>
@@ -37,24 +38,23 @@
 #include <QPoint>
 #include <QStyleOptionGraphicsItem>
 #include <Qt>
-#include <QDebug>
 
+#include "../ifc/exception/vexception.h"
 #include "../vmisc/def.h"
-#include "../vmisc/vmath.h"
 #include "../vmisc/literals.h"
-#include "../vmisc/compatibility.h"
+#include "../vmisc/vabstractvalapplication.h"
 #include "vtextgraphicsitem.h"
 
-const qreal resizeSquare = MmToPixel(3.);
-const qreal rotateCircle = MmToPixel(2.);
-#define ROTATE_RECT                 60
-#define ROTATE_ARC                  50
-const qreal minW = MmToPixel(4.) + resizeSquare;
-const qreal minH = MmToPixel(4.) + resizeSquare;
-#define ACTIVE_Z                    10
-
 namespace
 {
+constexpr qreal resizeSquare = MmToPixel(3.);
+constexpr qreal rotateCircle = MmToPixel(2.);
+constexpr int rotateRect = 60;
+constexpr int rotateArc = 50;
+constexpr qreal minW = MmToPixel(4.) + resizeSquare;
+constexpr qreal minH = MmToPixel(4.) + resizeSquare;
+constexpr int activeZ = 10;
+
 //---------------------------------------------------------------------------------------------------------------------
 /**
  * @brief GetBoundingRect calculates the bounding box around rectBB rectangle, rotated around its center by dRot degrees
@@ -64,7 +64,7 @@ namespace
  */
 auto GetBoundingRect(const QRectF &rectBB, qreal dRot) -> QRectF
 {
-    QPointF apt[4] = { rectBB.topLeft(), rectBB.topRight(), rectBB.bottomLeft(), rectBB.bottomRight() };
+    std::array<QPointF, 4> apt = {rectBB.topLeft(), rectBB.topRight(), rectBB.bottomLeft(), rectBB.bottomRight()};
     QPointF ptCenter = rectBB.center();
 
     qreal dX1 = 0;
@@ -73,11 +73,11 @@ auto GetBoundingRect(const QRectF &rectBB, qreal dRot) -> QRectF
     qreal dY2 = 0;
 
     double dAng = qDegreesToRadians(dRot);
-    for (int i = 0; i < 4; ++i)
+    for (std::size_t i = 0; i < 4; ++i)
     {
-        QPointF pt = apt[i] - ptCenter;
-        qreal dX = pt.x()*cos(dAng) + pt.y()*sin(dAng);
-        qreal dY = -pt.x()*sin(dAng) + pt.y()*cos(dAng);
+        QPointF pt = apt.at(i) - ptCenter;
+        qreal dX = pt.x() * cos(dAng) + pt.y() * sin(dAng);
+        qreal dY = -pt.x() * sin(dAng) + pt.y() * cos(dAng);
 
         if (i == 0)
         {
@@ -110,22 +110,16 @@ auto GetBoundingRect(const QRectF &rectBB, qreal dRot) -> QRectF
     rect.setHeight(dY2 - dY1);
     return rect;
 }
-}//static functions
+} // namespace
 
 //---------------------------------------------------------------------------------------------------------------------
 /**
  * @brief VTextGraphicsItem::VTextGraphicsItem constructor
  * @param pParent pointer to the parent item
  */
-VTextGraphicsItem::VTextGraphicsItem(QGraphicsItem* pParent)
-    : VPieceItem(pParent),
-      m_ptStartPos(),
-      m_ptStart(),
-      m_szStart(),
-      m_dRotation(0),
-      m_dAngle(0),
-      m_rectResize(),
-      m_tm()
+VTextGraphicsItem::VTextGraphicsItem(ItemType type, QGraphicsItem *pParent)
+  : VPieceItem(pParent),
+    m_itemType(type)
 {
     m_inactiveZ = 2;
     SetSize(minW, minH);
@@ -137,7 +131,7 @@ VTextGraphicsItem::VTextGraphicsItem(QGraphicsItem* pParent)
  * @brief VTextGraphicsItem::SetFont sets the item font
  * @param fnt font to be used in item
  */
-void VTextGraphicsItem::SetFont(const QFont& fnt)
+void VTextGraphicsItem::SetFont(const QFont &fnt)
 {
     m_tm.SetFont(fnt);
 }
@@ -155,38 +149,9 @@ void VTextGraphicsItem::paint(QPainter *painter, const QStyleOptionGraphicsItem
     Q_UNUSED(option)
     painter->fillRect(m_rectBoundingBox, QColor(251, 251, 175, 128 /*50% opacity*/));
     painter->setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);
-
     painter->setPen(Qt::black);
-    QFont fnt = m_tm.GetFont();
-    int iW = qFloor(boundingRect().width());
-    // draw text lines
-    int iY = 0;
-    for (int i = 0; i < m_tm.GetSourceLinesCount(); ++i)
-    {
-        const TextLine& tl = m_tm.GetSourceLine(i);
 
-        fnt.setPixelSize(m_tm.GetFont().pixelSize() + tl.m_iFontSize);
-        fnt.setBold(tl.m_bold);
-        fnt.setItalic(tl.m_italic);
-
-        QString qsText = tl.m_qsText;
-        QFontMetrics fm(fnt);
-
-        // check if the next line will go out of bounds
-        if (iY + fm.height() > boundingRect().height())
-        {
-            break;
-        }
-
-        if (TextWidth(fm, qsText) > iW)
-        {
-            qsText = fm.elidedText(qsText, Qt::ElideMiddle, iW);
-        }
-
-        painter->setFont(fnt);
-        painter->drawText(0, iY, iW, fm.height(), static_cast<int>(tl.m_eAlign), qsText);
-        iY += fm.height() + m_tm.GetSpacing();
-    }
+    PaintLabel(painter);
 
     // now draw the features specific to non-normal modes
     if (m_eMode != mNormal)
@@ -205,8 +170,8 @@ void VTextGraphicsItem::paint(QPainter *painter, const QStyleOptionGraphicsItem
             if (m_eMode == mResize)
             {
                 // draw the resize diagonal lines
-                painter->drawLine(1, 1, qFloor(m_rectBoundingBox.width())-1, qFloor(m_rectBoundingBox.height())-1);
-                painter->drawLine(1, qFloor(m_rectBoundingBox.height())-1, qFloor(m_rectBoundingBox.width())-1, 1);
+                painter->drawLine(1, 1, qFloor(m_rectBoundingBox.width()) - 1, qFloor(m_rectBoundingBox.height()) - 1);
+                painter->drawLine(1, qFloor(m_rectBoundingBox.height()) - 1, qFloor(m_rectBoundingBox.width()) - 1, 1);
             }
         }
         else
@@ -214,24 +179,21 @@ void VTextGraphicsItem::paint(QPainter *painter, const QStyleOptionGraphicsItem
             // in rotate mode, draw the circle in the middle
             painter->setPen(Qt::black);
             painter->setBrush(Qt::black);
-            painter->drawEllipse(
-                        QPointF(m_rectBoundingBox.width()/2, m_rectBoundingBox.height()/2),
-                        rotateCircle,
-                        rotateCircle
-                        );
-            if (m_rectBoundingBox.width() > minW*3 && m_rectBoundingBox.height() > minH*3)
+            painter->drawEllipse(QPointF(m_rectBoundingBox.width() / 2, m_rectBoundingBox.height() / 2), rotateCircle,
+                                 rotateCircle);
+            if (m_rectBoundingBox.width() > minW * 3 && m_rectBoundingBox.height() > minH * 3)
             {
                 painter->setPen(QPen(Qt::black, 3));
                 painter->setBrush(Qt::NoBrush);
                 // and then draw the arc in each of the corners
-                int iTop = ROTATE_RECT - ROTATE_ARC;
-                int iLeft = ROTATE_RECT - ROTATE_ARC;
-                int iRight = qRound(m_rectBoundingBox.width()) - ROTATE_RECT;
-                int iBottom = qRound(m_rectBoundingBox.height()) - ROTATE_RECT;
-                painter->drawArc(iLeft, iTop, ROTATE_ARC, ROTATE_ARC, 180*16, -90*16);
-                painter->drawArc(iRight, iTop, ROTATE_ARC, ROTATE_ARC, 90*16, -90*16);
-                painter->drawArc(iLeft, iBottom, ROTATE_ARC, ROTATE_ARC, 270*16, -90*16);
-                painter->drawArc(iRight, iBottom, ROTATE_ARC, ROTATE_ARC, 0*16, -90*16);
+                int iTop = rotateRect - rotateArc;
+                int iLeft = rotateRect - rotateArc;
+                int iRight = qRound(m_rectBoundingBox.width()) - rotateRect;
+                int iBottom = qRound(m_rectBoundingBox.height()) - rotateRect;
+                painter->drawArc(iLeft, iTop, rotateArc, rotateArc, 180 * 16, -90 * 16);
+                painter->drawArc(iRight, iTop, rotateArc, rotateArc, 90 * 16, -90 * 16);
+                painter->drawArc(iLeft, iBottom, rotateArc, rotateArc, 270 * 16, -90 * 16);
+                painter->drawArc(iRight, iBottom, rotateArc, rotateArc, 0 * 16, -90 * 16);
             }
         }
     }
@@ -284,7 +246,7 @@ auto VTextGraphicsItem::IsContained(QRectF rectBB, qreal dRot, qreal &dX, qreal
     dX = 0;
     dY = 0;
 
-    if (rectParent.contains(rectBB) == false)
+    if (not rectParent.contains(rectBB))
     {
         if (rectParent.left() - rectBB.left() > fabs(dX))
         {
@@ -325,7 +287,7 @@ void VTextGraphicsItem::UpdateData(const QString &qsName, const VPieceLabelData
  * @brief VTextGraphicsItem::UpdateData Updates the pattern label
  * @param pDoc pointer to the pattern object
  */
-void VTextGraphicsItem::UpdateData(VAbstractPattern* pDoc, const VContainer *pattern)
+void VTextGraphicsItem::UpdateData(VAbstractPattern *pDoc, const VContainer *pattern)
 {
     m_tm.Update(pDoc, pattern);
 }
@@ -340,6 +302,12 @@ auto VTextGraphicsItem::GetTextLines() const -> vsizetype
     return m_tm.GetSourceLinesCount();
 }
 
+//---------------------------------------------------------------------------------------------------------------------
+void VTextGraphicsItem::SetPieceName(const QString &name)
+{
+    m_pieceName = name;
+}
+
 //---------------------------------------------------------------------------------------------------------------------
 /**
  * @brief VTextGraphicsItem::GetFontSize returns the currently used text base font size
@@ -357,8 +325,8 @@ auto VTextGraphicsItem::GetFontSize() const -> int
  */
 void VTextGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *pME)
 {
-    if (pME->button() == Qt::LeftButton && pME->type() != QEvent::GraphicsSceneMouseDoubleClick
-            && (flags() & QGraphicsItem::ItemIsMovable))
+    if (pME->button() == Qt::LeftButton && pME->type() != QEvent::GraphicsSceneMouseDoubleClick &&
+        (flags() & QGraphicsItem::ItemIsMovable))
     {
         if (m_moveType == NotMovable)
         {
@@ -378,10 +346,10 @@ void VTextGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *pME)
         // in rotation mode, do not do any changes here, because user might want to
         // rotate the label more.
 
-        if ((m_moveType & AllModifications ) == AllModifications)
+        if ((m_moveType & AllModifications) == AllModifications)
         {
             AllUserModifications(pME->pos());
-            setZValue(ACTIVE_Z);
+            setZValue(activeZ);
             Update();
         }
         else if (m_moveType & IsRotatable)
@@ -399,7 +367,7 @@ void VTextGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *pME)
                 m_eMode = mRotate;
                 SetItemOverrideCursor(this, cursorArrowCloseHand, 1, 1);
             }
-            setZValue(ACTIVE_Z);
+            setZValue(activeZ);
             Update();
         }
         else if (m_moveType & IsResizable)
@@ -412,7 +380,7 @@ void VTextGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *pME)
             {
                 UserMoveAndResize(pME->pos());
             }
-            setZValue(ACTIVE_Z);
+            setZValue(activeZ);
             Update();
         }
         else if (m_moveType & IsMovable)
@@ -431,7 +399,7 @@ void VTextGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *pME)
                 SetItemOverrideCursor(this, cursorArrowCloseHand, 1, 1);
             }
 
-            setZValue(ACTIVE_Z);
+            setZValue(activeZ);
             Update();
         }
         else
@@ -450,102 +418,19 @@ void VTextGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *pME)
  * @brief VTextGraphicsItem::mouseMoveEvent handles mouse move events
  * @param pME pointer to QGraphicsSceneMouseEvent object
  */
-void VTextGraphicsItem::mouseMoveEvent(QGraphicsSceneMouseEvent* pME)
+void VTextGraphicsItem::mouseMoveEvent(QGraphicsSceneMouseEvent *pME)
 {
-    qreal dX;
-    qreal dY;
-    QRectF rectBB;
     if (m_eMode == mMove && m_moveType & IsMovable)
     {
-        const QPointF ptDiff = pME->scenePos() - m_ptStart;
-        // in move mode move the label along the mouse move from the origin
-        QPointF pt = m_ptStartPos + ptDiff;
-        rectBB.setTopLeft(pt);
-        rectBB.setWidth(m_rectBoundingBox.width());
-        rectBB.setHeight(m_rectBoundingBox.height());
-        // before moving label to a new position, check if it will still be inside the parent item
-        if (IsContained(rectBB, rotation(), dX, dY) == false)
-        {
-            pt.setX(pt.x() + dX);
-            pt.setY(pt.y() + dY);
-        }
-        setPos(pt);
-        UpdateBox();
+        MoveLabel(pME);
     }
     else if (m_eMode == mResize && m_moveType & IsResizable)
     {
-        QLineF vectorDiff(m_ptStart, pME->scenePos());
-        vectorDiff.setAngle(vectorDiff.angle() + m_dRotation);
-        const QPointF ptDiff = vectorDiff.p2() - m_ptStart;
-
-        // in resize mode, resize the label along the mouse move from the origin
-        QPointF pt;
-        QSizeF sz;
-
-        if (m_moveType & IsMovable)
-        {
-            const qreal newWidth = m_szStart.width() + ptDiff.x();
-            const qreal newHeight = m_szStart.height() + ptDiff.y();
-            if (newWidth <= minW || newHeight <= minH)
-            {
-                return;
-            }
-
-            pt = m_ptStartPos;
-            sz = QSizeF(newWidth, newHeight);
-        }
-        else
-        {
-            const qreal newWidth = m_szStart.width() + ptDiff.x()*2.0;
-            const qreal newHeight = m_szStart.height() + ptDiff.y()*2.0;
-            if (newWidth <= minW || newHeight <= minH)
-            {
-                return;
-            }
-
-            pt = QPointF(m_ptRotCenter.x() - newWidth/2.0, m_ptRotCenter.y() - newHeight/2.0);
-            sz = QSizeF(m_szStart.width() + ptDiff.x()*2.0, m_szStart.height() + ptDiff.y()*2.0);
-        }
-
-        rectBB.setTopLeft(pt);
-        rectBB.setSize(sz);
-        // before resizing the label to a new size, check if it will still be inside the parent item
-        if (IsContained(rectBB, rotation(), dX, dY))
-        {
-            if (not (m_moveType & IsMovable))
-            {
-                setPos(pt);
-            }
-        }
-        else
-        {
-            return;
-        }
-
-        SetSize(sz.width(), sz.height());
-        Update();
-        emit SignalShrink();
+        ResizeLabel(pME);
     }
     else if (m_eMode == mRotate && m_moveType & IsRotatable)
     {
-        // if the angle from the original position is small (0.5 degrees), just remeber the new angle
-        // new angle will be the starting angle for rotation
-        if (fabs(m_dAngle) < 0.01)
-        {
-            m_dAngle = GetAngle(mapToParent(pME->pos()));
-            return;
-        }
-        // calculate the angle difference from the starting angle
-        double dAng =  qRadiansToDegrees(GetAngle(mapToParent(pME->pos())) - m_dAngle);
-        rectBB.setTopLeft(m_ptStartPos);
-        rectBB.setWidth(m_rectBoundingBox.width());
-        rectBB.setHeight(m_rectBoundingBox.height());
-        // check if the rotated label will be inside the parent item and then rotate it
-        if (IsContained(rectBB, m_dRotation + dAng, dX, dY) == true)
-        {
-            setRotation(m_dRotation + dAng);
-            Update();
-        }
+        RotateLabel(pME);
     }
 }
 
@@ -554,56 +439,60 @@ void VTextGraphicsItem::mouseMoveEvent(QGraphicsSceneMouseEvent* pME)
  * @brief VTextGraphicsItem::mouseReleaseEvent handles left button mouse release events
  * @param pME pointer to QGraphicsSceneMouseEvent object
  */
-void VTextGraphicsItem::mouseReleaseEvent(QGraphicsSceneMouseEvent* pME)
+void VTextGraphicsItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *pME)
 {
-    if (pME->button() == Qt::LeftButton)
+    if (pME->button() != Qt::LeftButton)
     {
-        // restore the cursor
-        if ((m_eMode == mMove || m_eMode == mRotate || m_eMode == mResize) && (flags() & QGraphicsItem::ItemIsMovable))
-        {
-            SetItemOverrideCursor(this, cursorArrowOpenHand, 1, 1);
-        }
-        double dDist = fabs(pME->scenePos().x() - m_ptStart.x()) + fabs(pME->scenePos().y() - m_ptStart.y());
-        // determine if this was just press/release (bShort == true) or user did some operation between press and release
-        bool bShort = (dDist < 2);
+        return;
+    }
 
-        if (m_eMode == mMove || m_eMode == mResize)
-        {   // if user just pressed and released the button, we must switch the mode to rotate
-            // but if user did some operation (move/resize), emit the proper signal and update the label
-            if (bShort == true)
+    // restore the cursor
+    if ((m_eMode == mMove || m_eMode == mRotate || m_eMode == mResize) && (flags() & QGraphicsItem::ItemIsMovable))
+    {
+        SetItemOverrideCursor(this, cursorArrowOpenHand, 1, 1);
+    }
+
+    double dDist = fabs(pME->scenePos().x() - m_ptStart.x()) + fabs(pME->scenePos().y() - m_ptStart.y());
+    // determine if this was just press/release (bShort == true) or user did some operation between press and
+    // release
+    bool bShort = (dDist < 2);
+
+    if (m_eMode == mMove || m_eMode == mResize)
+    { // if user just pressed and released the button, we must switch the mode to rotate
+        // but if user did some operation (move/resize), emit the proper signal and update the label
+        if (bShort)
+        {
+            if (m_bReleased && m_moveType & IsRotatable)
             {
-                if (m_bReleased == true && m_moveType & IsRotatable)
-                {
-                    m_eMode = mRotate;
-                    UpdateBox();
-                }
-            }
-            else if (m_eMode == mMove && m_moveType & IsMovable)
-            {
-                emit SignalMoved(pos());
+                m_eMode = mRotate;
                 UpdateBox();
             }
-            else if (m_moveType & IsResizable)
-            {
-                emit SignalResized(m_rectBoundingBox.width(), m_tm.GetFont().pixelSize());
-                Update();
-            }
         }
-        else
-        {   // in rotate mode, if user did just press/release, switch to move mode
-            if (bShort == true && (m_moveType & IsMovable || m_moveType & IsResizable))
-            {
-                m_eMode = mMove;
-            }
-            else if (m_moveType & IsRotatable)
-            {
-                // if user rotated the item, emit proper signal and update the label
-                emit SignalRotated(rotation());
-            }
+        else if (m_eMode == mMove && m_moveType & IsMovable)
+        {
+            emit SignalMoved(pos());
             UpdateBox();
         }
-        m_bReleased = true;
+        else if (m_moveType & IsResizable)
+        {
+            emit SignalResized(m_rectBoundingBox.width());
+            Update();
+        }
     }
+    else
+    { // in rotate mode, if user did just press/release, switch to move mode
+        if (bShort && (m_moveType & IsMovable || m_moveType & IsResizable))
+        {
+            m_eMode = mMove;
+        }
+        else if (m_moveType & IsRotatable)
+        {
+            // if user rotated the item, emit proper signal and update the label
+            emit SignalRotated(rotation());
+        }
+        UpdateBox();
+    }
+    m_bReleased = true;
 }
 
 //---------------------------------------------------------------------------------------------------------------------
@@ -611,11 +500,11 @@ void VTextGraphicsItem::mouseReleaseEvent(QGraphicsSceneMouseEvent* pME)
  * @brief VTextGraphicsItem::hoverMoveEvent checks if cursor has to be changed
  * @param pHE pointer to the scene hover event
  */
-void VTextGraphicsItem::hoverMoveEvent(QGraphicsSceneHoverEvent* pHE)
+void VTextGraphicsItem::hoverMoveEvent(QGraphicsSceneHoverEvent *pHE)
 {
     if (m_eMode == mResize && m_moveType & IsResizable)
     {
-        if (m_rectResize.contains(pHE->pos()) == true)
+        if (m_rectResize.contains(pHE->pos()))
         {
             setCursor(Qt::SizeFDiagCursor);
         }
@@ -658,12 +547,11 @@ void VTextGraphicsItem::CorrectLabel()
     QRectF rectBB;
     rectBB.setTopLeft(pos());
     rectBB.setSize(m_rectBoundingBox.size());
-    if (IsContained(rectBB, rotation(), dX, dY) == false)
+    if (not IsContained(rectBB, rotation(), dX, dY))
     {
         // put the label inside the pattern
         setPos(pos().x() + dX, pos().y() + dY);
     }
-    m_tm.FitFontSize(m_rectBoundingBox.width(), m_rectBoundingBox.height());
     UpdateBox();
 }
 
@@ -693,7 +581,7 @@ void VTextGraphicsItem::UserRotateAndMove()
 //---------------------------------------------------------------------------------------------------------------------
 void VTextGraphicsItem::UserMoveAndResize(const QPointF &pos)
 {
-    if (m_rectResize.contains(pos) == true)
+    if (m_rectResize.contains(pos))
     {
         m_eMode = mResize;
         setCursor(Qt::SizeFDiagCursor);
@@ -704,3 +592,169 @@ void VTextGraphicsItem::UserMoveAndResize(const QPointF &pos)
         SetItemOverrideCursor(this, cursorArrowCloseHand, 1, 1);
     }
 }
+
+//---------------------------------------------------------------------------------------------------------------------
+void VTextGraphicsItem::MoveLabel(QGraphicsSceneMouseEvent *pME)
+{
+    const QPointF ptDiff = pME->scenePos() - m_ptStart;
+    // in move mode move the label along the mouse move from the origin
+    QPointF pt = m_ptStartPos + ptDiff;
+    QRectF rectBB;
+    rectBB.setTopLeft(pt);
+    rectBB.setWidth(m_rectBoundingBox.width());
+    rectBB.setHeight(m_rectBoundingBox.height());
+    // before moving label to a new position, check if it will still be inside the parent item
+    qreal dX;
+    qreal dY;
+    if (not IsContained(rectBB, rotation(), dX, dY))
+    {
+        pt.setX(pt.x() + dX);
+        pt.setY(pt.y() + dY);
+    }
+    setPos(pt);
+    UpdateBox();
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VTextGraphicsItem::ResizeLabel(QGraphicsSceneMouseEvent *pME)
+{
+    QLineF vectorDiff(m_ptStart, pME->scenePos());
+    vectorDiff.setAngle(vectorDiff.angle() + m_dRotation);
+    const QPointF ptDiff = vectorDiff.p2() - m_ptStart;
+
+    // in resize mode, resize the label along the mouse move from the origin
+    QPointF pt;
+    QSizeF sz;
+
+    if (m_moveType & IsMovable)
+    {
+        const qreal newWidth = m_szStart.width() + ptDiff.x();
+        const qreal newHeight = m_szStart.height() + ptDiff.y();
+        if (newWidth <= minW || newHeight <= minH)
+        {
+            return;
+        }
+
+        pt = m_ptStartPos;
+        sz = QSizeF(newWidth, newHeight);
+    }
+    else
+    {
+        const qreal newWidth = m_szStart.width() + ptDiff.x() * 2.0;
+        const qreal newHeight = m_szStart.height() + ptDiff.y() * 2.0;
+        if (newWidth <= minW || newHeight <= minH)
+        {
+            return;
+        }
+
+        pt = QPointF(m_ptRotCenter.x() - newWidth / 2.0, m_ptRotCenter.y() - newHeight / 2.0);
+        sz = QSizeF(m_szStart.width() + ptDiff.x() * 2.0, m_szStart.height() + ptDiff.y() * 2.0);
+    }
+
+    QRectF rectBB;
+    rectBB.setTopLeft(pt);
+    rectBB.setSize(sz);
+    // before resizing the label to a new size, check if it will still be inside the parent item
+    qreal dX;
+    qreal dY;
+    if (IsContained(rectBB, rotation(), dX, dY))
+    {
+        if (not(m_moveType & IsMovable))
+        {
+            setPos(pt);
+        }
+    }
+    else
+    {
+        return;
+    }
+
+    SetSize(sz.width(), sz.height());
+    Update();
+    emit SignalShrink();
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VTextGraphicsItem::RotateLabel(QGraphicsSceneMouseEvent *pME)
+{
+    // if the angle from the original position is small (0.5 degrees), just remeber the new angle
+    // new angle will be the starting angle for rotation
+    if (fabs(m_dAngle) < 0.01)
+    {
+        m_dAngle = GetAngle(mapToParent(pME->pos()));
+        return;
+    }
+
+    QRectF rectBB;
+    rectBB.setTopLeft(m_ptStartPos);
+    rectBB.setWidth(m_rectBoundingBox.width());
+    rectBB.setHeight(m_rectBoundingBox.height());
+
+    // calculate the angle difference from the starting angle
+    double dAng = qRadiansToDegrees(GetAngle(mapToParent(pME->pos())) - m_dAngle);
+
+    // check if the rotated label will be inside the parent item and then rotate it
+    qreal dX;
+    qreal dY;
+    if (IsContained(rectBB, m_dRotation + dAng, dX, dY))
+    {
+        setRotation(m_dRotation + dAng);
+        Update();
+    }
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+void VTextGraphicsItem::PaintLabel(QPainter *painter)
+{
+    const QRectF boundingRect = this->boundingRect();
+    const int iW = qFloor(boundingRect.width());
+    QFont fnt = m_tm.GetFont();
+    const QVector<TextLine> labelLines = m_tm.GetLabelSourceLines(iW, fnt);
+
+    // draw text lines
+    int iY = 0;
+    for (const auto &tl : labelLines)
+    {
+        fnt.setPointSize(m_tm.GetFont().pointSize() + tl.m_iFontSize);
+        fnt.setBold(tl.m_bold);
+        fnt.setItalic(tl.m_italic);
+
+        QString qsText = tl.m_qsText;
+        QFontMetrics fm(fnt);
+
+        int lineHeight = fm.height();
+        if (iY + fm.height() > boundingRect.height())
+        {
+            lineHeight = qFloor(boundingRect.height()) - iY;
+        }
+
+        painter->setFont(fnt);
+        painter->drawText(0, iY, iW, lineHeight, static_cast<int>(tl.m_eAlign), qsText);
+
+        // check if the next line will go out of bounds
+        if (iY + fm.height() > boundingRect.height())
+        {
+            QString errorMsg;
+            switch (m_itemType)
+            {
+                case PatternLabel:
+                    errorMsg = tr("Piece '%1'. Not enough space for pattern info label.").arg(m_pieceName);
+                    break;
+                case PieceLabel:
+                    errorMsg = tr("Piece '%1'. Not enough space for piece info label.").arg(m_pieceName);
+                    break;
+                case Unknown:
+                default:
+                    errorMsg = tr("Piece '%1'. Not enough space for label.").arg(m_pieceName);
+                    break;
+            };
+
+            VAbstractApplication::VApp()->IsPedantic()
+                ? throw VException(errorMsg)
+                : qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
+            break;
+        }
+
+        iY += fm.height() + m_tm.GetSpacing();
+    }
+}

src/libs/vwidgets/vtextgraphicsitem.h

@@ -40,8 +40,8 @@
 #include <QString>
 #include <QtGlobal>
 
-#include "vpieceitem.h"
 #include "../vlayout/vtextmanager.h"
+#include "vpieceitem.h"
 
 /**
  * @brief The VTextGraphicsItem class. This class implements text graphics item,
@@ -51,52 +51,72 @@
 class VTextGraphicsItem final : public VPieceItem
 {
     Q_OBJECT // NOLINT
+
 public:
-    explicit VTextGraphicsItem(QGraphicsItem* pParent = nullptr);
-    virtual ~VTextGraphicsItem() = default;
+    enum ItemType
+    {
+        PatternLabel,
+        PieceLabel,
+        Unknown
+    };
 
-    virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;
-    virtual void Update() override;
+    explicit VTextGraphicsItem(ItemType type, QGraphicsItem *pParent = nullptr);
+    ~VTextGraphicsItem() override = default;
 
-    virtual auto type() const -> int override { return Type; }
-    enum { Type = UserType + static_cast<int>(Vis::TextGraphicsItem)};
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;
+    void Update() override;
 
-    void SetFont(const QFont& fnt);
+    auto type() const -> int override { return Type; }
+    enum
+    {
+        Type = UserType + static_cast<int>(Vis::TextGraphicsItem)
+    };
+
+    void SetFont(const QFont &fnt);
     auto GetFontSize() const -> int;
     void SetSize(qreal fW, qreal fH);
     auto IsContained(QRectF rectBB, qreal dRot, qreal &dX, qreal &dY) const -> bool;
-    void UpdateData(const QString& qsName, const VPieceLabelData& data, const VContainer *pattern);
-    void UpdateData(VAbstractPattern* pDoc, const VContainer *pattern);
+    void UpdateData(const QString &qsName, const VPieceLabelData &data, const VContainer *pattern);
+    void UpdateData(VAbstractPattern *pDoc, const VContainer *pattern);
     auto GetTextLines() const -> vsizetype;
+    void SetPieceName(const QString &name);
 
 protected:
-    virtual void mousePressEvent(QGraphicsSceneMouseEvent* pME) override;
-    virtual void mouseMoveEvent(QGraphicsSceneMouseEvent* pME) override;
-    virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent* pME) override;
-    virtual void hoverEnterEvent(QGraphicsSceneHoverEvent *pME) override;
-    virtual void hoverMoveEvent(QGraphicsSceneHoverEvent* pHE) override;
+    void mousePressEvent(QGraphicsSceneMouseEvent *pME) override;
+    void mouseMoveEvent(QGraphicsSceneMouseEvent *pME) override;
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent *pME) override;
+    void hoverEnterEvent(QGraphicsSceneHoverEvent *pME) override;
+    void hoverMoveEvent(QGraphicsSceneHoverEvent *pHE) override;
 
     void UpdateBox();
     void CorrectLabel();
 
 signals:
-    void SignalResized(qreal iTW, int iFontSize);
+    void SignalResized(qreal iTW);
     void SignalRotated(qreal dAng);
     void SignalShrink();
 
 private:
     Q_DISABLE_COPY_MOVE(VTextGraphicsItem) // NOLINT
-    QPointF      m_ptStartPos;
-    QPointF      m_ptStart;
-    QSizeF       m_szStart;
-    double       m_dRotation;
-    double       m_dAngle;
-    QRectF       m_rectResize;
-    VTextManager m_tm;
+    QPointF m_ptStartPos{};
+    QPointF m_ptStart{};
+    QSizeF m_szStart{};
+    double m_dRotation{0};
+    double m_dAngle{0};
+    QRectF m_rectResize{};
+    VTextManager m_tm{};
+    QString m_pieceName{};
+    ItemType m_itemType{Unknown};
 
     void AllUserModifications(const QPointF &pos);
     void UserRotateAndMove();
     void UserMoveAndResize(const QPointF &pos);
+
+    void MoveLabel(QGraphicsSceneMouseEvent *pME);
+    void ResizeLabel(QGraphicsSceneMouseEvent *pME);
+    void RotateLabel(QGraphicsSceneMouseEvent *pME);
+
+    void PaintLabel(QPainter *painter);
 };
 
 #endif // VTEXTGRAPHICSITEM_H