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

Fix typo.

Browse Source
This commit is contained in:
Roman Telezhynskyi 2022-11-14 18:02:00 +02:00
parent d95d755e0d
commit 2f683930e9
18 changed files with 87 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/app/puzzle/layout/vppiece.cpp
View File

@ -149,7 +149,7 @@ void VPPiece::Update(const VPPiecePtr &piece)
} }
SetName(piece->GetName()); SetName(piece->GetName());
SetCountourPoints(piece->GetContourPoints(), piece->IsHideMainPath()); SetContourPoints(piece->GetContourPoints(), piece->IsHideMainPath());
SetSeamAllowancePoints(piece->GetSeamAllowancePoints(), piece->IsSeamAllowance(), piece->IsSeamAllowanceBuiltIn()); SetSeamAllowancePoints(piece->GetSeamAllowancePoints(), piece->IsSeamAllowance(), piece->IsSeamAllowanceBuiltIn());
SetInternalPaths(piece->GetInternalPaths()); SetInternalPaths(piece->GetInternalPaths());
SetPassmarks(piece->GetPassmarks()); SetPassmarks(piece->GetPassmarks());

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

@ -556,7 +556,7 @@ auto VPLayoutFileReader::ReadLayoutPoints() -> QVector<VLayoutPoint>
void VPLayoutFileReader::ReadSeamLine(const VPPiecePtr &piece) void VPLayoutFileReader::ReadSeamLine(const VPPiecePtr &piece)
{ {
AssertRootTag(ML::TagSeamLine); AssertRootTag(ML::TagSeamLine);
piece->SetCountourPoints(ReadLayoutPoints()); piece->SetContourPoints(ReadLayoutPoints());
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------

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

@ -4057,8 +4057,8 @@ void VPattern::ParsePathElement(VMainGraphicsScene *scene, QDomElement &domEleme
if (initData.path.GetType() == PiecePathType::InternalPath) if (initData.path.GetType() == PiecePathType::InternalPath)
{ {
initData.path.SetCutPath(GetParametrBool(domElement, AttrCut, falseStr)); initData.path.SetCutPath(GetParametrBool(domElement, AttrCut, falseStr));
initData.path.SetFirstToCuttingCountour(GetParametrBool(domElement, AttrFirstToCountour, falseStr)); initData.path.SetFirstToCuttingContour(GetParametrBool(domElement, AttrFirstToContour, falseStr));
initData.path.SetLastToCuttingCountour(GetParametrBool(domElement, AttrLastToCountour, falseStr)); initData.path.SetLastToCuttingContour(GetParametrBool(domElement, AttrLastToContour, falseStr));
initData.path.SetVisibilityTrigger(GetParametrString(domElement, AttrVisible, QChar('1'))); initData.path.SetVisibilityTrigger(GetParametrString(domElement, AttrVisible, QChar('1')));
} }

4
src/libs/ifc/ifcdef.cpp
View File

@ -137,8 +137,8 @@ const QString AttrWidth = QStringLiteral("width");
const QString AttrHeight = QStringLiteral("height"); const QString AttrHeight = QStringLiteral("height");
const QString AttrPlaceLabelType = QStringLiteral("placeLabelType"); const QString AttrPlaceLabelType = QStringLiteral("placeLabelType");
const QString AttrVersion = QStringLiteral("version"); const QString AttrVersion = QStringLiteral("version");
const QString AttrFirstToCountour = QStringLiteral("firstToCountour"); const QString AttrFirstToContour = QStringLiteral("firstToContour");
const QString AttrLastToCountour = QStringLiteral("lastToCountour"); const QString AttrLastToContour = QStringLiteral("lastToContour");
const QString AttrNotes = QStringLiteral("notes"); const QString AttrNotes = QStringLiteral("notes");
const QString AttrAlias = QStringLiteral("alias"); const QString AttrAlias = QStringLiteral("alias");
const QString AttrAlias1 = QStringLiteral("alias1"); const QString AttrAlias1 = QStringLiteral("alias1");

4
src/libs/ifc/ifcdef.h
View File

@ -156,8 +156,8 @@ extern const QString AttrWidth;
extern const QString AttrHeight; extern const QString AttrHeight;
extern const QString AttrPlaceLabelType; extern const QString AttrPlaceLabelType;
extern const QString AttrVersion; extern const QString AttrVersion;
extern const QString AttrFirstToCountour; extern const QString AttrFirstToContour;
extern const QString AttrLastToCountour; extern const QString AttrLastToContour;
extern const QString AttrNotes; extern const QString AttrNotes;
extern const QString AttrAlias; extern const QString AttrAlias;
extern const QString AttrAlias1; extern const QString AttrAlias1;

4
src/libs/ifc/schema/pattern/v0.9.2.xsd
View File

@ -441,8 +441,8 @@
<xs:attribute name="typeLine" type="curvePenStyle"/> <xs:attribute name="typeLine" type="curvePenStyle"/>
<xs:attribute name="cut" type="xs:boolean"/> <xs:attribute name="cut" type="xs:boolean"/>
<xs:attribute name="visible" type="xs:string"/> <xs:attribute name="visible" type="xs:string"/>
<xs:attribute name="firstToCountour" type="xs:boolean"/> <xs:attribute name="firstToContour" type="xs:boolean"/>
<xs:attribute name="lastToCountour" type="xs:boolean"/> <xs:attribute name="lastToContour" type="xs:boolean"/>
<xs:attribute name="cuttingNumber" type="xs:unsignedInt"/> <xs:attribute name="cuttingNumber" type="xs:unsignedInt"/>
<xs:attribute name="cuttingVelocityReduction" type="velocityReduction"/> <xs:attribute name="cuttingVelocityReduction" type="velocityReduction"/>
</xs:complexType> </xs:complexType>

36
src/libs/ifc/xml/vpatternconverter.cpp
View File

@ -169,6 +169,10 @@ Q_GLOBAL_STATIC_WITH_ARGS(const QString, strCutNumber, (QLatin1String("cutNumber
Q_GLOBAL_STATIC_WITH_ARGS(const QString, strQuantity, (QLatin1String("quantity"))) // NOLINT Q_GLOBAL_STATIC_WITH_ARGS(const QString, strQuantity, (QLatin1String("quantity"))) // NOLINT
Q_GLOBAL_STATIC_WITH_ARGS(const QString, strExtension, (QLatin1String("extension"))) // NOLINT Q_GLOBAL_STATIC_WITH_ARGS(const QString, strExtension, (QLatin1String("extension"))) // NOLINT
Q_GLOBAL_STATIC_WITH_ARGS(const QString, strContentType, (QLatin1String("contentType"))) // NOLINT Q_GLOBAL_STATIC_WITH_ARGS(const QString, strContentType, (QLatin1String("contentType"))) // NOLINT
Q_GLOBAL_STATIC_WITH_ARGS(const QString, strFirstToCountour, (QLatin1String("firstToCountour"))) // NOLINT
Q_GLOBAL_STATIC_WITH_ARGS(const QString, strFirstToContour, (QLatin1String("firstToContour"))) // NOLINT
Q_GLOBAL_STATIC_WITH_ARGS(const QString, strLastToCountour, (QLatin1String("lastToCountour"))) // NOLINT
Q_GLOBAL_STATIC_WITH_ARGS(const QString, strLastToContour, (QLatin1String("lastToContour"))) // NOLINT
} // anonymous namespace } // anonymous namespace
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -574,6 +578,7 @@ void VPatternConverter::ToV0_9_2()
Q_STATIC_ASSERT_X(VPatternConverter::PatternMinVer < FormatVersion(0, 9, 2), Q_STATIC_ASSERT_X(VPatternConverter::PatternMinVer < FormatVersion(0, 9, 2),
"Time to refactor the code."); "Time to refactor the code.");
ConvertPathAttributesToV0_9_2();
SetVersion(QStringLiteral("0.9.2")); SetVersion(QStringLiteral("0.9.2"));
Save(); Save();
} }
@ -2218,6 +2223,37 @@ void VPatternConverter::ConvertMeasurementsPathToV0_9_1()
} }
} }
//---------------------------------------------------------------------------------------------------------------------
void VPatternConverter::ConvertPathAttributesToV0_9_2()
{
// TODO. Delete if minimal supported version is 0.9.2
Q_STATIC_ASSERT_X(VPatternConverter::PatternMinVer < FormatVersion(0, 9, 2),
"Time to refactor the code.");
const QDomNodeList paths = this->elementsByTagName(*strPath);
for (int i=0; i < paths.size(); ++i)
{
QDomElement domElement = paths.at(i).toElement();
if (domElement.isNull())
{
continue;
}
if (domElement.hasAttribute(*strFirstToCountour))
{
domElement.setAttribute(*strFirstToContour, domElement.attribute(*strFirstToCountour));
domElement.removeAttribute(*strFirstToCountour);
}
if (domElement.hasAttribute(*strLastToCountour))
{
domElement.setAttribute(*strLastToContour, domElement.attribute(*strLastToCountour));
domElement.removeAttribute(*strLastToCountour);
}
}
}
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void VPatternConverter::TagUnionDetailsToV0_4_0() void VPatternConverter::TagUnionDetailsToV0_4_0()
{ {

2
src/libs/ifc/xml/vpatternconverter.h
View File

@ -146,6 +146,8 @@ private:
void ConvertImageToV0_9_0(); void ConvertImageToV0_9_0();
void ConvertMeasurementsPathToV0_9_1(); void ConvertMeasurementsPathToV0_9_1();
void ConvertPathAttributesToV0_9_2();
}; };
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------

