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

Added class VPiecePath.

Browse Source 
--HG--
branch : feature
This commit is contained in:
Roman Telezhynskyi 2016-11-23 12:54:46 +02:00
parent 6b89f43e87
commit 5d5e677e2c
13 changed files with 491 additions and 273 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -54,6 +54,7 @@
#include "../vpatterndb/vpatternpiecedata.h"
#include "../vpatterndb/vpatterninfogeometry.h"
#include "../vpatterndb/vgrainlinegeometry.h"
#include "../vpatterndb/vpiecepath.h"
#include <QMessageBox>
#include <QUndoStack>
@ -778,7 +779,7 @@ void VPattern::ParseDetailNodes(const QDomElement &domElement, VPiece &detail) c
node.SetSABefore(saBefore);
node.SetSAAfter(saAfter);
node.SetAngleType(angle);
detail.Append(node);
detail.GetPath().Append(node);
}
}
}

7
src/libs/vpatterndb/vpatterndb.pri
View File

@ -23,7 +23,8 @@ SOURCES += \
$$PWD/vgrainlinegeometry.cpp \
$$PWD/variables/vcurveclength.cpp \
$$PWD/vpiece.cpp \
$$PWD/vpiecenode.cpp
$$PWD/vpiecenode.cpp \
$$PWD/vpiecepath.cpp
win32-msvc*:SOURCES += $$PWD/stable.cpp
@ -63,4 +64,6 @@ HEADERS += \
$$PWD/vpiece.h \
$$PWD/vpiece_p.h \
$$PWD/vpiecenode.h \
$$PWD/vpiecenode_p.h
$$PWD/vpiecenode_p.h \
$$PWD/vpiecepath.h \
$$PWD/vpiecepath_p.h

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

