aw/valentina
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactoring.

Browse Source 
Fix code style.
This commit is contained in:
Roman Telezhynskyi 2023-05-22 17:27:15 +03:00
parent 1a0ca6c782
commit e540c6292c
15 changed files with 1132 additions and 1179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
src/app/puzzle/scene/vpgraphicspiece.cpp
View File

@ -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,7 +101,7 @@ 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);
@ -110,9 +110,8 @@ inline auto LineFont(const TextLine& tl, const QFont &base) -> QFont
return fnt;
}
//---------------------------------------------------------------------------------------------------------------------
inline auto LineText(const TextLine& tl, const QFontMetrics &fm, qreal width) -> QString
inline auto LineText(const TextLine &tl, const QFontMetrics &fm, qreal width) -> QString
{
QString qsText = tl.m_qsText;
if (TextWidth(fm, qsText) > width)
@ -124,7 +123,7 @@ inline auto LineText(const TextLine& tl, const QFontMetrics &fm, qreal width) ->
}
//---------------------------------------------------------------------------------------------------------------------
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 +134,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 +149,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 +189,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 +197,7 @@ auto VPGraphicsPiece::boundingRect() const -> QRectF
//---------------------------------------------------------------------------------------------------------------------
auto VPGraphicsPiece::shape() const -> QPainterPath
{
if(!m_cuttingLine.isEmpty())
if (!m_cuttingLine.isEmpty())
{
return m_cuttingLine;
}
@ -222,11 +221,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 +249,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 +266,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 +313,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 +323,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,7 +398,7 @@ 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));
@ -429,9 +428,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 +440,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 +463,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 +515,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 +540,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 +563,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 +584,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 +609,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 +806,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 +824,3 @@ auto VPGraphicsPiece::itemChange(GraphicsItemChange change, const QVariant &valu
return QGraphicsObject::itemChange(change, value);
}

67
src/app/puzzle/xml/vplayoutfilereader.cpp
View File

@ -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
@ -976,7 +971,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 +979,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 +1011,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 +1022,7 @@ auto VPLayoutFileReader::ReadAttributeBool(const QXmlStreamAttributes &attribs,
case 3: // 0
val = false;
break;
default:// others
default: // others
throw VExceptionConversionError(message, name);
}
}

45
src/app/valentina/dialogs/configpages/preferencespatternpage.cpp
View File

@ -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);
@ -192,7 +193,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 +218,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);
}
}

6
src/app/valentina/dialogs/configpages/preferencespatternpage.h
View File

@ -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();

727
src/app/valentina/xml/vpattern.cpp
View File

File diff suppressed because it is too large Load Diff

295
src/libs/vlayout/vlayoutpiece.cpp
View File

@ -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)
{
@ -934,7 +935,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 +947,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);
@ -1003,7 +1002,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 +1153,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 +1234,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 +1263,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 +1277,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 +1290,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 +1334,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 +1389,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 +1405,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 +1460,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 +1471,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 +1488,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 +1517,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 +1553,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,12 +1565,12 @@ 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 TextLine& tl = tm.GetSourceLine(i);
const TextLine &tl = tm.GetSourceLine(i);
QFont fnt = tm.GetFont();
fnt.setPixelSize(tm.GetFont().pixelSize() + tl.m_iFontSize);
fnt.setBold(tl.m_bold);
@ -1604,7 +1601,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 +1629,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 +1640,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 +1769,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 +1796,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);

10
src/libs/vlayout/vtextmanager.cpp
View File

@ -117,7 +117,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
@ -644,10 +644,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 +660,8 @@ 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;
}

6
src/libs/vmisc/vcommonsettings.h
View File

@ -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;

40
src/libs/vpatterndb/floatItemData/vpatternlabeldata_p.h
View File

@ -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

461
src/libs/vtools/dialogs/tools/piece/dialogseamallowance.cpp
View File