2
src/libs/vlayout/vcontour.cpp
View File

@ -295,7 +295,7 @@ QLineF VContour::GlobalEdge(int i) const
edge = QLineF(d->globalContour.at(i-1), d->globalContour.at(i)); edge = QLineF(d->globalContour.at(i-1), d->globalContour.at(i));
} }
else else
{ // Closed countour { // Closed contour
edge = QLineF(d->globalContour.at(GlobalEdgesCount()-1), d->globalContour.at(0)); edge = QLineF(d->globalContour.at(GlobalEdgesCount()-1), d->globalContour.at(0));
} }
} }

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

@ -654,7 +654,7 @@ auto VLayoutPiece::Create(const VPiece &piece, vidtype id, const VContainer *pat
qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg; qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
} }
det.SetCountourPoints(futureMainPath.result(), det.SetContourPoints(futureMainPath.result(),
VAbstractApplication::VApp()->Settings()->IsPieceShowMainPath() ? false VAbstractApplication::VApp()->Settings()->IsPieceShowMainPath() ? false
: piece.IsHideMainPath()); : piece.IsHideMainPath());
det.SetSeamAllowancePoints(futureSeamAllowance.result(), piece.IsSeamAllowance(), piece.IsSeamAllowanceBuiltIn()); det.SetSeamAllowancePoints(futureSeamAllowance.result(), piece.IsSeamAllowance(), piece.IsSeamAllowanceBuiltIn());
@ -764,7 +764,7 @@ auto VLayoutPiece::GetContourPoints() const -> QVector<VLayoutPoint>
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void VLayoutPiece::SetCountourPoints(const QVector<VLayoutPoint> &points, bool hideMainPath) void VLayoutPiece::SetContourPoints(const QVector<VLayoutPoint> &points, bool hideMainPath)
{ {
d->m_contour = RemoveDublicates(points, false); d->m_contour = RemoveDublicates(points, false);
SetHideMainPath(hideMainPath); SetHideMainPath(hideMainPath);

2
src/libs/vlayout/vlayoutpiece.h
View File

@ -82,7 +82,7 @@ public:
auto GetMappedContourPoints() const -> QVector<VLayoutPoint>; auto GetMappedContourPoints() const -> QVector<VLayoutPoint>;
auto GetContourPoints() const -> QVector<VLayoutPoint>; auto GetContourPoints() const -> QVector<VLayoutPoint>;
void SetCountourPoints(const QVector<VLayoutPoint> &points, bool hideMainPath = false); void SetContourPoints(const QVector<VLayoutPoint> &points, bool hideMainPath = false);
auto GetMappedSeamAllowancePoints() const -> QVector<VLayoutPoint>; auto GetMappedSeamAllowancePoints() const -> QVector<VLayoutPoint>;
auto GetSeamAllowancePoints() const -> QVector<VLayoutPoint>; auto GetSeamAllowancePoints() const -> QVector<VLayoutPoint>;

4
src/libs/vpatterndb/vpiece.cpp
View File

@ -1243,7 +1243,7 @@ void VPiece::TestInternalPathCuttingPathIntersection(const VContainer *data) con
if (internalPath.intersects(contourPath)) if (internalPath.intersects(contourPath))
{ {
const QString errorMsg = QObject::tr("Piece '%1'. Internal path '%2' intersects with cutting " const QString errorMsg = QObject::tr("Piece '%1'. Internal path '%2' intersects with cutting "
"countour.").arg(GetName(), path.GetName()); "contour.").arg(GetName(), path.GetName());
VAbstractApplication::VApp()->IsPedantic() ? throw VExceptionObjectError(errorMsg) : VAbstractApplication::VApp()->IsPedantic() ? throw VExceptionObjectError(errorMsg) :
qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg; qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
continue; continue;
@ -1252,7 +1252,7 @@ void VPiece::TestInternalPathCuttingPathIntersection(const VContainer *data) con
if (not contourPath.contains(internalPath)) if (not contourPath.contains(internalPath))
{ {
const QString errorMsg = QObject::tr("Piece '%1'. Internal path '%2' not inside of cutting " const QString errorMsg = QObject::tr("Piece '%1'. Internal path '%2' not inside of cutting "
"countour.").arg(GetName(), path.GetName()); "contour.").arg(GetName(), path.GetName());
VAbstractApplication::VApp()->IsPedantic() ? throw VExceptionObjectError(errorMsg) : VAbstractApplication::VApp()->IsPedantic() ? throw VExceptionObjectError(errorMsg) :
qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg; qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
} }

32
src/libs/vpatterndb/vpiecepath.cpp
View File

@ -198,7 +198,7 @@ qreal FindTipDirection(const QVector<T> &points)
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
bool IntersectionWithCuttingCountour(const QVector<QPointF> &cuttingPath, const QVector<VLayoutPoint> &points, bool IntersectionWithCuttingContour(const QVector<QPointF> &cuttingPath, const QVector<VLayoutPoint> &points,
QPointF *connection) QPointF *connection)
{ {
if (points.size() <= 1) if (points.size() <= 1)
@ -209,7 +209,7 @@ bool IntersectionWithCuttingCountour(const QVector<QPointF> &cuttingPath, const
const QPointF &first = ConstFirst(points); const QPointF &first = ConstFirst(points);
if (VAbstractCurve::IsPointOnCurve(cuttingPath, first)) if (VAbstractCurve::IsPointOnCurve(cuttingPath, first))
{ // Point is already part of a cutting countour { // Point is already part of a cutting contour
*connection = first; *connection = first;
return true; return true;
} }
@ -390,27 +390,27 @@ void VPiecePath::SetVisibilityTrigger(const QString &formula)
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void VPiecePath::SetFirstToCuttingCountour(bool value) void VPiecePath::SetFirstToCuttingContour(bool value)
{ {
d->m_firstToCuttingCountour = value; d->m_firstToCuttingContour = value;
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
bool VPiecePath::IsFirstToCuttingCountour() const bool VPiecePath::IsFirstToCuttingContour() const
{ {
return d->m_firstToCuttingCountour; return d->m_firstToCuttingContour;
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void VPiecePath::SetLastToCuttingCountour(bool value) void VPiecePath::SetLastToCuttingContour(bool value)
{ {
d->m_lastToCuttingCountour = value; d->m_lastToCuttingContour = value;
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
bool VPiecePath::IsLastToCuttingCountour() const bool VPiecePath::IsLastToCuttingContour() const
{ {
return d->m_lastToCuttingCountour; return d->m_lastToCuttingContour;
} }
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
@ -422,10 +422,10 @@ QVector<VLayoutPoint> VPiecePath::PathPoints(const VContainer *data, const QVect
{ {
QVector<VLayoutPoint> extended = points; QVector<VLayoutPoint> extended = points;
if (IsFirstToCuttingCountour()) if (IsFirstToCuttingContour())
{ {
VLayoutPoint firstConnection; VLayoutPoint firstConnection;
if (IntersectionWithCuttingCountour(cuttingPath, points, &firstConnection)) if (IntersectionWithCuttingContour(cuttingPath, points, &firstConnection))
{ {
firstConnection.SetTurnPoint(true); firstConnection.SetTurnPoint(true);
extended.prepend(firstConnection); extended.prepend(firstConnection);
@ -433,17 +433,17 @@ QVector<VLayoutPoint> VPiecePath::PathPoints(const VContainer *data, const QVect
else else
{ {
const QString errorMsg = QObject::tr("Error in internal path '%1'. There is no intersection of first " const QString errorMsg = QObject::tr("Error in internal path '%1'. There is no intersection of first "
"point with cutting countour") "point with cutting contour")
.arg(GetName()); .arg(GetName());
VAbstractApplication::VApp()->IsPedantic() ? throw VExceptionObjectError(errorMsg) : VAbstractApplication::VApp()->IsPedantic() ? throw VExceptionObjectError(errorMsg) :
qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg; qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;
} }
} }
if (IsLastToCuttingCountour()) if (IsLastToCuttingContour())
{ {
VLayoutPoint lastConnection; VLayoutPoint lastConnection;
if (IntersectionWithCuttingCountour(cuttingPath, Reverse(points), &lastConnection)) if (IntersectionWithCuttingContour(cuttingPath, Reverse(points), &lastConnection))
{ {
lastConnection.SetTurnPoint(true); lastConnection.SetTurnPoint(true);
extended.append(lastConnection); extended.append(lastConnection);
@ -451,7 +451,7 @@ QVector<VLayoutPoint> VPiecePath::PathPoints(const VContainer *data, const QVect
else else
{ {
const QString errorMsg = QObject::tr("Error in internal path '%1'. There is no intersection of last " const QString errorMsg = QObject::tr("Error in internal path '%1'. There is no intersection of last "
"point with cutting countour") "point with cutting contour")
.arg(GetName()); .arg(GetName());
VAbstractApplication::VApp()->IsPedantic() ? throw VExceptionObjectError(errorMsg) : VAbstractApplication::VApp()->IsPedantic() ? throw VExceptionObjectError(errorMsg) :
qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg; qWarning() << VAbstractValApplication::warningMessageSignature + errorMsg;

8
src/libs/vpatterndb/vpiecepath.h
View File

@ -84,11 +84,11 @@ public:
QString GetVisibilityTrigger() const; QString GetVisibilityTrigger() const;
void SetVisibilityTrigger(const QString &formula); void SetVisibilityTrigger(const QString &formula);
void SetFirstToCuttingCountour(bool value); void SetFirstToCuttingContour(bool value);
bool IsFirstToCuttingCountour() const; bool IsFirstToCuttingContour() const;
void SetLastToCuttingCountour(bool value); void SetLastToCuttingContour(bool value);
bool IsLastToCuttingCountour() const; bool IsLastToCuttingContour() const;
QVector<VLayoutPoint> PathPoints(const VContainer *data, QVector<VLayoutPoint> PathPoints(const VContainer *data,
const QVector<QPointF> &cuttingPath = QVector<QPointF>()) const; const QVector<QPointF> &cuttingPath = QVector<QPointF>()) const;

8
src/libs/vpatterndb/vpiecepath_p.h
View File

@ -59,8 +59,8 @@ public:
m_penType(path.m_penType), m_penType(path.m_penType),
m_cut(path.m_cut), m_cut(path.m_cut),
m_visibilityTrigger(path.m_visibilityTrigger), m_visibilityTrigger(path.m_visibilityTrigger),
m_firstToCuttingCountour(path.m_firstToCuttingCountour), m_firstToCuttingContour(path.m_firstToCuttingContour),
m_lastToCuttingCountour(path.m_lastToCuttingCountour) m_lastToCuttingContour(path.m_lastToCuttingContour)
{} {}
~VPiecePathData(); ~VPiecePathData();
@ -71,8 +71,8 @@ public:
Qt::PenStyle m_penType{Qt::SolidLine}; Qt::PenStyle m_penType{Qt::SolidLine};
bool m_cut{false}; bool m_cut{false};
QString m_visibilityTrigger{'1'}; QString m_visibilityTrigger{'1'};
bool m_firstToCuttingCountour{false}; bool m_firstToCuttingContour{false};
bool m_lastToCuttingCountour{false}; bool m_lastToCuttingContour{false};
private: private:
Q_DISABLE_ASSIGN(VPiecePathData) Q_DISABLE_ASSIGN(VPiecePathData)

8
src/libs/vtools/dialogs/tools/piece/dialogpiecepath.cpp
View File

@ -1358,8 +1358,8 @@ void DialogPiecePath::SetPiecePath(const VPiecePath &path)
SetPenType(path.GetPenType()); SetPenType(path.GetPenType());
SetCutPath(path.IsCutPath()); SetCutPath(path.IsCutPath());
ui->checkBoxFirstPointToCuttingContour->setChecked(path.IsFirstToCuttingCountour()); ui->checkBoxFirstPointToCuttingContour->setChecked(path.IsFirstToCuttingContour());
ui->checkBoxLastPointToCuttingContour->setChecked(path.IsLastToCuttingCountour()); ui->checkBoxLastPointToCuttingContour->setChecked(path.IsLastToCuttingContour());
if (path.GetType() == PiecePathType::InternalPath) if (path.GetType() == PiecePathType::InternalPath)
{ {
@ -1628,8 +1628,8 @@ VPiecePath DialogPiecePath::CreatePath() const
path.SetName(ui->lineEditName->text()); path.SetName(ui->lineEditName->text());
path.SetPenType(isInternalPath ? GetPenType() : Qt::SolidLine); path.SetPenType(isInternalPath ? GetPenType() : Qt::SolidLine);
path.SetCutPath(isInternalPath ? IsCutPath() : false); path.SetCutPath(isInternalPath ? IsCutPath() : false);
path.SetFirstToCuttingCountour(isInternalPath ? ui->checkBoxFirstPointToCuttingContour->isChecked() : false); path.SetFirstToCuttingContour(isInternalPath ? ui->checkBoxFirstPointToCuttingContour->isChecked() : false);
path.SetLastToCuttingCountour(isInternalPath ? ui->checkBoxLastPointToCuttingContour->isChecked() : false); path.SetLastToCuttingContour(isInternalPath ? ui->checkBoxLastPointToCuttingContour->isChecked() : false);
path.SetVisibilityTrigger(isInternalPath ? GetFormulaVisible() : QChar('1')); path.SetVisibilityTrigger(isInternalPath ? GetFormulaVisible() : QChar('1'));
return path; return path;

4
src/libs/vtools/tools/nodeDetails/vtoolpiecepath.cpp
View File

@ -194,8 +194,8 @@ void VToolPiecePath::AddAttributes(VAbstractPattern *doc, QDomElement &domElemen
{ {
doc->SetAttribute(domElement, VAbstractPattern::AttrVisible, path.GetVisibilityTrigger()); doc->SetAttribute(domElement, VAbstractPattern::AttrVisible, path.GetVisibilityTrigger());
doc->SetAttribute(domElement, AttrCut, path.IsCutPath()); doc->SetAttribute(domElement, AttrCut, path.IsCutPath());
doc->SetAttribute(domElement, AttrFirstToCountour, path.IsFirstToCuttingCountour()); doc->SetAttribute(domElement, AttrFirstToContour, path.IsFirstToCuttingContour());
doc->SetAttribute(domElement, AttrLastToCountour, path.IsLastToCuttingCountour()); doc->SetAttribute(domElement, AttrLastToContour, path.IsLastToCuttingContour());
} }
} }

6
src/test/ValentinaTest/tst_vlayoutdetail.cpp
View File

@ -59,7 +59,7 @@ void TST_VLayoutDetail::Case1() const
VLayoutPiece det = VLayoutPiece(); VLayoutPiece det = VLayoutPiece();
QVector<VLayoutPoint> inputPoints; QVector<VLayoutPoint> inputPoints;
CastTo(InputPointsCase1(), inputPoints); CastTo(InputPointsCase1(), inputPoints);
det.SetCountourPoints(inputPoints); det.SetContourPoints(inputPoints);
// Begin comparison // Begin comparison
QVector<QPointF> contourPoints; QVector<QPointF> contourPoints;
@ -125,7 +125,7 @@ void TST_VLayoutDetail::Case2() const
VLayoutPiece det = VLayoutPiece(); VLayoutPiece det = VLayoutPiece();
QVector<VLayoutPoint> inputPoints; QVector<VLayoutPoint> inputPoints;
CastTo(InputPointsCase2(), inputPoints); CastTo(InputPointsCase2(), inputPoints);
det.SetCountourPoints(inputPoints); det.SetContourPoints(inputPoints);
// Begin comparison // Begin comparison
QVector<QPointF> contourPoints; QVector<QPointF> contourPoints;
@ -170,7 +170,7 @@ void TST_VLayoutDetail::Case3() const
VLayoutPiece det = VLayoutPiece(); VLayoutPiece det = VLayoutPiece();
QVector<VLayoutPoint> inputPoints; QVector<VLayoutPoint> inputPoints;
CastTo(InputPointsCase3(), inputPoints); CastTo(InputPointsCase3(), inputPoints);
det.SetCountourPoints(inputPoints); det.SetContourPoints(inputPoints);
// Begin comparison // Begin comparison
QVector<QPointF> contourPoints; QVector<QPointF> contourPoints;