@ -63,114 +63,27 @@ VPiece::~VPiece()
{}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief append append in the end of list node.
* @param node new node.
*/
void VPiece::Append(const VPieceNode &node)
VPiecePath VPiece::GetPath() const
{
d->m_nodes.append(node);
return d->m_path;
}
//---------------------------------------------------------------------------------------------------------------------
/** @brief Clear detail full clear. */
void VPiece::Clear()
VPiecePath &VPiece::GetPath()
{
ClearNodes();
return d->m_path;
}
//---------------------------------------------------------------------------------------------------------------------
/** @brief ClearNodes clear list of nodes. */
void VPiece::ClearNodes()
void VPiece::SetPath(const VPiecePath &path)
{
d->m_nodes.clear();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief CountNode return count nodes.
* @return count.
*/
qint32 VPiece::CountNodes() const
{
return d->m_nodes.size();
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief operator [] find node by index in list.
* @param indx index node in list.
* @return node
*/
VPieceNode &VPiece::operator [](int indx)
{
return d->m_nodes[indx];
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief at find node by index in list.
* @param indx index node in list.
* @return const node.
*/
const VPieceNode &VPiece::at(int indx) const
{
return d->m_nodes.at(indx);
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief getNodes return list of nodes.
* @return list of nodes.
*/
QVector<VPieceNode> VPiece::GetNodes() const
{
return d->m_nodes;
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief setNodes set list of nodes
* @param value list of nodes
*/
// cppcheck-suppress unusedFunction
void VPiece::SetNodes(const QVector<VPieceNode> &nodes)
{
d->m_nodes = nodes;
d->m_path = path;
}
//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> VPiece::MainPathPoints(const VContainer *data) const
{
QVector<QPointF> points;
for (int i = 0; i < CountNodes(); ++i)
{
switch (at(i).GetTypeTool())
{
case (Tool::NodePoint):
{
const QSharedPointer<VPointF> point = data->GeometricObject<VPointF>(at(i).GetId());
points.append(*point);
}
break;
case (Tool::NodeArc):
case (Tool::NodeSpline):
case (Tool::NodeSplinePath):
{
const QSharedPointer<VAbstractCurve> curve = data->GeometricObject<VAbstractCurve>(at(i).GetId());
const QPointF begin = StartSegment(data, i, at(i).GetReverse());
const QPointF end = EndSegment(data, i, at(i).GetReverse());
points << curve->GetSegmentPoints(begin, end, at(i).GetReverse());
}
break;
default:
qDebug()<<"Get wrong tool type. Ignore."<< static_cast<char>(at(i).GetTypeTool());
break;
}
}
QVector<QPointF> points = GetPath().PathPoints(data);
points = CheckLoops(CorrectEquidistantPoints(points));//A path can contains loops
return points;
}
@ -178,26 +91,7 @@ QVector<QPointF> VPiece::MainPathPoints(const VContainer *data) const
//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> VPiece::MainPathNodePoints(const VContainer *data) const
{
QVector<QPointF> points;
for (int i = 0; i < CountNodes(); ++i)
{
switch (at(i).GetTypeTool())
{
case Tool::NodePoint:
{
const QSharedPointer<VPointF> point = data->GeometricObject<VPointF>(at(i).GetId());
points.append(*point);
}
break;
case Tool::NodeArc:
case Tool::NodeSpline:
case Tool::NodeSplinePath:
default:
break;
}
}
return points;
return GetPath().PathNodePoints(data);
}
//---------------------------------------------------------------------------------------------------------------------
@ -212,9 +106,9 @@ QVector<QPointF> VPiece::SeamAllowancePoints(const VContainer *data) const
}
QVector<VSAPoint> pointsEkv;
for (int i = 0; i< CountNodes(); ++i)
for (int i = 0; i< d->m_path.CountNodes(); ++i)
{
const VPieceNode &node = at(i);
const VPieceNode &node = d->m_path.at(i);
switch (node.GetTypeTool())
{
case (Tool::NodePoint):
@ -334,31 +228,32 @@ void VPiece::SetInLayout(bool inLayout)
*/
QVector<VPieceNode> VPiece::Missing(const VPiece &det) const
{
if (d->m_nodes.size() == det.CountNodes()) //-V807
const QVector<VPieceNode> pNodes = d->m_path.GetNodes();
if (pNodes.size() == det.GetPath().CountNodes()) //-V807
{
return QVector<VPieceNode>();
}
QSet<quint32> set1;
for (qint32 i = 0; i < d->m_nodes.size(); ++i)
for (qint32 i = 0; i < pNodes.size(); ++i)
{
set1.insert(d->m_nodes.at(i).GetId());
set1.insert(pNodes.at(i).GetId());
}
QSet<quint32> set2;
for (qint32 j = 0; j < det.CountNodes(); ++j)
for (qint32 j = 0; j < det.GetPath().CountNodes(); ++j)
{
set2.insert(det.at(j).GetId());
set2.insert(det.GetPath().at(j).GetId());
}
const QList<quint32> set3 = set1.subtract(set2).toList();
QVector<VPieceNode> nodes;
for (qint32 i = 0; i < set3.size(); ++i)
{
const int index = indexOfNode(d->m_nodes, set3.at(i));
const int index = indexOfNode(pNodes, set3.at(i));
if (index != -1)
{
nodes.append(d->m_nodes.at(index));
nodes.append(pNodes.at(index));
}
}
@ -373,15 +268,15 @@ QVector<VPieceNode> VPiece::Missing(const VPiece &det) const
*/
int VPiece::indexOfNode(const quint32 &id) const
{
return indexOfNode(d->m_nodes, id);
return indexOfNode(d->m_path.GetNodes(), id);
}
//---------------------------------------------------------------------------------------------------------------------
void VPiece::CurveSeamAllowanceSegment(QVector<VSAPoint> &pointsEkv, const VContainer *data,
const QSharedPointer<VAbstractCurve> &curve, int i, bool reverse) const
{
const VSAPoint begin = StartSegment(data, i, reverse);
const VSAPoint end = EndSegment(data, i, reverse);
const VSAPoint begin = d->m_path.StartSegment(data, i, reverse);
const VSAPoint end = d->m_path.EndSegment(data, i, reverse);
const QVector<QPointF> points = curve->GetSegmentPoints(begin, end, reverse);
if (points.isEmpty())
@ -461,112 +356,6 @@ void VPiece::CurveSeamAllowanceSegment(QVector<VSAPoint> &pointsEkv, const VCont
}
}
//---------------------------------------------------------------------------------------------------------------------
VSAPoint VPiece::StartSegment(const VContainer *data, int i, bool reverse) const
{
if (i < 0 && i > CountNodes()-1)
{
return VSAPoint();
}
const QSharedPointer<VAbstractCurve> curve = data->GeometricObject<VAbstractCurve>(at(i).GetId());
QVector<QPointF> points = curve->GetPoints();
if (reverse)
{
points = VGObject::GetReversePoints(points);
}
VSAPoint begin = VSAPoint(points.first());
if (CountNodes() > 1)
{
if (i == 0)
{
if (at(CountNodes()-1).GetTypeTool() == Tool::NodePoint)
{
const VPieceNode &node = at(CountNodes()-1);
const QPointF p = *data->GeometricObject<VPointF>(node.GetId());
if (curve->IsPointOnCurve(p))
{
begin = VSAPoint(p);
begin.SetSAAfter(node.GetSAAfter(*data->GetPatternUnit()));
begin.SetSABefore(node.GetSABefore(*data->GetPatternUnit()));
begin.SetAngleType(node.GetAngleType());
}
}
}
else
{
if (at(i-1).GetTypeTool() == Tool::NodePoint)
{
const VPieceNode &node = at(i-1);
const QPointF p = *data->GeometricObject<VPointF>(node.GetId());
if (curve->IsPointOnCurve(p))
{
begin = VSAPoint(p);
begin.SetSAAfter(node.GetSAAfter(*data->GetPatternUnit()));
begin.SetSABefore(node.GetSABefore(*data->GetPatternUnit()));
begin.SetAngleType(node.GetAngleType());
}
}
}
}
return begin;
}
//---------------------------------------------------------------------------------------------------------------------
VSAPoint VPiece::EndSegment(const VContainer *data, int i, bool reverse) const
{
if (i < 0 && i > CountNodes()-1)
{
return VSAPoint();
}
const QSharedPointer<VAbstractCurve> curve = data->GeometricObject<VAbstractCurve>(at(i).GetId());
QVector<QPointF> points = curve->GetPoints();
if (reverse)
{
points = VGObject::GetReversePoints(points);
}
VSAPoint end = VSAPoint(points.last());
if (CountNodes() > 2)
{
if (i == CountNodes() - 1)
{
if (at(0).GetTypeTool() == Tool::NodePoint)
{
const VPieceNode &node = at(0);
const QPointF p = *data->GeometricObject<VPointF>(node.GetId());
if (curve->IsPointOnCurve(p))
{
end = VSAPoint(p);
end.SetSAAfter(node.GetSAAfter(*data->GetPatternUnit()));
end.SetSABefore(node.GetSABefore(*data->GetPatternUnit()));
end.SetAngleType(node.GetAngleType());
}
}
}
else
{
if (at(i+1).GetTypeTool() == Tool::NodePoint)
{
const VPieceNode &node = at(i+1);
const QPointF p = *data->GeometricObject<VPointF>(node.GetId());
if (curve->IsPointOnCurve(p))
{
end = VSAPoint(p);
end.SetSAAfter(node.GetSAAfter(*data->GetPatternUnit()));
end.SetSABefore(node.GetSABefore(*data->GetPatternUnit()));
end.SetAngleType(node.GetAngleType());
}
}
}
}
return end;
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief indexOfNode return index in list node using id object.

16
src/libs/vpatterndb/vpiece.h
View File

@ -42,6 +42,7 @@ class VContainer;
template <class T> class QVector;
template <class T>class QSharedPointer;
class VAbstractCurve;
class VPiecePath;
class VPiece : public VAbstractPiece
{
@ -51,16 +52,9 @@ public:
VPiece &operator=(const VPiece &piece);
virtual ~VPiece();
void Append(const VPieceNode &node);
void Clear();
void ClearNodes();
qint32 CountNodes() const;
VPieceNode & operator[](int indx);
const VPieceNode & at ( int indx ) const;
QVector<VPieceNode> GetNodes() const;
void SetNodes(const QVector<VPieceNode> &nodes);
VPiecePath GetPath() const;
VPiecePath &GetPath();
void SetPath(const VPiecePath &path);
QVector<QPointF> MainPathPoints(const VContainer *data) const;
QVector<QPointF> MainPathNodePoints(const VContainer *data) const;
@ -87,8 +81,6 @@ private:
void CurveSeamAllowanceSegment(QVector<VSAPoint> &pointsEkv, const VContainer *data,
const QSharedPointer<VAbstractCurve> &curve, int i, bool reverse) const;
VSAPoint StartSegment(const VContainer *data, int i, bool reverse) const;
VSAPoint EndSegment(const VContainer *data, int i, bool reverse) const;
static int indexOfNode(const QVector<VPieceNode> &list, quint32 id);
};

7
src/libs/vpatterndb/vpiece_p.h
View File

@ -34,6 +34,7 @@
#include "../vmisc/diagnostic.h"
#include "vpiecenode.h"
#include "vpiecepath.h"
QT_WARNING_PUSH
QT_WARNING_DISABLE_GCC("-Weffc++")
@ -42,7 +43,7 @@ class VPieceData : public QSharedData
{
public:
VPieceData()
: m_nodes(),
: m_path(),
m_mx(0),
m_my(0),
m_inLayout(true)
@ -50,7 +51,7 @@ public:
VPieceData(const VPieceData &detail)
: QSharedData(detail),
m_nodes(detail.m_nodes),
m_path(detail.m_path),
m_mx(detail.m_mx),
m_my(detail.m_my),
m_inLayout(detail.m_inLayout)
@ -59,7 +60,7 @@ public:
~VPieceData();
/** @brief nodes list detail nodes. */
QVector<VPieceNode> m_nodes;
VPiecePath m_path;
qreal m_mx;
qreal m_my;

287
src/libs/vpatterndb/vpiecepath.cpp Normal file
View File

@ -0,0 +1,287 @@
/************************************************************************
**
** @file
** @author Roman Telezhynskyi <dismine(at)gmail.com>
** @date 22 11, 2016
**
** @brief
** @copyright
** This source code is part of the Valentine project, a pattern making
** program, whose allow create and modeling patterns of clothing.
** Copyright (C) 2016 Valentina project
** <https://bitbucket.org/dismine/valentina> All Rights Reserved.
**
** Valentina is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** Valentina is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with Valentina. If not, see <http://www.gnu.org/licenses/>.
**
*************************************************************************/
#include "vpiecepath.h"
#include "vpiecepath_p.h"
#include "vcontainer.h"
#include "../vgeometry/vpointf.h"
#include "../vlayout/vabstractpiece.h"
#include <QPainterPath>
//---------------------------------------------------------------------------------------------------------------------
VPiecePath::VPiecePath()
: d(new VPiecePathData)
{}
//---------------------------------------------------------------------------------------------------------------------
VPiecePath::VPiecePath(const VPiecePath &path)
: d (path.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VPiecePath &VPiecePath::operator=(const VPiecePath &path)
{
if ( &path == this )
{
return *this;
}
d = path.d;
return *this;
}
//---------------------------------------------------------------------------------------------------------------------
VPiecePath::~VPiecePath()
{}
//---------------------------------------------------------------------------------------------------------------------
void VPiecePath::Append(const VPieceNode &node)
{
d->m_nodes.append(node);
}
//---------------------------------------------------------------------------------------------------------------------
void VPiecePath::Clear()
{
d->m_nodes.clear();
}
//---------------------------------------------------------------------------------------------------------------------
qint32 VPiecePath::CountNodes() const
{
return d->m_nodes.size();
}
//---------------------------------------------------------------------------------------------------------------------
VPieceNode &VPiecePath::operator[](int indx)
{
return d->m_nodes[indx];
}
//---------------------------------------------------------------------------------------------------------------------
const VPieceNode &VPiecePath::at(int indx) const
{
return d->m_nodes.at(indx);
}
//---------------------------------------------------------------------------------------------------------------------
QVector<VPieceNode> VPiecePath::GetNodes() const
{
return d->m_nodes;
}
//---------------------------------------------------------------------------------------------------------------------
void VPiecePath::SetNodes(const QVector<VPieceNode> &nodes)
{
d->m_nodes = nodes;
}
//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> VPiecePath::PathPoints(const VContainer *data) const
{
QVector<QPointF> points;
for (int i = 0; i < CountNodes(); ++i)
{
switch (at(i).GetTypeTool())
{
case (Tool::NodePoint):
{
const QSharedPointer<VPointF> point = data->GeometricObject<VPointF>(at(i).GetId());
points.append(*point);
}
break;
case (Tool::NodeArc):
case (Tool::NodeSpline):
case (Tool::NodeSplinePath):
{
const QSharedPointer<VAbstractCurve> curve = data->GeometricObject<VAbstractCurve>(at(i).GetId());
const QPointF begin = StartSegment(data, i, at(i).GetReverse());
const QPointF end = EndSegment(data, i, at(i).GetReverse());
points << curve->GetSegmentPoints(begin, end, at(i).GetReverse());
}
break;
default:
qDebug()<<"Get wrong tool type. Ignore."<< static_cast<char>(at(i).GetTypeTool());
break;
}
}
return points;
}
//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> VPiecePath::PathNodePoints(const VContainer *data) const
{
QVector<QPointF> points;
for (int i = 0; i < CountNodes(); ++i)
{
switch (at(i).GetTypeTool())
{
case Tool::NodePoint:
{
const QSharedPointer<VPointF> point = data->GeometricObject<VPointF>(at(i).GetId());
points.append(*point);
}
break;
case Tool::NodeArc:
case Tool::NodeSpline:
case Tool::NodeSplinePath:
default:
break;
}
}
return points;
}
//---------------------------------------------------------------------------------------------------------------------
QPainterPath VPiecePath::PainterPath(const VContainer *data) const
{
const QVector<QPointF> points = PathPoints(data);
QPainterPath path;
if (not points.isEmpty())
{
path.moveTo(points[0]);
for (qint32 i = 1; i < points.count(); ++i)
{
path.lineTo(points.at(i));
}
path.setFillRule(Qt::WindingFill);
}
return path;
}
//---------------------------------------------------------------------------------------------------------------------
VSAPoint VPiecePath::StartSegment(const VContainer *data, int i, bool reverse) const
{
if (i < 0 && i > CountNodes()-1)
{
return VSAPoint();
}
const QSharedPointer<VAbstractCurve> curve = data->GeometricObject<VAbstractCurve>(at(i).GetId());
QVector<QPointF> points = curve->GetPoints();
if (reverse)
{
points = VGObject::GetReversePoints(points);
}
VSAPoint begin = VSAPoint(points.first());
if (CountNodes() > 1)
{
if (i == 0)
{
if (at(CountNodes()-1).GetTypeTool() == Tool::NodePoint)
{
const VPieceNode &node = at(CountNodes()-1);
const QPointF p = *data->GeometricObject<VPointF>(node.GetId());
if (curve->IsPointOnCurve(p))
{
begin = VSAPoint(p);
begin.SetSAAfter(node.GetSAAfter(*data->GetPatternUnit()));
begin.SetSABefore(node.GetSABefore(*data->GetPatternUnit()));
begin.SetAngleType(node.GetAngleType());
}
}
}
else
{
if (at(i-1).GetTypeTool() == Tool::NodePoint)
{
const VPieceNode &node = at(i-1);
const QPointF p = *data->GeometricObject<VPointF>(node.GetId());
if (curve->IsPointOnCurve(p))
{
begin = VSAPoint(p);
begin.SetSAAfter(node.GetSAAfter(*data->GetPatternUnit()));
begin.SetSABefore(node.GetSABefore(*data->GetPatternUnit()));
begin.SetAngleType(node.GetAngleType());
}
}
}
}
return begin;
}
//---------------------------------------------------------------------------------------------------------------------
VSAPoint VPiecePath::EndSegment(const VContainer *data, int i, bool reverse) const
{
if (i < 0 && i > CountNodes()-1)
{
return VSAPoint();
}
const QSharedPointer<VAbstractCurve> curve = data->GeometricObject<VAbstractCurve>(at(i).GetId());
QVector<QPointF> points = curve->GetPoints();
if (reverse)
{
points = VGObject::GetReversePoints(points);
}
VSAPoint end = VSAPoint(points.last());
if (CountNodes() > 2)
{
if (i == CountNodes() - 1)
{
if (at(0).GetTypeTool() == Tool::NodePoint)
{
const VPieceNode &node = at(0);
const QPointF p = *data->GeometricObject<VPointF>(node.GetId());
if (curve->IsPointOnCurve(p))
{
end = VSAPoint(p);
end.SetSAAfter(node.GetSAAfter(*data->GetPatternUnit()));
end.SetSABefore(node.GetSABefore(*data->GetPatternUnit()));
end.SetAngleType(node.GetAngleType());
}
}
}
else
{
if (at(i+1).GetTypeTool() == Tool::NodePoint)
{
const VPieceNode &node = at(i+1);
const QPointF p = *data->GeometricObject<VPointF>(node.GetId());
if (curve->IsPointOnCurve(p))
{
end = VSAPoint(p);
end.SetSAAfter(node.GetSAAfter(*data->GetPatternUnit()));
end.SetSABefore(node.GetSABefore(*data->GetPatternUnit()));
end.SetAngleType(node.GetAngleType());
}
}
}
}
return end;
}

74
src/libs/vpatterndb/vpiecepath.h Normal file
View File

@ -0,0 +1,74 @@
/************************************************************************
**
** @file
** @author Roman Telezhynskyi <dismine(at)gmail.com>
** @date 22 11, 2016
**
** @brief
** @copyright
** This source code is part of the Valentine project, a pattern making
** program, whose allow create and modeling patterns of clothing.
** Copyright (C) 2016 Valentina project
** <https://bitbucket.org/dismine/valentina> All Rights Reserved.
**
** Valentina is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** Valentina is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with Valentina. If not, see <http://www.gnu.org/licenses/>.
**
*************************************************************************/
#ifndef VPIECEPATH_H
#define VPIECEPATH_H
#include <QtGlobal>
#include <QSharedDataPointer>
class VPiecePathData;
class VPieceNode;
class QPointF;
class VContainer;
class VSAPoint;
class QPainterPath;
class VPiecePath
{
public:
VPiecePath();
VPiecePath(const VPiecePath &path);
VPiecePath &operator=(const VPiecePath &path);
~VPiecePath();
void Append(const VPieceNode &node);
void Clear();
qint32 CountNodes() const;
VPieceNode & operator[](int indx);
const VPieceNode & at ( int indx ) const;
QVector<VPieceNode> GetNodes() const;
void SetNodes(const QVector<VPieceNode> &nodes);
QVector<QPointF> PathPoints(const VContainer *data) const;
QVector<QPointF> PathNodePoints(const VContainer *data) const;
QPainterPath PainterPath(const VContainer *data) const;
VSAPoint StartSegment(const VContainer *data, int i, bool reverse) const;
VSAPoint EndSegment(const VContainer *data, int i, bool reverse) const;
private:
QSharedDataPointer<VPiecePathData> d;
};
Q_DECLARE_TYPEINFO(VPiecePath, Q_MOVABLE_TYPE);
#endif // VPIECEPATH_H

67
src/libs/vpatterndb/vpiecepath_p.h Normal file
View File

@ -0,0 +1,67 @@
/************************************************************************
**
** @file
** @author Roman Telezhynskyi <dismine(at)gmail.com>
** @date 22 11, 2016
**
** @brief
** @copyright
** This source code is part of the Valentine project, a pattern making
** program, whose allow create and modeling patterns of clothing.
** Copyright (C) 2016 Valentina project
** <https://bitbucket.org/dismine/valentina> All Rights Reserved.
**
** Valentina is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** Valentina is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with Valentina. If not, see <http://www.gnu.org/licenses/>.
**
*************************************************************************/
#ifndef VPIECEPATH_P_H
#define VPIECEPATH_P_H
#include <QSharedData>
#include <QVector>
#include "../vmisc/diagnostic.h"
#include "vpiecenode.h"
QT_WARNING_PUSH
QT_WARNING_DISABLE_GCC("-Weffc++")
class VPiecePathData : public QSharedData
{
public:
VPiecePathData()
: m_nodes()
{}
VPiecePathData(const VPiecePathData &path)
: QSharedData(path),
m_nodes(path.m_nodes)
{}
~VPiecePathData();
QVector<VPieceNode> m_nodes;
private:
VPiecePathData &operator=(const VPiecePathData &) Q_DECL_EQ_DELETE;
};
VPiecePathData::~VPiecePathData()
{}
QT_WARNING_POP
#endif // VPIECEPATH_P_H

15
src/libs/vtools/dialogs/tools/dialogseamallowance.cpp
View File

@ -29,6 +29,7 @@
#include "dialogseamallowance.h"
#include "ui_dialogseamallowance.h"
#include "../vpatterndb/vpiecenode.h"
#include "../vpatterndb/vpiecepath.h"
#include "visualization/path/vistoolpiece.h"
#include <QMenu>
@ -123,9 +124,9 @@ VPiece DialogSeamAllowance::GetPiece() const
void DialogSeamAllowance::SetPiece(const VPiece &piece)
{
ui->listWidget->clear();
for (int i = 0; i < piece.CountNodes(); ++i)
for (int i = 0; i < piece.GetPath().CountNodes(); ++i)
{
NewItem(piece.at(i));
NewItem(piece.GetPath().at(i));
}
ui->checkBoxForbidFlipping->setChecked(piece.IsForbidFlipping());
@ -186,7 +187,7 @@ void DialogSeamAllowance::ChosenObject(quint32 id, const SceneObject &type)
const VPiece p = CreatePiece();
visPath->SetPiece(p);
if (p.CountNodes() == 1)
if (p.GetPath().CountNodes() == 1)
{
emit ToolTip(tr("Select main path objects clockwise, <b>Shift</b> - reverse direction curve, "
"<b>Enter</b> - finish creation"));
@ -329,7 +330,7 @@ void DialogSeamAllowance::NodeChanged(int index)
const int nodeIndex = piece.indexOfNode(id);
if (nodeIndex != -1)
{
const VPieceNode &node = piece.at(nodeIndex);
const VPieceNode &node = piece.GetPath().at(nodeIndex);
ui->doubleSpinBoxSABefore->setEnabled(true);
ui->doubleSpinBoxSAAfter->setEnabled(true);
@ -437,7 +438,7 @@ VPiece DialogSeamAllowance::CreatePiece() const
for (qint32 i = 0; i < ui->listWidget->count(); ++i)
{
QListWidgetItem *item = ui->listWidget->item(i);
piece.Append(qvariant_cast<VPieceNode>(item->data(Qt::UserRole)));
piece.GetPath().Append(qvariant_cast<VPieceNode>(item->data(Qt::UserRole)));
}
piece.SetForbidFlipping(ui->checkBoxForbidFlipping->isChecked());
@ -530,9 +531,9 @@ void DialogSeamAllowance::InitNodesList()
const VPiece piece = CreatePiece();
for (int i = 0; i < piece.CountNodes(); ++i)
for (int i = 0; i < piece.GetPath().CountNodes(); ++i)
{
const VPieceNode node = piece.at(i);
const VPieceNode node = piece.GetPath().at(i);
if (node.GetTypeTool() == Tool::NodePoint)
{
const QString name = GetNodeName(node);

25
src/libs/vtools/tools/vtoolseamallowance.cpp
View File

@ -29,6 +29,7 @@
#include "vtoolseamallowance.h"
#include "../dialogs/tools/dialogseamallowance.h"
#include "../vpatterndb/vpiecenode.h"
#include "../vpatterndb/vpiecepath.h"
#include "nodeDetails/vnodearc.h"
#include "nodeDetails/vnodepoint.h"
#include "nodeDetails/vnodespline.h"
@ -88,10 +89,10 @@ VToolSeamAllowance *VToolSeamAllowance::Create(DialogTool *dialog, VMainGraphics
VPiece detail = dialogTool->GetPiece();
QVector<VPieceNode> nodes;
qApp->getUndoStack()->beginMacro("add detail");
for (int i = 0; i< detail.CountNodes(); ++i)
for (int i = 0; i< detail.GetPath().CountNodes(); ++i)
{
quint32 id = 0;
VPieceNode nodeD = detail.at(i);
VPieceNode nodeD = detail.GetPath().at(i);
switch (nodeD.GetTypeTool())
{
case (Tool::NodePoint):
@ -142,7 +143,7 @@ VToolSeamAllowance *VToolSeamAllowance::Create(DialogTool *dialog, VMainGraphics
nodes.append(nodeD);
}
detail.SetNodes(nodes);
detail.GetPath().SetNodes(nodes);
VToolSeamAllowance *piece = Create(0, detail, scene, doc, data, Document::FullParse, Source::FromGui);
if (piece != nullptr)
@ -252,12 +253,12 @@ void VToolSeamAllowance::AddNode(VAbstractPattern *doc, QDomElement &domElement,
//---------------------------------------------------------------------------------------------------------------------
void VToolSeamAllowance::AddNodes(VAbstractPattern *doc, QDomElement &domElement, const VPiece &piece)
{
if (piece.CountNodes() > 0)
if (piece.GetPath().CountNodes() > 0)
{
QDomElement nodesElement = doc->createElement(TagNodes);
for (int i = 0; i < piece.CountNodes(); ++i)
for (int i = 0; i < piece.GetPath().CountNodes(); ++i)
{
AddNode(doc, nodesElement, piece.at(i));
AddNode(doc, nodesElement, piece.GetPath().at(i));
}
domElement.appendChild(nodesElement);
}
@ -635,24 +636,24 @@ VToolSeamAllowance::VToolSeamAllowance(VAbstractPattern *doc, VContainer *data,
m_seamAllowance(new VNoBrushScalePathItem(this))
{
VPiece detail = data->GetPiece(id);
for (int i = 0; i< detail.CountNodes(); ++i)
for (int i = 0; i< detail.GetPath().CountNodes(); ++i)
{
switch (detail.at(i).GetTypeTool())
switch (detail.GetPath().at(i).GetTypeTool())
{
case (Tool::NodePoint):
{
VNodePoint *tool = InitTool<VNodePoint>(scene, detail.at(i));
VNodePoint *tool = InitTool<VNodePoint>(scene, detail.GetPath().at(i));
connect(tool, &VNodePoint::ShowContextMenu, this, &VToolSeamAllowance::contextMenuEvent);
break;
}
case (Tool::NodeArc):
doc->IncrementReferens(detail.at(i).GetId());
doc->IncrementReferens(detail.GetPath().at(i).GetId());
break;
case (Tool::NodeSpline):
doc->IncrementReferens(detail.at(i).GetId());
doc->IncrementReferens(detail.GetPath().at(i).GetId());
break;
case (Tool::NodeSplinePath):
doc->IncrementReferens(detail.at(i).GetId());
doc->IncrementReferens(detail.GetPath().at(i).GetId());
break;
default:
qDebug()<<"Get wrong tool type. Ignore.";

3
src/libs/vtools/undocommands/addpiece.cpp
View File

@ -28,6 +28,7 @@
#include "addpiece.h"
#include "../vpatterndb/vpiecenode.h"
#include "../vpatterndb/vpiecepath.h"
//---------------------------------------------------------------------------------------------------------------------
AddPiece::AddPiece(const QDomElement &xml, VAbstractPattern *doc, const VPiece &detail, const QString &drawName,
@ -61,7 +62,7 @@ void AddPiece::undo()
return;
}
DecrementReferences(m_detail.GetNodes());
DecrementReferences(m_detail.GetPath().GetNodes());
}
else
{

3
src/libs/vtools/undocommands/deletepiece.cpp
View File

@ -39,6 +39,7 @@
#include "../tools/vdatatool.h"
#include "vundocommand.h"
#include "../vpatterndb/vpiecenode.h"
#include "../vpatterndb/vpiecepath.h"
class QUndoCommand;
@ -105,7 +106,7 @@ void DeletePiece::redo()
SCASSERT(toolDet != nullptr);
toolDet->hide();
DecrementReferences(m_detail.GetNodes());
DecrementReferences(m_detail.GetPath().GetNodes());
emit NeedFullParsing(); // Doesn't work when UnionDetail delete detail.
}
else

4
src/libs/vtools/visualization/path/vistoolpiece.cpp
View File

@ -27,6 +27,7 @@
*************************************************************************/
#include "vistoolpiece.h"
#include "../vpatterndb/vpiecepath.h"
//---------------------------------------------------------------------------------------------------------------------
VisToolPiece::VisToolPiece(const VContainer *data, QGraphicsItem *parent)
@ -49,7 +50,7 @@ void VisToolPiece::RefreshGeometry()
{
HideAllItems();
if (m_piece.CountNodes() > 0)
if (m_piece.GetPath().CountNodes() > 0)
{
DrawPath(this, m_piece.MainPathPath(Visualization::data), mainColor, Qt::SolidLine, Qt::RoundCap);
@ -99,7 +100,6 @@ void VisToolPiece::HideAllItems()
m_line2->setVisible(false);
}
QVector<QGraphicsEllipseItem *> m_points;
for (int i=0; i < m_points.size(); ++i)
{
if (QGraphicsEllipseItem *item = m_points.at(i))