@ -76,7 +76,16 @@
#include <array>
#include <cstddef>
enum TabOrder {Paths=0, Pins=1, Labels=2, Grainline=3, Passmarks=4, PlaceLabels=5, Count=6};
enum TabOrder
{
Paths = 0,
Pins = 1,
Labels = 2,
Grainline = 3,
Passmarks = 4,
PlaceLabels = 5,
Count = 6
};
namespace
{
@ -120,9 +129,8 @@ void InitComboBoxFormats(QComboBox *box, const QStringList &items, const QString
} // namespace
//---------------------------------------------------------------------------------------------------------------------
DialogSeamAllowance::DialogSeamAllowance(const VContainer *data, VAbstractPattern *doc, quint32 toolId,
QWidget *parent)
: DialogSeamAllowance(data, toolId, parent)
DialogSeamAllowance::DialogSeamAllowance(const VContainer *data, VAbstractPattern *doc, quint32 toolId, QWidget *parent)
: DialogSeamAllowance(data, toolId, parent)
{
SCASSERT(doc != nullptr)
m_doc = doc;
@ -177,7 +185,7 @@ DialogSeamAllowance::DialogSeamAllowance(const VContainer *data, quint32 toolId,
ChangeColor(uiTabPaths->labelEditName, OkColor(this));
flagMainPathIsValid = MainPathIsValid();
m_ftb->SetCurrentIndex(TabOrder::Paths);// Show always first tab active on start.
m_ftb->SetCurrentIndex(TabOrder::Paths); // Show always first tab active on start.
}
//---------------------------------------------------------------------------------------------------------------------
@ -256,7 +264,7 @@ void DialogSeamAllowance::SetPiece(const VPiece &piece)
item->setFont(NodeFont(item->font()));
item->setData(Qt::UserRole, QVariant::fromValue(record));
uiTabPaths->listWidgetCustomSA->addItem(item);
uiTabPaths->listWidgetCustomSA->setCurrentRow(uiTabPaths->listWidgetCustomSA->count()-1);
uiTabPaths->listWidgetCustomSA->setCurrentRow(uiTabPaths->listWidgetCustomSA->count() - 1);
}
}
uiTabPaths->listWidgetCustomSA->blockSignals(false);
@ -273,7 +281,7 @@ void DialogSeamAllowance::SetPiece(const VPiece &piece)
item->setFont(NodeFont(item->font()));
item->setData(Qt::UserRole, QVariant::fromValue(path));
uiTabPaths->listWidgetInternalPaths->addItem(item);
uiTabPaths->listWidgetInternalPaths->setCurrentRow(uiTabPaths->listWidgetInternalPaths->count()-1);
uiTabPaths->listWidgetInternalPaths->setCurrentRow(uiTabPaths->listWidgetInternalPaths->count() - 1);
}
}
@ -289,7 +297,7 @@ void DialogSeamAllowance::SetPiece(const VPiece &piece)
item->setFont(NodeFont(item->font()));
item->setData(Qt::UserRole, QVariant::fromValue(point));
listWidget->addItem(item);
listWidget->setCurrentRow(uiTabPins->listWidgetPins->count()-1);
listWidget->setCurrentRow(uiTabPins->listWidgetPins->count() - 1);
}
catch (const VExceptionBadId &e)
{
@ -340,9 +348,8 @@ void DialogSeamAllowance::SetPiece(const VPiece &piece)
uiTabPaths->lineEditGradationLabel->setText(piece.GetGradationLabel());
uiTabPaths->spinBoxPriority->setValue(static_cast<int>(piece.GetPriority()));
uiTabPaths->plainTextEditFormulaWidth->setPlainText(
VAbstractApplication::VApp()->TrVars()
->FormulaToUser(piece.GetFormulaSAWidth(), VAbstractApplication::VApp()->Settings()->GetOsSeparator()));
uiTabPaths->plainTextEditFormulaWidth->setPlainText(VAbstractApplication::VApp()->TrVars()->FormulaToUser(
piece.GetFormulaSAWidth(), VAbstractApplication::VApp()->Settings()->GetOsSeparator()));
m_saWidth = piece.GetSAWidth();
const VPieceLabelData &ppData = piece.GetPieceLabelData();
@ -525,7 +532,7 @@ void DialogSeamAllowance::CheckState()
SCASSERT(bOk != nullptr);
bOk->setEnabled(IsValid());
// In case dialog hasn't apply button
if ( bApply != nullptr && applyAllowed)
if (bApply != nullptr && applyAllowed)
{
bApply->setEnabled(bOk->isEnabled());
}
@ -557,8 +564,8 @@ void DialogSeamAllowance::CheckState()
if (not applyAllowed)
{
tooltip = tooltip + QStringLiteral(" <b>") +
tr("To open all detail's features complete creating the main path. Please, press OK.")
+ QStringLiteral("</b>");
tr("To open all detail's features complete creating the main path. Please, press OK.") +
QStringLiteral("</b>");
}
uiTabPaths->helpLabel->setText(tooltip);
uiTabPaths->tabWidget->setTabIcon(uiTabPaths->tabWidget->indexOf(uiTabPaths->tabMainPath), QIcon());
@ -664,7 +671,7 @@ void DialogSeamAllowance::showEvent(QShowEvent *event)
resize(sz);
}
isInitialized = true;//first show windows are held
isInitialized = true; // first show windows are held
}
//---------------------------------------------------------------------------------------------------------------------
@ -878,8 +885,8 @@ void DialogSeamAllowance::ShowCustomSAContextMenu(const QPoint &pos)
void DialogSeamAllowance::ShowInternalPathsContextMenu(const QPoint &pos)
{
const int row = uiTabPaths->listWidgetInternalPaths->currentRow();
if (uiTabPaths->listWidgetInternalPaths->count() == 0 || row == -1
|| row >= uiTabPaths->listWidgetInternalPaths->count())
if (uiTabPaths->listWidgetInternalPaths->count() == 0 || row == -1 ||
row >= uiTabPaths->listWidgetInternalPaths->count())
{
return;
}
@ -935,9 +942,8 @@ void DialogSeamAllowance::ShowPinsContextMenu(const QPoint &pos)
void DialogSeamAllowance::ShowPlaceLabelsContextMenu(const QPoint &pos)
{
const int row = uiTabPlaceLabels->listWidgetPlaceLabels->currentRow();
if (uiTabPlaceLabels->listWidgetPlaceLabels->count() == 0
|| row == -1
|| row >= uiTabPlaceLabels->listWidgetPlaceLabels->count())
if (uiTabPlaceLabels->listWidgetPlaceLabels->count() == 0 || row == -1 ||
row >= uiTabPlaceLabels->listWidgetPlaceLabels->count())
{
return;
}
@ -963,10 +969,9 @@ void DialogSeamAllowance::ShowPlaceLabelsContextMenu(const QPoint &pos)
newLabel.SetLabelType(type);
m_newPlaceLabels.insert(labelId, newLabel);
QPointer<VUndoCommand> saveCommand =
new SavePlaceLabelOptions(toolId, currentLabel, newLabel,
VAbstractValApplication::VApp()->getCurrentDocument(),
const_cast<VContainer *>(data), labelId);
QPointer<VUndoCommand> saveCommand = new SavePlaceLabelOptions(
toolId, currentLabel, newLabel, VAbstractValApplication::VApp()->getCurrentDocument(),
const_cast<VContainer *>(data), labelId);
m_undoStack.append(saveCommand);
UpdateCurrentPlaceLabelRecords();
};
@ -1096,9 +1101,9 @@ void DialogSeamAllowance::NodeChanged(int index)
QString w1Formula = node.GetFormulaSABefore();
EnableDefButton(uiTabPaths->pushButtonDefBefore, w1Formula);
w1Formula = VAbstractApplication::VApp()->TrVars()
->FormulaToUser(w1Formula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
if (w1Formula.length() > 80)// increase height if needed.
w1Formula = VAbstractApplication::VApp()->TrVars()->FormulaToUser(
w1Formula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
if (w1Formula.length() > 80) // increase height if needed.
{
this->DeployWidthBeforeFormulaTextEdit();
}
@ -1111,9 +1116,9 @@ void DialogSeamAllowance::NodeChanged(int index)
QString w2Formula = node.GetFormulaSAAfter();
EnableDefButton(uiTabPaths->pushButtonDefAfter, w2Formula);
w2Formula = VAbstractApplication::VApp()->TrVars()
->FormulaToUser(w2Formula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
if (w2Formula.length() > 80)// increase height if needed.
w2Formula = VAbstractApplication::VApp()->TrVars()->FormulaToUser(
w2Formula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
if (w2Formula.length() > 80) // increase height if needed.
{
this->DeployWidthAfterFormulaTextEdit();
}
@ -1288,8 +1293,8 @@ void DialogSeamAllowance::NodeAngleChanged(int index)
//---------------------------------------------------------------------------------------------------------------------
void DialogSeamAllowance::ReturnDefBefore()
{
const QString def = VAbstractApplication::VApp()->TrVars()
->FormulaToUser(currentSeamAllowance, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
const QString def = VAbstractApplication::VApp()->TrVars()->FormulaToUser(
currentSeamAllowance, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
uiTabPaths->plainTextEditFormulaWidthBefore->setPlainText(def);
if (auto *button = qobject_cast<QPushButton *>(sender()))
{
@ -1300,8 +1305,8 @@ void DialogSeamAllowance::ReturnDefBefore()
//---------------------------------------------------------------------------------------------------------------------
void DialogSeamAllowance::ReturnDefAfter()
{
const QString def = VAbstractApplication::VApp()->TrVars()
->FormulaToUser(currentSeamAllowance, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
const QString def = VAbstractApplication::VApp()->TrVars()->FormulaToUser(
currentSeamAllowance, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
uiTabPaths->plainTextEditFormulaWidthAfter->setPlainText(def);
if (auto *button = qobject_cast<QPushButton *>(sender()))
{
@ -1328,7 +1333,7 @@ void DialogSeamAllowance::CustomSAChanged(int row)
return;
}
const QListWidgetItem *item = uiTabPaths->listWidgetCustomSA->item( row );
const QListWidgetItem *item = uiTabPaths->listWidgetCustomSA->item(row);
SCASSERT(item != nullptr);
const auto record = qvariant_cast<CustomSARecord>(item->data(Qt::UserRole));
@ -1380,10 +1385,9 @@ void DialogSeamAllowance::PathDialogClosed(int result)
VPiecePath newPath = dialogTool->GetPiecePath();
m_newPaths.insert(dialogTool->GetToolId(), newPath);
QPointer<VUndoCommand> saveCommand =
new SavePiecePathOptions(toolId, currentPath, newPath,
VAbstractValApplication::VApp()->getCurrentDocument(),
const_cast<VContainer *>(data), dialogTool->GetToolId());
QPointer<VUndoCommand> saveCommand = new SavePiecePathOptions(
toolId, currentPath, newPath, VAbstractValApplication::VApp()->getCurrentDocument(),
const_cast<VContainer *>(data), dialogTool->GetToolId());
m_undoStack.append(saveCommand);
UpdateCurrentCustomSARecord();
UpdateCurrentInternalPathRecord();
@ -1391,7 +1395,7 @@ void DialogSeamAllowance::PathDialogClosed(int result)
catch (const VExceptionBadId &e)
{
qCritical("%s\n\n%s\n\n%s", qUtf8Printable(tr("Error. Can't save piece path.")),
qUtf8Printable(e.ErrorMessage()), qUtf8Printable(e.DetailedInformation()));
qUtf8Printable(e.ErrorMessage()), qUtf8Printable(e.DetailedInformation()));
}
}
delete m_dialog;
@ -1409,7 +1413,7 @@ void DialogSeamAllowance::PlaceLabelDialogClosed(int result)
{
VPlaceLabelItem currentLabel = CurrentPlaceLabel(dialogTool->GetToolId());
const QHash<QString, QSharedPointer<VInternalVariable> > *vars = data->DataVariables();
const QHash<QString, QSharedPointer<VInternalVariable>> *vars = data->DataVariables();
const qreal w = qAbs(Visualization::FindLengthFromUser(dialogTool->GetWidth(), vars, false));
const qreal h = qAbs(Visualization::FindLengthFromUser(dialogTool->GetHeight(), vars, false));
@ -1417,7 +1421,7 @@ void DialogSeamAllowance::PlaceLabelDialogClosed(int result)
const qreal v = Visualization::FindValFromUser(dialogTool->GetFormulaVisible(), vars, false);
qDebug() << w << h << a << v;
VPlaceLabelItem newLabel = VPlaceLabelItem();
VPlaceLabelItem newLabel = VPlaceLabelItem();
newLabel.setName(currentLabel.name());
newLabel.setX(currentLabel.x());
newLabel.setY(currentLabel.y());
@ -1433,17 +1437,16 @@ void DialogSeamAllowance::PlaceLabelDialogClosed(int result)
m_newPlaceLabels.insert(dialogTool->GetToolId(), newLabel);
QPointer<VUndoCommand> saveCommand =
new SavePlaceLabelOptions(toolId, currentLabel, newLabel,
VAbstractValApplication::VApp()->getCurrentDocument(),
const_cast<VContainer *>(data), dialogTool->GetToolId());
QPointer<VUndoCommand> saveCommand = new SavePlaceLabelOptions(
toolId, currentLabel, newLabel, VAbstractValApplication::VApp()->getCurrentDocument(),
const_cast<VContainer *>(data), dialogTool->GetToolId());
m_undoStack.append(saveCommand);
UpdateCurrentPlaceLabelRecords();
}
catch (const VExceptionBadId &e)
{
qCritical("%s\n\n%s\n\n%s", qUtf8Printable(tr("Error. Can't save piece path.")),
qUtf8Printable(e.ErrorMessage()), qUtf8Printable(e.DetailedInformation()));
qUtf8Printable(e.ErrorMessage()), qUtf8Printable(e.DetailedInformation()));
}
}
delete m_dialog;
@ -1466,7 +1469,7 @@ void DialogSeamAllowance::FancyTabChanged(int index)
QT_WARNING_PUSH
QT_WARNING_DISABLE_GCC("-Wswitch-default")
switch(index)
switch (index)
{
case TabOrder::Paths:
m_tabPaths->show();
@ -1683,8 +1686,8 @@ void DialogSeamAllowance::UpdateGrainlineValues()
for (std::size_t i = 0; i < 2; ++i)
{
QLabel* plbVal;
QLabel* plbText;
QLabel *plbVal;
QLabel *plbText;
QString qsUnit;
if (i == 0)
{
@ -1705,8 +1708,8 @@ void DialogSeamAllowance::UpdateGrainlineValues()
QString qsVal;
try
{
qsFormula = VAbstractApplication::VApp()->TrVars()
->FormulaFromUser(qsFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
qsFormula = VAbstractApplication::VApp()->TrVars()->FormulaFromUser(
qsFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
Calculator cal;
qreal dVal = cal.EvalFormula(data->DataVariables(), qsFormula);
if (qIsInf(dVal) || qIsNaN(dVal))
@ -1757,8 +1760,8 @@ void DialogSeamAllowance::UpdateDetailLabelValues()
for (std::size_t i = 0; i < 3; ++i)
{
QLabel* plbVal;
QLabel* plbText;
QLabel *plbVal;
QLabel *plbText;
QString qsUnit;
if (i == 0)
{
@ -1786,8 +1789,8 @@ void DialogSeamAllowance::UpdateDetailLabelValues()
try
{
qsFormula = VAbstractApplication::VApp()->TrVars()
->FormulaFromUser(qsFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
qsFormula = VAbstractApplication::VApp()->TrVars()->FormulaFromUser(
qsFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
Calculator cal;
qreal dVal = cal.EvalFormula(data->DataVariables(), qsFormula);
if (qIsInf(dVal) || qIsNaN(dVal))
@ -1819,7 +1822,7 @@ void DialogSeamAllowance::UpdateDetailLabelValues()
flagDLAngle = bFormulasOK[2];
flagDLFormulas = bFormulasOK[0] && bFormulasOK[1];
if (not flagDLAngle || not (flagDLFormulas || flagDPin) || not flagPLAngle || not (flagPLFormulas || flagPPin))
if (not flagDLAngle || not(flagDLFormulas || flagDPin) || not flagPLAngle || not(flagPLFormulas || flagPPin))
{
m_ftb->SetTabText(TabOrder::Labels, tr("Labels") + '*');
const QIcon icon = QIcon::fromTheme(QStringLiteral("dialog-warning"),
@ -1842,8 +1845,8 @@ void DialogSeamAllowance::UpdatePatternLabelValues()
for (std::size_t i = 0; i < 3; ++i)
{
QLabel* plbVal;
QLabel* plbText;
QLabel *plbVal;
QLabel *plbText;
QString qsUnit;
if (i == 0)
{
@ -1870,8 +1873,8 @@ void DialogSeamAllowance::UpdatePatternLabelValues()
QString qsVal;
try
{
qsFormula = VAbstractApplication::VApp()->TrVars()
->FormulaFromUser(qsFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
qsFormula = VAbstractApplication::VApp()->TrVars()->FormulaFromUser(
qsFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
Calculator cal;
qreal dVal = cal.EvalFormula(data->DataVariables(), qsFormula);
if (qIsInf(dVal) || qIsNaN(dVal))
@ -1903,7 +1906,7 @@ void DialogSeamAllowance::UpdatePatternLabelValues()
flagPLAngle = bFormulasOK[2];
flagPLFormulas = bFormulasOK[0] && bFormulasOK[1];
if (not flagDLAngle || not (flagDLFormulas || flagDPin) || not flagPLAngle || not (flagPLFormulas || flagPPin))
if (not flagDLAngle || not(flagDLFormulas || flagDPin) || not flagPLAngle || not(flagPLFormulas || flagPPin))
{
m_ftb->SetTabText(TabOrder::Labels, tr("Labels") + '*');
const QIcon icon = QIcon::fromTheme(QStringLiteral("dialog-warning"),
@ -2041,7 +2044,7 @@ void DialogSeamAllowance::EnabledManualPassmarkAngle()
//---------------------------------------------------------------------------------------------------------------------
void DialogSeamAllowance::EditGrainlineFormula()
{
QPlainTextEdit* pleFormula;
QPlainTextEdit *pleFormula;
bool bCheckZero;
QString title;
@ -2092,7 +2095,7 @@ void DialogSeamAllowance::EditGrainlineFormula()
//---------------------------------------------------------------------------------------------------------------------
void DialogSeamAllowance::EditDLFormula()
{
QPlainTextEdit* pleFormula;
QPlainTextEdit *pleFormula;
bool bCheckZero;
QString title;
@ -2152,7 +2155,7 @@ void DialogSeamAllowance::EditDLFormula()
//---------------------------------------------------------------------------------------------------------------------
void DialogSeamAllowance::EditPLFormula()
{
QPlainTextEdit* pleFormula;
QPlainTextEdit *pleFormula;
bool bCheckZero;
QString title;
@ -2218,7 +2221,7 @@ void DialogSeamAllowance::DeployGrainlineRotation()
//---------------------------------------------------------------------------------------------------------------------
void DialogSeamAllowance::DeployGrainlineLength()
{
DeployFormula(this,uiTabGrainline->lineEditLenFormula, uiTabGrainline->pushButtonShowLen, m_iLenBaseHeight);
DeployFormula(this, uiTabGrainline->lineEditLenFormula, uiTabGrainline->pushButtonShowLen, m_iLenBaseHeight);
}
//---------------------------------------------------------------------------------------------------------------------
@ -2594,7 +2597,7 @@ void DialogSeamAllowance::GrainlinePinPointChanged()
else
{
flagGPin = false;
topPinId == NULL_ID && bottomPinId == NULL_ID ? color = OkColor(this) : color = errorColor;
topPinId == NULL_ID &&bottomPinId == NULL_ID ? color = OkColor(this) : color = errorColor;
if (not flagGFormulas && not flagGPin)
{
@ -2628,7 +2631,7 @@ void DialogSeamAllowance::DetailPinPointChanged()
else
{
flagDPin = false;
topPinId == NULL_ID && bottomPinId == NULL_ID ? color = OkColor(this) : color = errorColor;
topPinId == NULL_ID &&bottomPinId == NULL_ID ? color = OkColor(this) : color = errorColor;
m_ftb->SetTabText(TabOrder::Labels, tr("Labels") + '*');
const QIcon icon = QIcon::fromTheme(QStringLiteral("dialog-warning"),
@ -2662,7 +2665,7 @@ void DialogSeamAllowance::PatternPinPointChanged()
else
{
flagPPin = false;
topPinId == NULL_ID && bottomPinId == NULL_ID ? color = OkColor(this) : color = errorColor;
topPinId == NULL_ID &&bottomPinId == NULL_ID ? color = OkColor(this) : color = errorColor;
m_ftb->SetTabText(TabOrder::Labels, tr("Labels") + '*');
const QIcon icon = QIcon::fromTheme(QStringLiteral("dialog-warning"),
@ -2762,7 +2765,7 @@ auto DialogSeamAllowance::CreatePiece() const -> VPiece
piece.GetGrainlineGeometry().SetVisible(uiTabGrainline->groupBoxGrainline->isChecked());
piece.GetGrainlineGeometry().SetArrowType(
static_cast<GrainlineArrowDirection>(uiTabGrainline->comboBoxArrow->currentData().toInt()));
static_cast<GrainlineArrowDirection>(uiTabGrainline->comboBoxArrow->currentData().toInt()));
if (not flagGPin)
{
@ -2811,13 +2814,13 @@ auto DialogSeamAllowance::GetPathName(quint32 path, bool reverse) const -> QStri
//---------------------------------------------------------------------------------------------------------------------
auto DialogSeamAllowance::MainPathIsValid() const -> bool
{
if(CreatePiece().MainPathPoints(data).count() < 3)
if (CreatePiece().MainPathPoints(data).count() < 3)
{
uiTabPaths->helpLabel->setText(DialogWarningIcon() + tr("You need more points!"));
return false;
}
if(not MainPathIsClockwise())
if (not MainPathIsClockwise())
{
uiTabPaths->helpLabel->setText(DialogWarningIcon() + tr("You have to choose points in a clockwise direction!"));
return false;
@ -2877,7 +2880,7 @@ auto DialogSeamAllowance::MainPathIsClockwise() const -> bool
QVector<QPointF> points;
CastTo(CreatePiece().MainPathPoints(data), points);
if(points.count() < 3)
if (points.count() < 3)
{
return false;
}
@ -2911,7 +2914,7 @@ void DialogSeamAllowance::InitNodesList()
if (index != -1)
{
uiTabPaths->comboBoxNodes->setCurrentIndex(index);
NodeChanged(index);// Need in case combox index was not changed
NodeChanged(index); // Need in case combox index was not changed
}
else
{
@ -2944,7 +2947,7 @@ void DialogSeamAllowance::InitPassmarksList()
if (index != -1)
{
uiTabPassmarks->comboBoxPassmarks->setCurrentIndex(index);
PassmarkChanged(index);// Need in case combox index was not changed
PassmarkChanged(index); // Need in case combox index was not changed
}
else
{
@ -2974,7 +2977,7 @@ auto DialogSeamAllowance::GetLastId() const -> quint32
const int count = uiTabPaths->listWidgetMainPath->count();
if (count > 0)
{
QListWidgetItem *item = uiTabPaths->listWidgetMainPath->item(count-1);
QListWidgetItem *item = uiTabPaths->listWidgetMainPath->item(count - 1);
const auto node = qvariant_cast<VPieceNode>(item->data(Qt::UserRole));
return node.GetId();
}
@ -3131,31 +3134,33 @@ void DialogSeamAllowance::InitMainPathTab()
connect(uiTabPaths->listWidgetMainPath, &QListWidget::itemSelectionChanged, this,
&DialogSeamAllowance::SetMoveControls);
connect(uiTabPaths->listWidgetMainPath->model(), &QAbstractItemModel::rowsMoved, this, [this]()
{
ValidObjects(MainPathIsValid());
});
connect(uiTabPaths->listWidgetMainPath->model(), &QAbstractItemModel::rowsMoved, this,
[this]() { ValidObjects(MainPathIsValid()); });
connect(uiTabPaths->toolButtonTop, &QToolButton::clicked, this, [this]()
{
MoveListRowTop(uiTabPaths->listWidgetMainPath);
ValidObjects(MainPathIsValid());
});
connect(uiTabPaths->toolButtonUp, &QToolButton::clicked, this, [this]()
{
MoveListRowUp(uiTabPaths->listWidgetMainPath);
ValidObjects(MainPathIsValid());
});
connect(uiTabPaths->toolButtonDown, &QToolButton::clicked, this, [this]()
{
MoveListRowDown(uiTabPaths->listWidgetMainPath);
ValidObjects(MainPathIsValid());
});
connect(uiTabPaths->toolButtonBottom, &QToolButton::clicked, this, [this]()
{
MoveListRowBottom(uiTabPaths->listWidgetMainPath);
ValidObjects(MainPathIsValid());
});
connect(uiTabPaths->toolButtonTop, &QToolButton::clicked, this,
[this]()
{
MoveListRowTop(uiTabPaths->listWidgetMainPath);
ValidObjects(MainPathIsValid());
});
connect(uiTabPaths->toolButtonUp, &QToolButton::clicked, this,
[this]()
{
MoveListRowUp(uiTabPaths->listWidgetMainPath);
ValidObjects(MainPathIsValid());
});
connect(uiTabPaths->toolButtonDown, &QToolButton::clicked, this,
[this]()
{
MoveListRowDown(uiTabPaths->listWidgetMainPath);
ValidObjects(MainPathIsValid());
});
connect(uiTabPaths->toolButtonBottom, &QToolButton::clicked, this,
[this]()
{
MoveListRowBottom(uiTabPaths->listWidgetMainPath);
ValidObjects(MainPathIsValid());
});
}
//---------------------------------------------------------------------------------------------------------------------
@ -3169,21 +3174,23 @@ void DialogSeamAllowance::InitPieceTab()
uiTabPaths->lineEditName->setClearButtonEnabled(true);
uiTabPaths->lineEditName->setText(GetDefaultPieceName());
connect(uiTabPaths->checkBoxForbidFlipping, &QCheckBox::stateChanged, this, [this](int state)
{
if (state == Qt::Checked)
{
uiTabPaths->checkBoxForceFlipping->setChecked(false);
}
});
connect(uiTabPaths->checkBoxForbidFlipping, &QCheckBox::stateChanged, this,
[this](int state)
{
if (state == Qt::Checked)
{
uiTabPaths->checkBoxForceFlipping->setChecked(false);
}
});
connect(uiTabPaths->checkBoxForceFlipping, &QCheckBox::stateChanged, this, [this](int state)
{
if (state == Qt::Checked)
{
uiTabPaths->checkBoxForbidFlipping->setChecked(false);
}
});
connect(uiTabPaths->checkBoxForceFlipping, &QCheckBox::stateChanged, this,
[this](int state)
{
if (state == Qt::Checked)
{
uiTabPaths->checkBoxForbidFlipping->setChecked(false);
}
});
VCommonSettings *settings = VAbstractApplication::VApp()->Settings();
uiTabPaths->checkBoxForbidFlipping->setChecked(settings->GetForbidWorkpieceFlipping());
@ -3219,31 +3226,33 @@ void DialogSeamAllowance::InitSeamAllowanceTab()
m_timerWidthAfter->setSingleShot(true);
connect(m_timerWidthAfter, &QTimer::timeout, this, &DialogSeamAllowance::EvalWidthAfter);
connect(uiTabPaths->checkBoxSeams, &QCheckBox::toggled, this, [this](bool enable)
{
uiTabPaths->checkBoxBuiltIn->setEnabled(enable);
connect(uiTabPaths->checkBoxSeams, &QCheckBox::toggled, this,
[this](bool enable)
{
uiTabPaths->checkBoxBuiltIn->setEnabled(enable);
if (not enable)
{
uiTabPaths->groupBoxAutomatic->setEnabled(enable);
uiTabPaths->groupBoxCustom->setEnabled(enable);
}
else
{
emit uiTabPaths->checkBoxBuiltIn->toggled(uiTabPaths->checkBoxBuiltIn->isChecked());
}
});
if (not enable)
{
uiTabPaths->groupBoxAutomatic->setEnabled(enable);
uiTabPaths->groupBoxCustom->setEnabled(enable);
}
else
{
emit uiTabPaths->checkBoxBuiltIn->toggled(uiTabPaths->checkBoxBuiltIn->isChecked());
}
});
connect(uiTabPaths->checkBoxBuiltIn, &QCheckBox::toggled, this, [this](bool enable)
{
uiTabPaths->groupBoxAutomatic->setEnabled(not enable);
uiTabPaths->groupBoxCustom->setEnabled(not enable);
connect(uiTabPaths->checkBoxBuiltIn, &QCheckBox::toggled, this,
[this](bool enable)
{
uiTabPaths->groupBoxAutomatic->setEnabled(not enable);
uiTabPaths->groupBoxCustom->setEnabled(not enable);
if (not enable)
{
InitNodesList();
}
});
if (not enable)
{
InitNodesList();
}
});
// init the default seam allowance, convert the value if app unit is different than pattern unit
m_saWidth = UnitConvertor(VAbstractApplication::VApp()->Settings()->GetDefaultSeamAllowance(),
@ -3268,36 +3277,30 @@ void DialogSeamAllowance::InitSeamAllowanceTab()
&DialogSeamAllowance::ShowCustomSAContextMenu);
connect(uiTabPaths->listWidgetCustomSA, &QListWidget::currentRowChanged, this,
&DialogSeamAllowance::CustomSAChanged);
connect(uiTabPaths->comboBoxStartPoint, QOverload<int>::of(&QComboBox::currentIndexChanged),
this, &DialogSeamAllowance::CSAStartPointChanged);
connect(uiTabPaths->comboBoxStartPoint, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
&DialogSeamAllowance::CSAStartPointChanged);
connect(uiTabPaths->comboBoxEndPoint, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
&DialogSeamAllowance::CSAEndPointChanged);
connect(uiTabPaths->comboBoxIncludeType, QOverload<int>::of(&QComboBox::currentIndexChanged),
this, &DialogSeamAllowance::CSAIncludeTypeChanged);
connect(uiTabPaths->comboBoxIncludeType, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
&DialogSeamAllowance::CSAIncludeTypeChanged);
connect(uiTabPaths->toolButtonExprWidth, &QPushButton::clicked, this, &DialogSeamAllowance::FXWidth);
connect(uiTabPaths->toolButtonExprBefore, &QPushButton::clicked, this, &DialogSeamAllowance::FXWidthBefore);
connect(uiTabPaths->toolButtonExprAfter, &QPushButton::clicked, this, &DialogSeamAllowance::FXWidthAfter);
connect(uiTabPaths->plainTextEditFormulaWidth, &QPlainTextEdit::textChanged, this, [this]()
{
m_timerWidth->start(formulaTimerTimeout);
});
connect(uiTabPaths->plainTextEditFormulaWidth, &QPlainTextEdit::textChanged, this,
[this]() { m_timerWidth->start(formulaTimerTimeout); });
connect(uiTabPaths->plainTextEditFormulaWidthBefore, &QPlainTextEdit::textChanged, this, [this]()
{
m_timerWidthBefore->start(formulaTimerTimeout);
});
connect(uiTabPaths->plainTextEditFormulaWidthBefore, &QPlainTextEdit::textChanged, this,
[this]() { m_timerWidthBefore->start(formulaTimerTimeout); });
connect(uiTabPaths->plainTextEditFormulaWidthAfter, &QPlainTextEdit::textChanged, this, [this]()
{
m_timerWidthAfter->start(formulaTimerTimeout);
});
connect(uiTabPaths->plainTextEditFormulaWidthAfter, &QPlainTextEdit::textChanged, this,
[this]() { m_timerWidthAfter->start(formulaTimerTimeout); });
connect(uiTabPaths->pushButtonGrowWidth, &QPushButton::clicked, this,
&DialogSeamAllowance::DeployWidthFormulaTextEdit);
connect(uiTabPaths->pushButtonGrowWidthBefore, &QPushButton::clicked,
this, &DialogSeamAllowance::DeployWidthBeforeFormulaTextEdit);
connect(uiTabPaths->pushButtonGrowWidthBefore, &QPushButton::clicked, this,
&DialogSeamAllowance::DeployWidthBeforeFormulaTextEdit);
connect(uiTabPaths->pushButtonGrowWidthAfter, &QPushButton::clicked, this,
&DialogSeamAllowance::DeployWidthAfterFormulaTextEdit);
}
@ -3398,10 +3401,10 @@ void DialogSeamAllowance::InitLabelsTab()
InitPinPoint(uiTabLabels->comboBoxDLTopLeftPin);
InitPinPoint(uiTabLabels->comboBoxDLBottomRightPin);
connect(uiTabLabels->comboBoxDLTopLeftPin, &QComboBox::currentTextChanged,
this, &DialogSeamAllowance::DetailPinPointChanged);
connect(uiTabLabels->comboBoxDLBottomRightPin, &QComboBox::currentTextChanged,
this, &DialogSeamAllowance::DetailPinPointChanged);
connect(uiTabLabels->comboBoxDLTopLeftPin, &QComboBox::currentTextChanged, this,
&DialogSeamAllowance::DetailPinPointChanged);
connect(uiTabLabels->comboBoxDLBottomRightPin, &QComboBox::currentTextChanged, this,
&DialogSeamAllowance::DetailPinPointChanged);
connect(uiTabLabels->pushButtonDLWidth, &QPushButton::clicked, this, &DialogSeamAllowance::EditDLFormula);
connect(uiTabLabels->pushButtonDLHeight, &QPushButton::clicked, this, &DialogSeamAllowance::EditDLFormula);
@ -3429,10 +3432,10 @@ void DialogSeamAllowance::InitLabelsTab()
InitPinPoint(uiTabLabels->comboBoxPLTopLeftPin);
InitPinPoint(uiTabLabels->comboBoxPLBottomRightPin);
connect(uiTabLabels->comboBoxPLTopLeftPin, &QComboBox::currentTextChanged,
this, &DialogSeamAllowance::PatternPinPointChanged);
connect(uiTabLabels->comboBoxPLBottomRightPin, &QComboBox::currentTextChanged,
this, &DialogSeamAllowance::PatternPinPointChanged);
connect(uiTabLabels->comboBoxPLTopLeftPin, &QComboBox::currentTextChanged, this,
&DialogSeamAllowance::PatternPinPointChanged);
connect(uiTabLabels->comboBoxPLBottomRightPin, &QComboBox::currentTextChanged, this,
&DialogSeamAllowance::PatternPinPointChanged);
connect(uiTabLabels->pushButtonPLWidth, &QPushButton::clicked, this, &DialogSeamAllowance::EditPLFormula);
connect(uiTabLabels->pushButtonPLHeight, &QPushButton::clicked, this, &DialogSeamAllowance::EditPLFormula);
@ -3488,10 +3491,10 @@ void DialogSeamAllowance::InitLabelsTab()
connect(uiTabLabels->pushButtonPatternMaterials, &QPushButton::clicked, this,
&DialogSeamAllowance::ManagePatternMaterials);
connect(uiTabLabels->comboBoxDateFormat, QOverload<int>::of(&QComboBox::currentIndexChanged),
this, &DialogSeamAllowance::PatternLabelDataChanged);
connect(uiTabLabels->comboBoxTimeFormat, QOverload<int>::of(&QComboBox::currentIndexChanged),
this, &DialogSeamAllowance::PatternLabelDataChanged);
connect(uiTabLabels->comboBoxDateFormat, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
&DialogSeamAllowance::PatternLabelDataChanged);
connect(uiTabLabels->comboBoxTimeFormat, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
&DialogSeamAllowance::PatternLabelDataChanged);
}
//---------------------------------------------------------------------------------------------------------------------
@ -3547,10 +3550,10 @@ void DialogSeamAllowance::InitGrainlineTab()
InitPinPoint(uiTabGrainline->comboBoxGrainlineTopPin);
InitPinPoint(uiTabGrainline->comboBoxGrainlineBottomPin);
connect(uiTabGrainline->comboBoxGrainlineTopPin, &QComboBox::currentTextChanged,
this, &DialogSeamAllowance::GrainlinePinPointChanged);
connect(uiTabGrainline->comboBoxGrainlineBottomPin, &QComboBox::currentTextChanged,
this, &DialogSeamAllowance::GrainlinePinPointChanged);
connect(uiTabGrainline->comboBoxGrainlineTopPin, &QComboBox::currentTextChanged, this,
&DialogSeamAllowance::GrainlinePinPointChanged);
connect(uiTabGrainline->comboBoxGrainlineBottomPin, &QComboBox::currentTextChanged, this,
&DialogSeamAllowance::GrainlinePinPointChanged);
}
//---------------------------------------------------------------------------------------------------------------------
@ -3608,19 +3611,19 @@ void DialogSeamAllowance::InitPassmarksTab()
// notch list
InitPassmarksList();
connect(uiTabPassmarks->comboBoxPassmarks, QOverload<int>::of(&QComboBox::currentIndexChanged),
this, &DialogSeamAllowance::PassmarkChanged);
connect(uiTabPassmarks->comboBoxPassmarks, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
&DialogSeamAllowance::PassmarkChanged);
#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
connect(uiTabPassmarks->buttonGroupLineType, QOverload<int>::of(&QButtonGroup::buttonClicked),
this, &DialogSeamAllowance::PassmarkLineTypeChanged);
connect(uiTabPassmarks->buttonGroupAngleType, QOverload<int>::of(&QButtonGroup::buttonClicked),
this, &DialogSeamAllowance::PassmarkAngleTypeChanged);
connect(uiTabPassmarks->buttonGroupLineType, QOverload<int>::of(&QButtonGroup::buttonClicked), this,
&DialogSeamAllowance::PassmarkLineTypeChanged);
connect(uiTabPassmarks->buttonGroupAngleType, QOverload<int>::of(&QButtonGroup::buttonClicked), this,
&DialogSeamAllowance::PassmarkAngleTypeChanged);
#else
connect(uiTabPassmarks->buttonGroupLineType, &QButtonGroup::idClicked,
this, &DialogSeamAllowance::PassmarkLineTypeChanged);
connect(uiTabPassmarks->buttonGroupAngleType, &QButtonGroup::idClicked,
this, &DialogSeamAllowance::PassmarkAngleTypeChanged);
connect(uiTabPassmarks->buttonGroupLineType, &QButtonGroup::idClicked, this,
&DialogSeamAllowance::PassmarkLineTypeChanged);
connect(uiTabPassmarks->buttonGroupAngleType, &QButtonGroup::idClicked, this,
&DialogSeamAllowance::PassmarkAngleTypeChanged);
#endif
connect(uiTabPassmarks->checkBoxShowSecondPassmark, &QCheckBox::stateChanged, this,
&DialogSeamAllowance::PassmarkShowSecondChanged);
@ -3632,15 +3635,16 @@ void DialogSeamAllowance::InitPassmarksTab()
void DialogSeamAllowance::InitPlaceLabelsTab()
{
uiTabPlaceLabels->listWidgetPlaceLabels->setContextMenuPolicy(Qt::CustomContextMenu);
connect(uiTabPlaceLabels->listWidgetPlaceLabels, &QListWidget::currentRowChanged, this, [this]()
{
if (not m_visSpecialPoints.isNull())
{
m_visSpecialPoints->SetShowRect(true);
m_visSpecialPoints->SetRect(CurrentRect());
m_visSpecialPoints->RefreshGeometry();
}
});
connect(uiTabPlaceLabels->listWidgetPlaceLabels, &QListWidget::currentRowChanged, this,
[this]()
{
if (not m_visSpecialPoints.isNull())
{
m_visSpecialPoints->SetShowRect(true);
m_visSpecialPoints->SetRect(CurrentRect());
m_visSpecialPoints->RefreshGeometry();
}
});
connect(uiTabPlaceLabels->listWidgetPlaceLabels, &QListWidget::customContextMenuRequested, this,
&DialogSeamAllowance::ShowPlaceLabelsContextMenu);
}
@ -3677,8 +3681,8 @@ auto DialogSeamAllowance::UndoStack() -> QVector<QPointer<VUndoCommand>> &
//---------------------------------------------------------------------------------------------------------------------
void DialogSeamAllowance::SetFormulaSAWidth(const QString &formula)
{
const QString width = VAbstractApplication::VApp()->TrVars()
->FormulaToUser(formula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
const QString width = VAbstractApplication::VApp()->TrVars()->FormulaToUser(
formula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
// increase height if needed.
if (width.length() > 80)
{
@ -3700,8 +3704,8 @@ void DialogSeamAllowance::SetFormulaSAWidth(const QString &formula)
//---------------------------------------------------------------------------------------------------------------------
void DialogSeamAllowance::SetFormulaPassmarkLength(const QString &formula)
{
const QString width = VAbstractApplication::VApp()->TrVars()
->FormulaToUser(formula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
const QString width = VAbstractApplication::VApp()->TrVars()->FormulaToUser(
formula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
// increase height if needed.
if (width.length() > 80)
{
@ -3795,8 +3799,8 @@ void DialogSeamAllowance::SetGrainlineAngle(QString angleFormula)
angleFormula = '0';
}
const QString formula = VAbstractApplication::VApp()->TrVars()
->FormulaToUser(angleFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
const QString formula = VAbstractApplication::VApp()->TrVars()->FormulaToUser(
angleFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
// increase height if needed.
if (formula.length() > 80)
{
@ -3815,8 +3819,8 @@ void DialogSeamAllowance::SetGrainlineLength(QString lengthFormula)
lengthFormula = QString().setNum(UnitConvertor(10, Unit::Cm, *data->GetPatternUnit()));
}
const QString formula = VAbstractApplication::VApp()->TrVars()
->FormulaToUser(lengthFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
const QString formula = VAbstractApplication::VApp()->TrVars()->FormulaToUser(
lengthFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
// increase height if needed.
if (formula.length() > 80)
{
@ -3836,8 +3840,8 @@ void DialogSeamAllowance::SetDLWidth(QString widthFormula)
widthFormula = QString().setNum(UnitConvertor(10, Unit::Cm, *data->GetPatternUnit()));
}
const QString formula = VAbstractApplication::VApp()->TrVars()
->FormulaToUser(widthFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
const QString formula = VAbstractApplication::VApp()->TrVars()->FormulaToUser(
widthFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
// increase height if needed.
if (formula.length() > 80)
{
@ -3857,8 +3861,8 @@ void DialogSeamAllowance::SetDLHeight(QString heightFormula)
heightFormula = QString().setNum(UnitConvertor(10, Unit::Cm, *data->GetPatternUnit()));
}
const QString formula = VAbstractApplication::VApp()->TrVars()
->FormulaToUser(heightFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
const QString formula = VAbstractApplication::VApp()->TrVars()->FormulaToUser(
heightFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
// increase height if needed.
if (formula.length() > 80)
{
@ -3878,8 +3882,8 @@ void DialogSeamAllowance::SetDLAngle(QString angleFormula)
angleFormula = '0';
}
const QString formula = VAbstractApplication::VApp()->TrVars()
->FormulaToUser(angleFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
const QString formula = VAbstractApplication::VApp()->TrVars()->FormulaToUser(
angleFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
// increase height if needed.
if (formula.length() > 80)
{
@ -3899,8 +3903,8 @@ void DialogSeamAllowance::SetPLWidth(QString widthFormula)
widthFormula = QString().setNum(UnitConvertor(10, Unit::Cm, *data->GetPatternUnit()));
}
const QString formula = VAbstractApplication::VApp()->TrVars()
->FormulaToUser(widthFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
const QString formula = VAbstractApplication::VApp()->TrVars()->FormulaToUser(
widthFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
// increase height if needed.
if (formula.length() > 80)
{
@ -3920,8 +3924,8 @@ void DialogSeamAllowance::SetPLHeight(QString heightFormula)
heightFormula = QString().setNum(UnitConvertor(10, Unit::Cm, *data->GetPatternUnit()));
}
const QString formula = VAbstractApplication::VApp()->TrVars()
->FormulaToUser(heightFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
const QString formula = VAbstractApplication::VApp()->TrVars()->FormulaToUser(
heightFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
// increase height if needed.
if (formula.length() > 80)
{
@ -3941,8 +3945,8 @@ void DialogSeamAllowance::SetPLAngle(QString angleFormula)
angleFormula = '0';
}
const QString formula = VAbstractApplication::VApp()->TrVars()
->FormulaToUser(angleFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
const QString formula = VAbstractApplication::VApp()->TrVars()->FormulaToUser(
angleFormula, VAbstractApplication::VApp()->Settings()->GetOsSeparator());
// increase height if needed.
if (formula.length() > 80)
{
@ -3961,8 +3965,8 @@ auto DialogSeamAllowance::CurrentRect() const -> QRectF
if (QListWidgetItem *item = uiTabPlaceLabels->listWidgetPlaceLabels->currentItem())
{
VPlaceLabelItem label = CurrentPlaceLabel(qvariant_cast<quint32>(item->data(Qt::UserRole)));
rect = QRectF(QPointF(label.x() - label.GetWidth()/2.0, label.y() - label.GetHeight()/2.0),
QPointF(label.x() + label.GetWidth()/2.0, label.y() + label.GetHeight()/2.0));
rect = QRectF(QPointF(label.x() - label.GetWidth() / 2.0, label.y() - label.GetHeight() / 2.0),
QPointF(label.x() + label.GetWidth() / 2.0, label.y() + label.GetHeight() / 2.0));
}
return rect;
}
@ -4021,7 +4025,7 @@ auto DialogSeamAllowance::GetDefaultPieceName() const -> QString
QString name = defName;
int i = 0;
while(names.contains(name))
while (names.contains(name))
{
name = defName + QStringLiteral("_%1").arg(++i);
}
@ -4149,39 +4153,39 @@ void DialogSeamAllowance::InitGradationPlaceholders()
{
QString label = VAbstractValApplication::VApp()->GetDimensionHeightLabel();
m_gradationPlaceholders.insert(pl_heightLabel, qMakePair(tr("Height label", "dimension"),
not label.isEmpty() ? label : heightValue));
m_gradationPlaceholders.insert(
pl_heightLabel, qMakePair(tr("Height label", "dimension"), not label.isEmpty() ? label : heightValue));
m_gradationPlaceholders.insert(pl_dimensionXLabel, qMakePair(tr("Dimension X label", "dimension"),
not label.isEmpty() ? label : heightValue));
label = VAbstractValApplication::VApp()->GetDimensionSizeLabel();
m_gradationPlaceholders.insert(pl_sizeLabel, qMakePair(tr("Size label", "dimension"),
not label.isEmpty() ? label : sizeValue));
m_gradationPlaceholders.insert(
pl_sizeLabel, qMakePair(tr("Size label", "dimension"), not label.isEmpty() ? label : sizeValue));
m_gradationPlaceholders.insert(pl_dimensionYLabel, qMakePair(tr("Dimension Y label", "dimension"),
not label.isEmpty() ? label : sizeValue));
label = VAbstractValApplication::VApp()->GetDimensionHipLabel();
m_gradationPlaceholders.insert(pl_hipLabel, qMakePair(tr("Hip label", "dimension"),
not label.isEmpty() ? label : hipValue));
m_gradationPlaceholders.insert(pl_hipLabel,
qMakePair(tr("Hip label", "dimension"), not label.isEmpty() ? label : hipValue));
m_gradationPlaceholders.insert(pl_dimensionZLabel, qMakePair(tr("Dimension Z label", "dimension"),
not label.isEmpty() ? label : hipValue));
label = VAbstractValApplication::VApp()->GetDimensionWaistLabel();
m_gradationPlaceholders.insert(pl_waistLabel, qMakePair(tr("Waist label", "dimension"),
not label.isEmpty() ? label : waistValue));
m_gradationPlaceholders.insert(
pl_waistLabel, qMakePair(tr("Waist label", "dimension"), not label.isEmpty() ? label : waistValue));
m_gradationPlaceholders.insert(pl_dimensionWLabel, qMakePair(tr("Dimension W label", "dimension"),
not label.isEmpty() ? label : waistValue));
}
{
const QMap<QString, QSharedPointer<VMeasurement> > measurements = data->DataMeasurements();
const QMap<QString, QSharedPointer<VMeasurement>> measurements = data->DataMeasurements();
auto i = measurements.constBegin();
while (i != measurements.constEnd())
{
QString description = i.value()->GetGuiText().isEmpty() ? i.key() : i.value()->GetGuiText();
m_gradationPlaceholders.insert(pl_measurement + i.key(),
qMakePair(tr("Measurement: %1").arg(description),
QString::number(*i.value()->GetValue())));
m_gradationPlaceholders.insert(
pl_measurement + i.key(),
qMakePair(tr("Measurement: %1").arg(description), QString::number(*i.value()->GetValue())));
++i;
}
}
@ -4421,7 +4425,7 @@ void DialogSeamAllowance::SetMoveControls()
uiTabPaths->toolButtonDown->setEnabled(true);
uiTabPaths->toolButtonBottom->setEnabled(true);
}
else if (uiTabPaths->listWidgetMainPath->currentRow() == uiTabPaths->listWidgetMainPath->count()-1)
else if (uiTabPaths->listWidgetMainPath->currentRow() == uiTabPaths->listWidgetMainPath->count() - 1)
{
uiTabPaths->toolButtonTop->setEnabled(true);
uiTabPaths->toolButtonUp->setEnabled(true);
@ -4448,9 +4452,10 @@ void DialogSeamAllowance::EditPatternLabel()
{
if (m_patternLabelDataChanged && m_askSavePatternLabelData)
{
QMessageBox::StandardButton answer = QMessageBox::question(this, tr("Save label data."),
tr("Label data were changed. Do you want to save them before editing label template?"),
QMessageBox::Yes|QMessageBox::No, QMessageBox::Yes);
QMessageBox::StandardButton answer = QMessageBox::question(
this, tr("Save label data."),
tr("Label data were changed. Do you want to save them before editing label template?"),
QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
if (answer == QMessageBox::Yes)
{

29
src/libs/vtools/dialogs/tools/piece/dialogseamallowance.h
View File

@ -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};

97
src/libs/vtools/tools/vtoolseamallowance.h
View File

@ -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;
@ -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>;
};

2
src/libs/vwidgets/vgraphicssimpletextitem.cpp
View File

@ -85,7 +85,7 @@ 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();
}

390
src/libs/vwidgets/vtextgraphicsitem.cpp
View File

@ -27,6 +27,7 @@
*************************************************************************/
#include <QColor>
#include <QDebug>
#include <QFlags>
#include <QFont>
#include <QGraphicsItem>
@ -37,24 +38,22 @@
#include <QPoint>
#include <QStyleOptionGraphicsItem>
#include <Qt>
#include <QDebug>
#include "../vmisc/def.h"
#include "../vmisc/vmath.h"
#include "../vmisc/literals.h"
#include "../vmisc/compatibility.h"
#include "../vmisc/def.h"
#include "../vmisc/literals.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 +63,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 +72,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 +109,15 @@ 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(QGraphicsItem *pParent)
: VPieceItem(pParent)
{
m_inactiveZ = 2;
SetSize(minW, minH);
@ -137,7 +129,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);
}
@ -163,7 +155,7 @@ void VTextGraphicsItem::paint(QPainter *painter, const QStyleOptionGraphicsItem
int iY = 0;
for (int i = 0; i < m_tm.GetSourceLinesCount(); ++i)
{
const TextLine& tl = m_tm.GetSourceLine(i);
const TextLine &tl = m_tm.GetSourceLine(i);
fnt.setPixelSize(m_tm.GetFont().pixelSize() + tl.m_iFontSize);
fnt.setBold(tl.m_bold);
@ -205,8 +197,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 +206,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 +273,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 +314,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);
}
@ -357,8 +346,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 +367,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 +388,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 +401,7 @@ void VTextGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *pME)
{
UserMoveAndResize(pME->pos());
}
setZValue(ACTIVE_Z);
setZValue(activeZ);
Update();
}
else if (m_moveType & IsMovable)
@ -431,7 +420,7 @@ void VTextGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *pME)
SetItemOverrideCursor(this, cursorArrowCloseHand, 1, 1);
}
setZValue(ACTIVE_Z);
setZValue(activeZ);
Update();
}
else
@ -450,102 +439,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 +460,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(), m_tm.GetFont().pixelSize());
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 +521,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,7 +568,7 @@ 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);
@ -693,7 +603,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 +614,113 @@ 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();
}
}

52
src/libs/vwidgets/vtextgraphicsitem.h
View File

@ -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,30 +51,34 @@
class VTextGraphicsItem final : public VPieceItem
{
Q_OBJECT // NOLINT
public:
explicit VTextGraphicsItem(QGraphicsItem* pParent = nullptr);
virtual ~VTextGraphicsItem() = default;
explicit VTextGraphicsItem(QGraphicsItem *pParent = nullptr);
~VTextGraphicsItem() override = default;
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;
virtual void Update() override;
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;
void Update() override;
virtual auto type() const -> int override { return Type; }
enum { Type = UserType + static_cast<int>(Vis::TextGraphicsItem)};
auto type() const -> int override { return Type; }
enum
{
Type = UserType + static_cast<int>(Vis::TextGraphicsItem)
};
void SetFont(const QFont& fnt);
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;
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();
@ -86,17 +90,21 @@ signals:
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{};
void AllUserModifications(const QPointF &pos);
void UserRotateAndMove();
void UserMoveAndResize(const QPointF &pos);
void MoveLabel(QGraphicsSceneMouseEvent *pME);
void ResizeLabel(QGraphicsSceneMouseEvent *pME);
void RotateLabel(QGraphicsSceneMouseEvent *pME);
};
#endif // VTEXTGRAPHICSITEM_H