palo/valentina
1
0
Fork 0
mirror of https://gitlab.com/smart-pattern/valentina.git synced 2024-06-29 07:38:11 +02:00
Code Issues Projects Releases Wiki Activity

Commit after success build. Still not stable.

Browse source 
--HG--
branch : feature
This commit is contained in:
dismine 2013-12-29 18:48:57 +02:00
parent 5e94742b06
commit 41f5f207d8
77 changed files with 2390 additions and 1730 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Valentina.pro
View file

@ -133,4 +133,4 @@ INSTALLS += target \
desktop \ desktop \
pixmaps \ pixmaps \
translations translations
} }

2
src/container/container.pri
View file

@ -1,12 +1,10 @@
SOURCES += \ SOURCES += \
src/container/vpointf.cpp \
src/container/vincrementtablerow.cpp \ src/container/vincrementtablerow.cpp \
src/container/vcontainer.cpp \ src/container/vcontainer.cpp \
src/container/calculator.cpp \ src/container/calculator.cpp \
src/container/vstandarttablerow.cpp src/container/vstandarttablerow.cpp
HEADERS += \ HEADERS += \
src/container/vpointf.h \
src/container/vincrementtablerow.h \ src/container/vincrementtablerow.h \
src/container/vcontainer.h \ src/container/vcontainer.h \
src/container/calculator.h \ src/container/calculator.h \

367
src/container/vcontainer.cpp
View file

@ -30,15 +30,15 @@
#include "../exception/vexceptionbadid.h" #include "../exception/vexceptionbadid.h"
#include <QDebug> #include <QDebug>
#include <QtAlgorithms>
qint64 VContainer::_id = 0; qint64 VContainer::_id = 0;
VContainer::VContainer() VContainer::VContainer()
:base(QHash<QString, qint32>()), points(QHash<qint64, VPointF>()), :base(QHash<QString, qint32>()), gObjects(QHash<qint64, VGObject *>()),
standartTable(QHash<QString, VStandartTableRow>()), incrementTable(QHash<QString, VIncrementTableRow>()), standartTable(QHash<QString, VStandartTableRow *>()), incrementTable(QHash<QString, VIncrementTableRow *>()),
lengthLines(QHash<QString, qreal>()), lineAngles(QHash<QString, qreal>()), splines(QHash<qint64, VSpline>()), lengthLines(QHash<QString, qreal>()),lineAngles(QHash<QString, qreal>()), lengthSplines(QHash<QString, qreal>()),
lengthSplines(QHash<QString, qreal>()), arcs(QHash<qint64, VArc>()), lengthArcs(QHash<QString, qreal>()), lengthArcs(QHash<QString, qreal>()), details(QHash<qint64, VDetail *>())
splinePaths(QHash<qint64, VSplinePath>()), details(QHash<qint64, VDetail>())
{ {
SetSize(500); SetSize(500);
SetGrowth(1760); SetGrowth(1760);
@ -52,11 +52,10 @@ VContainer &VContainer::operator =(const VContainer &data)
} }
VContainer::VContainer(const VContainer &data) VContainer::VContainer(const VContainer &data)
:base(QHash<QString, qint32>()), points(QHash<qint64, VPointF>()), :base(QHash<QString, qint32>()), gObjects(QHash<qint64, VGObject *>()),
standartTable(QHash<QString, VStandartTableRow>()), incrementTable(QHash<QString, VIncrementTableRow>()), standartTable(QHash<QString, VStandartTableRow *>()), incrementTable(QHash<QString, VIncrementTableRow *>()),
lengthLines(QHash<QString, qreal>()), lineAngles(QHash<QString, qreal>()), splines(QHash<qint64, VSpline>()), lengthLines(QHash<QString, qreal>()), lineAngles(QHash<QString, qreal>()), lengthSplines(QHash<QString, qreal>()),
lengthSplines(QHash<QString, qreal>()), arcs(QHash<qint64, VArc>()), lengthArcs(QHash<QString, qreal>()), lengthArcs(QHash<QString, qreal>()), details(QHash<qint64, VDetail *>())
splinePaths(QHash<qint64, VSplinePath>()), details(QHash<qint64, VDetail>())
{ {
setData(data); setData(data);
} }
@ -64,26 +63,23 @@ VContainer::VContainer(const VContainer &data)
void VContainer::setData(const VContainer &data) void VContainer::setData(const VContainer &data)
{ {
base = *data.DataBase(); base = *data.DataBase();
points = *data.DataPoints(); gObjects = *data.DataGObjects();
standartTable = *data.DataStandartTable(); standartTable = *data.DataStandartTable();
incrementTable = *data.DataIncrementTable(); incrementTable = *data.DataIncrementTable();
lengthLines = *data.DataLengthLines(); lengthLines = *data.DataLengthLines();
lineAngles = *data.DataLineAngles(); lineAngles = *data.DataLineAngles();
splines = *data.DataSplines();
lengthSplines = *data.DataLengthSplines(); lengthSplines = *data.DataLengthSplines();
arcs = *data.DataArcs();
lengthArcs = *data.DataLengthArcs(); lengthArcs = *data.DataLengthArcs();
splinePaths = *data.DataSplinePaths();
details = *data.DataDetails(); details = *data.DataDetails();
} }
VPointF VContainer::GetPoint(qint64 id) const const VGObject *VContainer::GetGObject(qint64 id)const
{ {
return GetObject(points, id); return GetObject(gObjects, id);
} }
template <typename key, typename val> template <typename key, typename val>
val VContainer::GetObject(const QHash<key, val> &obj, key id) const val *VContainer::GetObject(const QHash<key, val*> &obj, key id) const
{ {
if (obj.contains(id)) if (obj.contains(id))
{ {
@ -95,13 +91,26 @@ val VContainer::GetObject(const QHash<key, val> &obj, key id)
} }
} }
VStandartTableRow VContainer::GetStandartTableCell(const QString &name) const template <typename key, typename val>
val VContainer::GetVariable(const QHash<key, val> &obj, key id) const
{
if (obj.contains(id))
{
return obj.value(id);
}
else
{
throw VExceptionBadId(tr("Can't find object"), id);
}
}
const VStandartTableRow *VContainer::GetStandartTableCell(const QString &name) const
{ {
Q_ASSERT(name.isEmpty()==false); Q_ASSERT(name.isEmpty()==false);
return GetObject(standartTable, name); return GetObject(standartTable, name);
} }
VIncrementTableRow VContainer::GetIncrementTableRow(const QString& name) const const VIncrementTableRow *VContainer::GetIncrementTableRow(const QString& name) const
{ {
Q_ASSERT(name.isEmpty()==false); Q_ASSERT(name.isEmpty()==false);
return GetObject(incrementTable, name); return GetObject(incrementTable, name);
@ -110,53 +119,38 @@ VIncrementTableRow VContainer::GetIncrementTableRow(const QString& name) const
qreal VContainer::GetLine(const QString &name) const qreal VContainer::GetLine(const QString &name) const
{ {
Q_ASSERT(name.isEmpty()==false); Q_ASSERT(name.isEmpty()==false);
return GetObject(lengthLines, name); return GetVariable(lengthLines, name);
} }
qreal VContainer::GetLengthArc(const QString &name) const qreal VContainer::GetLengthArc(const QString &name) const
{ {
Q_ASSERT(name.isEmpty()==false); Q_ASSERT(name.isEmpty()==false);
return GetObject(lengthArcs, name); return GetVariable(lengthArcs, name);
} }
qreal VContainer::GetLengthSpline(const QString &name) const qreal VContainer::GetLengthSpline(const QString &name) const
{ {
Q_ASSERT(name.isEmpty()==false); Q_ASSERT(name.isEmpty()==false);
return GetObject(lengthSplines, name); return GetVariable(lengthSplines, name);
} }
qreal VContainer::GetLineAngle(const QString &name) const qreal VContainer::GetLineAngle(const QString &name) const
{ {
Q_ASSERT(name.isEmpty()==false); Q_ASSERT(name.isEmpty()==false);
return GetObject(lineAngles, name); return GetVariable(lineAngles, name);
} }
VSpline VContainer::GetSpline(qint64 id) const const VDetail *VContainer::GetDetail(qint64 id) const
{
return GetObject(splines, id);
}
VArc VContainer::GetArc(qint64 id) const
{
return GetObject(arcs, id);
}
VSplinePath VContainer::GetSplinePath(qint64 id) const
{
return GetObject(splinePaths, id);
}
VDetail VContainer::GetDetail(qint64 id) const
{ {
return GetObject(details, id); return GetObject(details, id);
} }
qint64 VContainer::AddPoint(const VPointF &point) qint64 VContainer::AddGObject(VGObject *obj)
{ {
return AddObject(points, point); return AddObject(gObjects, obj);
} }
qint64 VContainer::AddDetail(const VDetail &detail) qint64 VContainer::AddDetail(VDetail *detail)
{ {
return AddObject(details, detail); return AddObject(details, detail);
} }
@ -177,101 +171,100 @@ void VContainer::UpdateId(qint64 newId)
QPainterPath VContainer::ContourPath(qint64 idDetail) const QPainterPath VContainer::ContourPath(qint64 idDetail) const
{ {
VDetail detail = GetDetail(idDetail); const VDetail *detail = GetDetail(idDetail);
QVector<QPointF> points; QVector<QPointF> points;
QVector<QPointF> pointsEkv; QVector<QPointF> pointsEkv;
for (ptrdiff_t i = 0; i< detail.CountNode(); ++i) for (ptrdiff_t i = 0; i< detail->CountNode(); ++i)
{ {
switch (detail[i].getTypeTool()) switch (detail->at(i).getTypeTool())
{ {
case (Tool::NodePoint): case (Tool::NodePoint):
{ {
VPointF point = GetPoint(detail[i].getId()); const VPointF *point = GeometricObject<const VPointF*>(detail->at(i).getId());
points.append(point.toQPointF()); points.append(point->toQPointF());
if (detail.getSupplement() == true) if (detail->getSupplement() == true)
{ {
QPointF pEkv = point.toQPointF(); QPointF pEkv = point->toQPointF();
pEkv.setX(pEkv.x()+detail[i].getMx()); pEkv.setX(pEkv.x()+detail->at(i).getMx());
pEkv.setY(pEkv.y()+detail[i].getMy()); pEkv.setY(pEkv.y()+detail->at(i).getMy());
pointsEkv.append(pEkv); pointsEkv.append(pEkv);
} }
} }
break; break;
case (Tool::NodeArc): case (Tool::NodeArc):
{ {
VArc arc = GetArc(detail[i].getId()); const VArc *arc = GeometricObject<const VArc *>(detail->at(i).getId());
qreal len1 = GetLengthContour(points, arc.GetPoints()); qreal len1 = GetLengthContour(points, arc->GetPoints());
qreal lenReverse = GetLengthContour(points, GetReversePoint(arc.GetPoints())); qreal lenReverse = GetLengthContour(points, GetReversePoint(arc->GetPoints()));
if (len1 <= lenReverse) if (len1 <= lenReverse)
{ {
points << arc.GetPoints(); points << arc->GetPoints();
if (detail.getSupplement() == true) if (detail->getSupplement() == true)
{ {
pointsEkv << biasPoints(arc.GetPoints(), detail[i].getMx(), detail[i].getMy()); pointsEkv << biasPoints(arc->GetPoints(), detail->at(i).getMx(), detail->at(i).getMy());
} }
} }
else else
{ {
points << GetReversePoint(arc.GetPoints()); points << GetReversePoint(arc->GetPoints());
if (detail.getSupplement() == true) if (detail->getSupplement() == true)
{ {
pointsEkv << biasPoints(GetReversePoint(arc.GetPoints()), detail[i].getMx(), detail[i].getMy()); pointsEkv << biasPoints(GetReversePoint(arc->GetPoints()), detail->at(i).getMx(),
detail->at(i).getMy());
} }
} }
} }
break; break;
case (Tool::NodeSpline): case (Tool::NodeSpline):
{ {
VSpline spline = GetSpline(detail[i].getId()); const VSpline *spline = GeometricObject<const VSpline *>(detail->at(i).getId());
qreal len1 = GetLengthContour(points, spline.GetPoints()); qreal len1 = GetLengthContour(points, spline->GetPoints());
qreal lenReverse = GetLengthContour(points, GetReversePoint(spline.GetPoints())); qreal lenReverse = GetLengthContour(points, GetReversePoint(spline->GetPoints()));
if (len1 <= lenReverse) if (len1 <= lenReverse)
{ {
points << spline.GetPoints(); points << spline->GetPoints();
if (detail.getSupplement() == true) if (detail->getSupplement() == true)
{ {
pointsEkv << biasPoints(spline.GetPoints(), detail[i].getMx(), detail[i].getMy()); pointsEkv << biasPoints(spline->GetPoints(), detail->at(i).getMx(), detail->at(i).getMy());
} }
} }
else else
{ {
points << GetReversePoint(spline.GetPoints()); points << GetReversePoint(spline->GetPoints());
if (detail.getSupplement() == true) if (detail->getSupplement() == true)
{ {
pointsEkv << biasPoints(GetReversePoint(spline.GetPoints()), detail[i].getMx(), pointsEkv << biasPoints(GetReversePoint(spline->GetPoints()), detail->at(i).getMx(),
detail[i].getMy()); detail->at(i).getMy());
} }
} }
} }
break; break;
case (Tool::NodeSplinePath): case (Tool::NodeSplinePath):
{ {
VSplinePath splinePath = GetSplinePath(detail[i].getId()); const VSplinePath *splinePath = GeometricObject<const VSplinePath *>(detail->at(i).getId());
qreal len1 = GetLengthContour(points, splinePath.GetPathPoints()); qreal len1 = GetLengthContour(points, splinePath->GetPathPoints());
qreal lenReverse = GetLengthContour(points, GetReversePoint(splinePath.GetPathPoints())); qreal lenReverse = GetLengthContour(points, GetReversePoint(splinePath->GetPathPoints()));
if (len1 <= lenReverse) if (len1 <= lenReverse)
{ {
points << splinePath.GetPathPoints(); points << splinePath->GetPathPoints();
if (detail.getSupplement() == true) if (detail->getSupplement() == true)
{ {
pointsEkv << biasPoints(splinePath.GetPathPoints(), detail[i].getMx(), detail[i].getMy()); pointsEkv << biasPoints(splinePath->GetPathPoints(), detail->at(i).getMx(), detail->at(i).getMy());
} }
} }
else else
{ {
points << GetReversePoint(splinePath.GetPathPoints()); points << GetReversePoint(splinePath->GetPathPoints());
if (detail.getSupplement() == true) if (detail->getSupplement() == true)
{ {
pointsEkv << biasPoints(GetReversePoint(splinePath.GetPathPoints()), detail[i].getMx(), pointsEkv << biasPoints(GetReversePoint(splinePath->GetPathPoints()), detail->at(i).getMx(),
detail[i].getMy()); detail->at(i).getMy());
} }
} }
} }
break; break;
case (Tool::SplineTool):
break;//Nothing to do, just ignore.
default: default:
qWarning()<<"Get wrong tool type. Ignore."<<detail[i].getTypeTool(); qWarning()<<"Get wrong tool type. Ignore."<<detail->at(i).getTypeTool();
break; break;
} }
} }
@ -284,16 +277,16 @@ QPainterPath VContainer::ContourPath(qint64 idDetail) const
} }
path.lineTo(points[0]); path.lineTo(points[0]);
if (detail.getSupplement() == true) if (detail->getSupplement() == true)
{ {
QPainterPath ekv; QPainterPath ekv;
if (detail.getClosed() == true) if (detail->getClosed() == true)
{ {
ekv = Equidistant(pointsEkv, Detail::CloseEquidistant, toPixel(detail.getWidth())); ekv = Equidistant(pointsEkv, Detail::CloseEquidistant, toPixel(detail->getWidth()));
} }
else else
{ {
ekv = Equidistant(pointsEkv, Detail::OpenEquidistant, toPixel(detail.getWidth())); ekv = Equidistant(pointsEkv, Detail::OpenEquidistant, toPixel(detail->getWidth()));
} }
path.addPath(ekv); path.addPath(ekv);
path.setFillRule(Qt::WindingFill); path.setFillRule(Qt::WindingFill);
@ -363,7 +356,7 @@ QPainterPath VContainer::Equidistant(QVector<QPointF> points, const Detail::Equi
continue; continue;
} }
else if (i == points.size()-1 && eqv == Detail::OpenEquidistant) else if (i == points.size()-1 && eqv == Detail::OpenEquidistant)
{//остання точка, polyline doesn't closed {//last point, polyline doesn't closed
ekvPoints.append(SingleParallelPoint(QLineF(points[points.size()-1], points[points.size()-2]), -90, ekvPoints.append(SingleParallelPoint(QLineF(points[points.size()-1], points[points.size()-2]), -90,
width)); width));
continue; continue;
@ -508,18 +501,21 @@ QVector<QPointF> VContainer::CheckLoops(const QVector<QPointF> &points) const
void VContainer::PrepareDetails(QVector<VItem *> &list) const void VContainer::PrepareDetails(QVector<VItem *> &list) const
{ {
QHashIterator<qint64, VDetail> iDetail(details); QHashIterator<qint64, VDetail *> idetail(details);
while (iDetail.hasNext()) while (idetail.hasNext())
{ {
iDetail.next(); idetail.next();
list.append(new VItem(ContourPath(iDetail.key()), list.size())); list.append(new VItem(ContourPath(idetail.key()), list.size()));
} }
} }
template <typename val> template <typename val>
void VContainer::UpdateObject(QHash<qint64, val> &obj, const qint64 &id, const val& point) void VContainer::UpdateObject(QHash<qint64, val *> &obj, const qint64 &id, val *point)
{ {
Q_ASSERT_X(id > 0, Q_FUNC_INFO, "id <= 0"); Q_ASSERT_X(id > 0, Q_FUNC_INFO, "id <= 0");
Q_ASSERT(point != 0);
point->setId(id);
delete GetObject(gObjects, id);
obj[id] = point; obj[id] = point;
UpdateId(id); UpdateId(id);
} }
@ -532,7 +528,8 @@ void VContainer::AddLengthSpline(const QString &name, const qreal &value)
void VContainer::AddLengthArc(const qint64 &id) void VContainer::AddLengthArc(const qint64 &id)
{ {
AddLengthArc(GetArc(id).name(), toMM(GetArc(id).GetLength())); const VArc * arc = GeometricObject<const VArc *>(id);
AddLengthArc(arc->name(), toMM(arc->GetLength()));
} }
void VContainer::AddLengthArc(const QString &name, const qreal &value) void VContainer::AddLengthArc(const QString &name, const qreal &value)
@ -549,19 +546,19 @@ void VContainer::AddLineAngle(const QString &name, const qreal &value)
qreal VContainer::GetValueStandartTableCell(const QString& name) const qreal VContainer::GetValueStandartTableCell(const QString& name) const
{ {
VStandartTableRow cell = GetStandartTableCell(name); const VStandartTableRow *cell = GetStandartTableCell(name);
qreal k_size = ( static_cast<qreal> (size()/10.0) - 50.0 ) / 2.0; qreal k_size = ( static_cast<qreal> (size()/10.0) - 50.0 ) / 2.0;
qreal k_growth = ( static_cast<qreal> (growth()/10.0) - 176.0 ) / 6.0; qreal k_growth = ( static_cast<qreal> (growth()/10.0) - 176.0 ) / 6.0;
qreal value = cell.GetBase() + k_size*cell.GetKsize() + k_growth*cell.GetKgrowth(); qreal value = cell->GetBase() + k_size*cell->GetKsize() + k_growth*cell->GetKgrowth();
return value; return value;
} }
qreal VContainer::GetValueIncrementTableRow(const QString& name) const qreal VContainer::GetValueIncrementTableRow(const QString& name) const
{ {
VIncrementTableRow cell = GetIncrementTableRow(name); const VIncrementTableRow *cell = GetIncrementTableRow(name);
qreal k_size = ( static_cast<qreal> (size()/10.0) - 50.0 ) / 2.0; qreal k_size = ( static_cast<qreal> (size()/10.0) - 50.0 ) / 2.0;
qreal k_growth = ( static_cast<qreal> (growth()/10.0) - 176.0 ) / 6.0; qreal k_growth = ( static_cast<qreal> (growth()/10.0) - 176.0 ) / 6.0;
qreal value = cell.getBase() + k_size*cell.getKsize() + k_growth*cell.getKgrowth(); qreal value = cell->getBase() + k_size*cell->getKsize() + k_growth*cell->getKgrowth();
return value; return value;
} }
@ -580,10 +577,8 @@ void VContainer::Clear()
void VContainer::ClearObject() void VContainer::ClearObject()
{ {
points.clear(); qDeleteAll(gObjects);
splines.clear(); gObjects.clear();
arcs.clear();
splinePaths.clear();
} }
qreal VContainer::FindVar(const QString &name, bool *ok)const qreal VContainer::FindVar(const QString &name, bool *ok)const
@ -631,77 +626,49 @@ qreal VContainer::FindVar(const QString &name, bool *ok)const
void VContainer::AddLine(const qint64 &firstPointId, const qint64 &secondPointId) void VContainer::AddLine(const qint64 &firstPointId, const qint64 &secondPointId)
{ {
QString nameLine = GetNameLine(firstPointId, secondPointId); QString nameLine = GetNameLine(firstPointId, secondPointId);
VPointF first = GetPoint(firstPointId); const VPointF *first = GeometricObject<const VPointF *>(firstPointId);
VPointF second = GetPoint(secondPointId); const VPointF *second = GeometricObject<const VPointF *>(secondPointId);
AddLengthLine(nameLine, toMM(QLineF(first.toQPointF(), second.toQPointF()).length())); AddLengthLine(nameLine, toMM(QLineF(first->toQPointF(), second->toQPointF()).length()));
nameLine = GetNameLineAngle(firstPointId, secondPointId); nameLine = GetNameLineAngle(firstPointId, secondPointId);
AddLineAngle(nameLine, QLineF(first.toQPointF(), second.toQPointF()).angle()); AddLineAngle(nameLine, QLineF(first->toQPointF(), second->toQPointF()).angle());
}
qint64 VContainer::AddSpline(const VSpline &spl)
{
return AddObject(splines, spl);
}
qint64 VContainer::AddSplinePath(const VSplinePath &splPath)
{
return AddObject(splinePaths, splPath);
}
qint64 VContainer::AddArc(const VArc &arc)
{
return AddObject(arcs, arc);
} }
template <typename key, typename val> template <typename key, typename val>
qint64 VContainer::AddObject(QHash<key, val> &obj, const val& value) qint64 VContainer::AddObject(QHash<key, val*> &obj, val *value)
{ {
Q_ASSERT(value != 0);
qint64 id = getNextId(); qint64 id = getNextId();
value->setId(id);
obj[id] = value; obj[id] = value;
return id; return id;
} }
QString VContainer::GetNameLine(const qint64 &firstPoint, const qint64 &secondPoint) const QString VContainer::GetNameLine(const qint64 &firstPoint, const qint64 &secondPoint) const
{ {
VPointF first = GetPoint(firstPoint); const VPointF *first = GeometricObject<const VPointF *>(firstPoint);
VPointF second = GetPoint(secondPoint); const VPointF *second = GeometricObject<const VPointF *>(secondPoint);
return QString("Line_%1_%2").arg(first.name(), second.name()); return QString("Line_%1_%2").arg(first->name(), second->name());
} }
QString VContainer::GetNameLineAngle(const qint64 &firstPoint, const qint64 &secondPoint) const QString VContainer::GetNameLineAngle(const qint64 &firstPoint, const qint64 &secondPoint) const
{ {
VPointF first = GetPoint(firstPoint); const VPointF *first = GeometricObject<const VPointF *>(firstPoint);
VPointF second = GetPoint(secondPoint); const VPointF *second = GeometricObject<const VPointF *>(secondPoint);
return QString("AngleLine_%1_%2").arg(first.name(), second.name()); return QString("AngleLine_%1_%2").arg(first->name(), second->name());
} }
void VContainer::UpdatePoint(qint64 id, const VPointF &point) void VContainer::UpdateGObject(qint64 id, VGObject* obj)
{ {
UpdateObject(points, id, point); UpdateObject(gObjects, id, obj);
} }
void VContainer::UpdateDetail(qint64 id, const VDetail &detail) void VContainer::UpdateDetail(qint64 id,VDetail *detail)
{ {
UpdateObject(details, id, detail); UpdateObject(details, id, detail);
} }
void VContainer::UpdateSpline(qint64 id, const VSpline &spl)
{
UpdateObject(splines, id, spl);
}
void VContainer::UpdateSplinePath(qint64 id, const VSplinePath &splPath)
{
UpdateObject(splinePaths, id, splPath);
}
void VContainer::UpdateArc(qint64 id, const VArc &arc)
{
UpdateObject(arcs, id, arc);
}
void VContainer::AddLengthLine(const QString &name, const qreal &value) void VContainer::AddLengthLine(const QString &name, const qreal &value)
{ {
Q_ASSERT(name.isEmpty() == false); Q_ASSERT(name.isEmpty() == false);
@ -710,60 +677,60 @@ void VContainer::AddLengthLine(const QString &name, const qreal &value)
void VContainer::CreateManTableIGroup () void VContainer::CreateManTableIGroup ()
{ {
AddStandartTableCell("Pkor", VStandartTableRow(84, 0, 3)); AddStandartTableCell("Pkor", new VStandartTableRow(84, 0, 3));
AddStandartTableCell("Pkor", VStandartTableRow(84, 0, 3)); AddStandartTableCell("Pkor", new VStandartTableRow(84, 0, 3));
AddStandartTableCell("Vtos", VStandartTableRow(1450, 2, 51)); AddStandartTableCell("Vtos", new VStandartTableRow(1450, 2, 51));
AddStandartTableCell("Vtosh", VStandartTableRow(1506, 2, 54)); AddStandartTableCell("Vtosh", new VStandartTableRow(1506, 2, 54));
AddStandartTableCell("Vpt", VStandartTableRow(1438, 3, 52)); AddStandartTableCell("Vpt", new VStandartTableRow(1438, 3, 52));
AddStandartTableCell("Vst", VStandartTableRow(1257, -1, 49)); AddStandartTableCell("Vst", new VStandartTableRow(1257, -1, 49));
AddStandartTableCell("Vlt", VStandartTableRow(1102, 0, 43)); AddStandartTableCell("Vlt", new VStandartTableRow(1102, 0, 43));
AddStandartTableCell("Vk", VStandartTableRow(503, 0, 22)); AddStandartTableCell("Vk", new VStandartTableRow(503, 0, 22));
AddStandartTableCell("Vsht", VStandartTableRow(1522, 2, 54)); AddStandartTableCell("Vsht", new VStandartTableRow(1522, 2, 54));
AddStandartTableCell("Vzy", VStandartTableRow(1328, 0, 49)); AddStandartTableCell("Vzy", new VStandartTableRow(1328, 0, 49));
AddStandartTableCell("Vlop", VStandartTableRow(1320, 0, 49)); AddStandartTableCell("Vlop", new VStandartTableRow(1320, 0, 49));
AddStandartTableCell("Vps", VStandartTableRow(811, -1, 36)); AddStandartTableCell("Vps", new VStandartTableRow(811, -1, 36));
AddStandartTableCell("Ssh", VStandartTableRow(202, 4, 1)); AddStandartTableCell("Ssh", new VStandartTableRow(202, 4, 1));
AddStandartTableCell("SgI", VStandartTableRow(517, 18, 2)); AddStandartTableCell("SgI", new VStandartTableRow(517, 18, 2));
AddStandartTableCell("SgII", VStandartTableRow(522, 19, 1)); AddStandartTableCell("SgII", new VStandartTableRow(522, 19, 1));
AddStandartTableCell("SgIII", VStandartTableRow(500, 20, 0)); AddStandartTableCell("SgIII", new VStandartTableRow(500, 20, 0));
AddStandartTableCell("St", VStandartTableRow(390, 20, 0)); AddStandartTableCell("St", new VStandartTableRow(390, 20, 0));
AddStandartTableCell("Sb", VStandartTableRow(492, 15, 5)); AddStandartTableCell("Sb", new VStandartTableRow(492, 15, 5));
AddStandartTableCell("SbI", VStandartTableRow(482, 12, 6)); AddStandartTableCell("SbI", new VStandartTableRow(482, 12, 6));
AddStandartTableCell("Obed", VStandartTableRow(566, 18, 6)); AddStandartTableCell("Obed", new VStandartTableRow(566, 18, 6));
AddStandartTableCell("Ok", VStandartTableRow(386, 8, 8)); AddStandartTableCell("Ok", new VStandartTableRow(386, 8, 8));
AddStandartTableCell("Oi", VStandartTableRow(380, 8, 6)); AddStandartTableCell("Oi", new VStandartTableRow(380, 8, 6));
AddStandartTableCell("Osch", VStandartTableRow(234, 4, 4)); AddStandartTableCell("Osch", new VStandartTableRow(234, 4, 4));
AddStandartTableCell("Dsb", VStandartTableRow(1120, 0, 44)); AddStandartTableCell("Dsb", new VStandartTableRow(1120, 0, 44));
AddStandartTableCell("Dsp", VStandartTableRow(1110, 0, 43)); AddStandartTableCell("Dsp", new VStandartTableRow(1110, 0, 43));
AddStandartTableCell("Dn", VStandartTableRow(826, -3, 37)); AddStandartTableCell("Dn", new VStandartTableRow(826, -3, 37));
AddStandartTableCell("Dps", VStandartTableRow(316, 4, 7)); AddStandartTableCell("Dps", new VStandartTableRow(316, 4, 7));
AddStandartTableCell("Dpob", VStandartTableRow(783, 14, 15)); AddStandartTableCell("Dpob", new VStandartTableRow(783, 14, 15));
AddStandartTableCell("Ds", VStandartTableRow(260, 1, 6)); AddStandartTableCell("Ds", new VStandartTableRow(260, 1, 6));
AddStandartTableCell("Op", VStandartTableRow(316, 12, 0)); AddStandartTableCell("Op", new VStandartTableRow(316, 12, 0));
AddStandartTableCell("Ozap", VStandartTableRow(180, 4, 0)); AddStandartTableCell("Ozap", new VStandartTableRow(180, 4, 0));
AddStandartTableCell("Pkis", VStandartTableRow(250, 4, 0)); AddStandartTableCell("Pkis", new VStandartTableRow(250, 4, 0));
AddStandartTableCell("SHp", VStandartTableRow(160, 1, 4)); AddStandartTableCell("SHp", new VStandartTableRow(160, 1, 4));
AddStandartTableCell("Dlych", VStandartTableRow(500, 2, 15)); AddStandartTableCell("Dlych", new VStandartTableRow(500, 2, 15));
AddStandartTableCell("Dzap", VStandartTableRow(768, 2, 24)); AddStandartTableCell("Dzap", new VStandartTableRow(768, 2, 24));
AddStandartTableCell("DIIIp", VStandartTableRow(970, 2, 29)); AddStandartTableCell("DIIIp", new VStandartTableRow(970, 2, 29));
AddStandartTableCell("Vprp", VStandartTableRow(214, 3, 3)); AddStandartTableCell("Vprp", new VStandartTableRow(214, 3, 3));
AddStandartTableCell("Vg", VStandartTableRow(262, 8, 3)); AddStandartTableCell("Vg", new VStandartTableRow(262, 8, 3));
AddStandartTableCell("Dtp", VStandartTableRow(460, 7, 9)); AddStandartTableCell("Dtp", new VStandartTableRow(460, 7, 9));
AddStandartTableCell("Dp", VStandartTableRow(355, 5, 5)); AddStandartTableCell("Dp", new VStandartTableRow(355, 5, 5));
AddStandartTableCell("Vprz", VStandartTableRow(208, 3, 5)); AddStandartTableCell("Vprz", new VStandartTableRow(208, 3, 5));
AddStandartTableCell("Dts", VStandartTableRow(438, 2, 10)); AddStandartTableCell("Dts", new VStandartTableRow(438, 2, 10));
AddStandartTableCell("DtsI", VStandartTableRow(469, 2, 10)); AddStandartTableCell("DtsI", new VStandartTableRow(469, 2, 10));
AddStandartTableCell("Dvcht", VStandartTableRow(929, 9, 19)); AddStandartTableCell("Dvcht", new VStandartTableRow(929, 9, 19));
AddStandartTableCell("SHg", VStandartTableRow(370, 14, 4)); AddStandartTableCell("SHg", new VStandartTableRow(370, 14, 4));
AddStandartTableCell("Cg", VStandartTableRow(224, 6, 0)); AddStandartTableCell("Cg", new VStandartTableRow(224, 6, 0));
AddStandartTableCell("SHs", VStandartTableRow(416, 10, 2)); AddStandartTableCell("SHs", new VStandartTableRow(416, 10, 2));
AddStandartTableCell("dpzr", VStandartTableRow(121, 6, 0)); AddStandartTableCell("dpzr", new VStandartTableRow(121, 6, 0));
AddStandartTableCell("Ogol", VStandartTableRow(576, 4, 4)); AddStandartTableCell("Ogol", new VStandartTableRow(576, 4, 4));
AddStandartTableCell("Ssh1", VStandartTableRow(205, 5, 0)); AddStandartTableCell("Ssh1", new VStandartTableRow(205, 5, 0));
AddStandartTableCell("St", VStandartTableRow(410, 20, 0)); AddStandartTableCell("St", new VStandartTableRow(410, 20, 0));
AddStandartTableCell("Drzap", VStandartTableRow(594, 3, 19)); AddStandartTableCell("Drzap", new VStandartTableRow(594, 3, 19));
AddStandartTableCell("DbII", VStandartTableRow(1020, 0, 44)); AddStandartTableCell("DbII", new VStandartTableRow(1020, 0, 44));
AddStandartTableCell("Sb", VStandartTableRow(504, 15, 4)); AddStandartTableCell("Sb", new VStandartTableRow(504, 15, 4));
} }
QVector<QPointF> VContainer::GetReversePoint(const QVector<QPointF> &points) const QVector<QPointF> VContainer::GetReversePoint(const QVector<QPointF> &points) const

164
src/container/vcontainer.h
View file

@ -35,6 +35,7 @@
#include "../geometry/vsplinepath.h" #include "../geometry/vsplinepath.h"
#include "../geometry/vdetail.h" #include "../geometry/vdetail.h"
#include "../widgets/vitem.h" #include "../widgets/vitem.h"
#include "../geometry/vgobject.h"
/** /**
* @brief The VContainer class container of all variables. * @brief The VContainer class container of all variables.
@ -63,24 +64,32 @@ public:
* @param data container * @param data container
*/ */
void setData(const VContainer &data); void setData(const VContainer &data);
template <typename T>
const T GeometricObject(qint64 id) const
{
const T obj = dynamic_cast<T>(GetObject(gObjects, id));
Q_ASSERT(obj != 0);
return obj;
}
/** /**
* @brief GetPoint returns a point by id * @brief GetGObject returns a point by id
* @param id id of point * @param id id of point
* @return point * @return point
*/ */
VPointF GetPoint(qint64 id) const; const VGObject *GetGObject(qint64 id) const;
/** /**
* @brief GetStandartTableCell return standart table row by name * @brief GetStandartTableCell return standart table row by name
* @param name name of standart table row * @param name name of standart table row
* @return row of standart table * @return row of standart table
*/ */
VStandartTableRow GetStandartTableCell(const QString& name) const; const VStandartTableRow *GetStandartTableCell(const QString& name) const;
/** /**
* @brief GetIncrementTableRow return increment table row by name * @brief GetIncrementTableRow return increment table row by name
* @param name name of increment table row * @param name name of increment table row
* @return row of increment table * @return row of increment table
*/ */
VIncrementTableRow GetIncrementTableRow(const QString& name) const; const VIncrementTableRow *GetIncrementTableRow(const QString& name) const;
/** /**
* @brief GetLine return length of line by name * @brief GetLine return length of line by name
* @param name name of line * @param name name of line
@ -105,30 +114,12 @@ public:
* @return angle in degree * @return angle in degree
*/ */
qreal GetLineAngle(const QString &name) const; qreal GetLineAngle(const QString &name) const;
/**
* @brief GetSpline return spline by id
* @param id id of spline
* @return spline
*/
VSpline GetSpline(qint64 id) const;
/**
* @brief GetArc return arc by id
* @param id id of arc
* @return arc
*/
VArc GetArc(qint64 id) const;
/**
* @brief GetSplinePath return spline path by id
* @param id id of spline path
* @return spline path
*/
VSplinePath GetSplinePath(qint64 id) const;
/** /**
* @brief GetDetail return detail by id * @brief GetDetail return detail by id
* @param id id of detail * @param id id of detail
* @return detail * @return detail
*/ */
VDetail GetDetail(qint64 id) const; const VDetail *GetDetail(qint64 id) const;
/** /**
* @brief getId return current id * @brief getId return current id
* @return current id * @return current id
@ -139,26 +130,26 @@ public:
* @param point new point * @param point new point
* @return return id of new point in container * @return return id of new point in container
*/ */
qint64 AddPoint(const VPointF& point); qint64 AddGObject(VGObject *obj);
/** /**
* @brief AddDetail add new detail to container * @brief AddDetail add new detail to container
* @param detail new detail * @param detail new detail
* @return return id of new detail in container * @return return id of new detail in container
*/ */
qint64 AddDetail(const VDetail& detail); qint64 AddDetail(VDetail *detail);
/** /**
* @brief AddStandartTableCell add new row of standart table * @brief AddStandartTableCell add new row of standart table
* @param name name of row of standart table * @param name name of row of standart table
* @param cell row of standart table * @param cell row of standart table
*/ */
inline void AddStandartTableCell(const QString& name, const VStandartTableRow& cell) inline void AddStandartTableCell(const QString& name, VStandartTableRow *cell)
{standartTable[name] = cell;} {standartTable[name] = cell;}
/** /**
* @brief AddIncrementTableRow add new row of increment table * @brief AddIncrementTableRow add new row of increment table
* @param name name of new row of increment table * @param name name of new row of increment table
* @param row new row of increment table * @param row new row of increment table
*/ */
inline void AddIncrementTableRow(const QString& name, const VIncrementTableRow &row) inline void AddIncrementTableRow(const QString& name, VIncrementTableRow *row)
{incrementTable[name] = row;} {incrementTable[name] = row;}
/** /**
* @brief AddLengthLine add length of line to container * @brief AddLengthLine add length of line to container
@ -196,30 +187,6 @@ public:
* @param mode mode of line * @param mode mode of line
*/ */
void AddLine(const qint64 &firstPointId, const qint64 &secondPointId); void AddLine(const qint64 &firstPointId, const qint64 &secondPointId);
/**
* @brief AddSpline add spline to container
* @param spl new spline
* @return id of spline in container
*/
qint64 AddSpline(const VSpline& spl);
/**
* @brief AddSplinePath add spline path to container
* @param splPath new spline path
* @return id of spline path in container
*/
qint64 AddSplinePath(const VSplinePath& splPath);
/**
* @brief AddArc add arc to container
* @param arc new arc
* @return id of arc in container in container
*/
qint64 AddArc(const VArc& arc);
/**
* @brief AddArcModeling add arc modeling to container
* @param arc new arc modeling
* @return id of new arc modeling in container
*/
qint64 AddArcModeling(const VArc& arc);
/** /**
* @brief GetNameLine return name of line * @brief GetNameLine return name of line
* @param firstPoint id of first point of line * @param firstPoint id of first point of line
@ -239,50 +206,26 @@ public:
* @param id id of existing point * @param id id of existing point
* @param point point * @param point point
*/ */
void UpdatePoint(qint64 id, const VPointF& point); void UpdateGObject(qint64 id, VGObject* obj);
/** /**
* @brief UpdateDetail update detail by id * @brief UpdateDetail update detail by id
* @param id id of existing detail * @param id id of existing detail
* @param detail detail * @param detail detail
*/ */
void UpdateDetail(qint64 id, const VDetail& detail); void UpdateDetail(qint64 id, VDetail *detail);
/**
* @brief UpdateSpline update spline by id
* @param id if of existing spline
* @param spl spline
*/
void UpdateSpline(qint64 id, const VSpline& spl);
/**
* @brief UpdateSplinePath update spline path by id
* @param id id of existing spline path
* @param splPath spline path
*/
void UpdateSplinePath(qint64 id, const VSplinePath& splPath);
/**
* @brief UpdateArc update arc by id
* @param id id of existing arc
* @param arc arc
*/
void UpdateArc(qint64 id, const VArc& arc);
/**
* @brief UpdateArcModeling update arc modeling by id
* @param id id of existing arc modeling
* @param arc arc modeling
*/
void UpdateArcModeling(qint64 id, const VArc& arc);
/** /**
* @brief UpdateStandartTableCell update standart table row by name * @brief UpdateStandartTableCell update standart table row by name
* @param name name of row * @param name name of row
* @param cell row of standart table * @param cell row of standart table
*/ */
inline void UpdateStandartTableCell(const QString& name, const VStandartTableRow& cell) inline void UpdateStandartTableCell(const QString& name, VStandartTableRow *cell)
{standartTable[name] = cell;} {standartTable[name] = cell;}
/** /**
* @brief UpdateIncrementTableRow update increment table row by name * @brief UpdateIncrementTableRow update increment table row by name
* @param name name of row * @param name name of row
* @param row row * @param row row
*/ */
inline void UpdateIncrementTableRow(const QString& name, const VIncrementTableRow& row) inline void UpdateIncrementTableRow(const QString& name, VIncrementTableRow *row)
{incrementTable[name] = row;} {incrementTable[name] = row;}
/** /**
* @brief GetValueStandartTableCell return value of standart table row by name * @brief GetValueStandartTableCell return value of standart table row by name
@ -368,20 +311,10 @@ public:
*/ */
inline void RemoveIncrementTableRow(const QString& name) {incrementTable.remove(name);} inline void RemoveIncrementTableRow(const QString& name) {incrementTable.remove(name);}
/** /**
* @brief data container with dataPoints return container of points * @brief data container with datagObjects return container of gObjects
* @return pointer on container of points * @return pointer on container of gObjects
*/ */
inline const QHash<qint64, VPointF> *DataPoints() const {return &points;} inline const QHash<qint64, VGObject*> *DataGObjects() const {return &gObjects;}
/**
* @brief data container with dataSplines return container of splines
* @return pointer on container of splines
*/
inline const QHash<qint64, VSpline> *DataSplines() const {return &splines;}
/**
* @brief data container with dataArcs return container of arcs
* @return pointer on container of arcs
*/
inline const QHash<qint64, VArc> *DataArcs() const {return &arcs;}
/** /**
* @brief data container with dataBase return container of data * @brief data container with dataBase return container of data
* @return pointer on container of base data * @return pointer on container of base data
@ -391,12 +324,12 @@ public:
* @brief data container with dataStandartTable return container of standart table * @brief data container with dataStandartTable return container of standart table
* @return pointer on container of standart table * @return pointer on container of standart table
*/ */
inline const QHash<QString, VStandartTableRow> *DataStandartTable() const {return &standartTable;} inline const QHash<QString, VStandartTableRow *> *DataStandartTable() const {return &standartTable;}
/** /**
* @brief data container with dataIncrementTable return container of increment table * @brief data container with dataIncrementTable return container of increment table
* @return pointer on container of increment table * @return pointer on container of increment table
*/ */
inline const QHash<QString, VIncrementTableRow> *DataIncrementTable() const {return &incrementTable;} inline const QHash<QString, VIncrementTableRow *> *DataIncrementTable() const {return &incrementTable;}
/** /**
* @brief data container with dataLengthLines return container of lines lengths * @brief data container with dataLengthLines return container of lines lengths
* @return pointer on container of lines lengths * @return pointer on container of lines lengths
@ -417,16 +350,11 @@ public:
* @return pointer on container of angles of line * @return pointer on container of angles of line
*/ */
inline const QHash<QString, qreal> *DataLineAngles() const {return &lineAngles;} inline const QHash<QString, qreal> *DataLineAngles() const {return &lineAngles;}
/**
* @brief data container with dataSplinePaths return container of spline paths
* @return pointer on container of spline paths
*/
inline const QHash<qint64, VSplinePath> *DataSplinePaths() const {return &splinePaths;}
/** /**
* @brief data container with dataDetails return container of details * @brief data container with dataDetails return container of details
* @return pointer on container of details * @return pointer on container of details
*/ */
inline const QHash<qint64, VDetail> *DataDetails() const {return &details;} inline const QHash<qint64, VDetail *> *DataDetails() const {return &details;}
/** /**
* @brief UpdateId update id. If new id bigger when current save new like current. * @brief UpdateId update id. If new id bigger when current save new like current.
* @param newId id * @param newId id
@ -498,17 +426,17 @@ private:
*/ */
QHash<QString, qint32> base; QHash<QString, qint32> base;
/** /**
* @brief points container of points * @brief gObjects graphicals objects of pattern.
*/ */
QHash<qint64, VPointF> points; QHash<qint64, VGObject*> gObjects;
/** /**
* @brief standartTable container of standart table rows * @brief standartTable container of standart table rows
*/ */
QHash<QString, VStandartTableRow> standartTable; QHash<QString, VStandartTableRow*> standartTable;
/** /**
* @brief incrementTable * @brief incrementTable
*/ */
QHash<QString, VIncrementTableRow> incrementTable; QHash<QString, VIncrementTableRow*> incrementTable;
/** /**
* @brief lengthLines container of lines lengths * @brief lengthLines container of lines lengths
*/ */
@ -517,30 +445,18 @@ private:
* @brief lineAngles container of angles of lines * @brief lineAngles container of angles of lines
*/ */
QHash<QString, qreal> lineAngles; QHash<QString, qreal> lineAngles;
/**
* @brief splines container of splines
*/
QHash<qint64, VSpline> splines;
/** /**
* @brief lengthSplines container of splines length * @brief lengthSplines container of splines length
*/ */
QHash<QString, qreal> lengthSplines; QHash<QString, qreal> lengthSplines;
/**
* @brief arcs container of arcs
*/
QHash<qint64, VArc> arcs;
/** /**
* @brief lengthArcs container of arcs length * @brief lengthArcs container of arcs length
*/ */
QHash<QString, qreal> lengthArcs; QHash<QString, qreal> lengthArcs;
/**
* @brief splinePaths container of spline paths
*/
QHash<qint64, VSplinePath> splinePaths;
/** /**
* @brief details container of details * @brief details container of details
*/ */
QHash<qint64, VDetail> details; QHash<qint64, VDetail*> details;
/** /**
* @brief CreateManTableIGroup generate man standart table of measurements * @brief CreateManTableIGroup generate man standart table of measurements
*/ */
@ -565,7 +481,15 @@ private:
* @param id id of object * @param id id of object
* @return Object * @return Object
*/ */
static val GetObject(const QHash<key, val> &obj, key id); const val *GetObject(const QHash<key, val*> &obj, key id) const;
template <typename key, typename val>
/**
* @brief GetObject return object from container
* @param obj container
* @param id id of object
* @return Object
*/
val GetVariable(const QHash<key, val> &obj, key id) const;
template <typename val> template <typename val>
/** /**
* @brief UpdateObject update object in container * @brief UpdateObject update object in container
@ -573,7 +497,7 @@ private:
* @param id id of existing object * @param id id of existing object
* @param point object * @param point object
*/ */
static void UpdateObject(QHash<qint64, val> &obj, const qint64 &id, const val& point); void UpdateObject(QHash<qint64, val *> &obj, const qint64 &id, val* point);
template <typename key, typename val> template <typename key, typename val>
/** /**
* @brief AddObject add object to container * @brief AddObject add object to container
@ -581,7 +505,7 @@ private:
* @param value object * @param value object
* @return id of object in container * @return id of object in container
*/ */
static qint64 AddObject(QHash<key, val> &obj, const val& value); static qint64 AddObject(QHash<key, val*> &obj, val *value);
}; };
#endif // VCONTAINER_H #endif // VCONTAINER_H

6
src/dialogs/dialogalongline.cpp
View file

@ -85,10 +85,10 @@ void DialogAlongLine::ChoosedObject(qint64 id, const Scene::Scenes &type)
{ {
if (type == Scene::Point) if (type == Scene::Point)
{ {
VPointF point = data->GetPoint(id); const VPointF *point = data->GeometricObject<const VPointF *>(id);
if (number == 0) if (number == 0)
{ {
qint32 index = ui->comboBoxFirstPoint->findText(point.name()); qint32 index = ui->comboBoxFirstPoint->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxFirstPoint->setCurrentIndex(index); ui->comboBoxFirstPoint->setCurrentIndex(index);
@ -99,7 +99,7 @@ void DialogAlongLine::ChoosedObject(qint64 id, const Scene::Scenes &type)
} }
if (number == 1) if (number == 1)
{ {
qint32 index = ui->comboBoxSecondPoint->findText(point.name()); qint32 index = ui->comboBoxSecondPoint->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxSecondPoint->setCurrentIndex(index); ui->comboBoxSecondPoint->setCurrentIndex(index);

4
src/dialogs/dialogarc.cpp
View file

@ -122,9 +122,9 @@ void DialogArc::ChoosedObject(qint64 id, const Scene::Scenes &type)
{ {
if (type == Scene::Point) if (type == Scene::Point)
{ {
VPointF point = data->GetPoint(id); const VPointF *point = data->GeometricObject<const VPointF *>(id);
ChangeCurrentText(ui->comboBoxBasePoint, point.name()); ChangeCurrentText(ui->comboBoxBasePoint, point->name());
emit ToolTip(""); emit ToolTip("");
this->show(); this->show();
} }

8
src/dialogs/dialogbisector.cpp
View file

@ -86,10 +86,10 @@ void DialogBisector::ChoosedObject(qint64 id, const Scene::Scenes &type)
{ {
if (type == Scene::Point) if (type == Scene::Point)
{ {
VPointF point = data->GetPoint(id); const VPointF *point = data->GeometricObject<const VPointF *>(id);
if (number == 0) if (number == 0)
{ {
qint32 index = ui->comboBoxFirstPoint->findText(point.name()); qint32 index = ui->comboBoxFirstPoint->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxFirstPoint->setCurrentIndex(index); ui->comboBoxFirstPoint->setCurrentIndex(index);
@ -100,7 +100,7 @@ void DialogBisector::ChoosedObject(qint64 id, const Scene::Scenes &type)
} }
if (number == 1) if (number == 1)
{ {
qint32 index = ui->comboBoxSecondPoint->findText(point.name()); qint32 index = ui->comboBoxSecondPoint->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxSecondPoint->setCurrentIndex(index); ui->comboBoxSecondPoint->setCurrentIndex(index);
@ -111,7 +111,7 @@ void DialogBisector::ChoosedObject(qint64 id, const Scene::Scenes &type)
} }
if (number == 2) if (number == 2)
{ {
qint32 index = ui->comboBoxThirdPoint->findText(point.name()); qint32 index = ui->comboBoxThirdPoint->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxThirdPoint->setCurrentIndex(index); ui->comboBoxThirdPoint->setCurrentIndex(index);

4
src/dialogs/dialogcutspline.cpp
View file

@ -97,8 +97,8 @@ void DialogCutSpline::ChoosedObject(qint64 id, const Scene::Scenes &type)
{ {
if (type == Scene::Spline) if (type == Scene::Spline)
{ {
VSpline spl = data->GetSpline(id); const VSpline *spl = data->GeometricObject<const VSpline *>(id);
ChangeCurrentText(ui->comboBoxSpline, spl.name()); ChangeCurrentText(ui->comboBoxSpline, spl->name());
emit ToolTip(""); emit ToolTip("");
this->show(); this->show();
} }

4
src/dialogs/dialogcutsplinepath.cpp
View file

@ -98,8 +98,8 @@ void DialogCutSplinePath::ChoosedObject(qint64 id, const Scene::Scenes &type)
{ {
if (type == Scene::SplinePath) if (type == Scene::SplinePath)
{ {
VSplinePath splPath = data->GetSplinePath(id); const VSplinePath *splPath = data->GeometricObject<const VSplinePath *>(id);
ChangeCurrentText(ui->comboBoxSplinePath, splPath.name()); ChangeCurrentText(ui->comboBoxSplinePath, splPath->name());
emit ToolTip(""); emit ToolTip("");
this->show(); this->show();
} }

16
src/dialogs/dialogdetail.cpp
View file

@ -103,26 +103,26 @@ void DialogDetail::NewItem(qint64 id, const Tool::Tools &typeTool, const NodeDet
{ {
case (Tool::NodePoint): case (Tool::NodePoint):
{ {
VPointF point = data->GetPoint(id); const VPointF *point = data->GeometricObject<const VPointF *>(id);
name = point.name(); name = point->name();
break; break;
} }
case (Tool::NodeArc): case (Tool::NodeArc):
{ {
VArc arc = data->GetArc(id); const VArc *arc = data->GeometricObject<const VArc *>(id);
name = arc.name(); name = arc->name();
break; break;
} }
case (Tool::NodeSpline): case (Tool::NodeSpline):
{ {
VSpline spl = data->GetSpline(id); const VSpline *spl = data->GeometricObject<const VSpline *>(id);
name = spl.GetName(); name = spl->name();
break; break;
} }
case (Tool::NodeSplinePath): case (Tool::NodeSplinePath):
{ {
VSplinePath splPath = data->GetSplinePath(id); const VSplinePath *splPath = data->GeometricObject<const VSplinePath *>(id);
name = splPath.name(); name = splPath->name();
break; break;
} }
default: default:

4
src/dialogs/dialogendline.cpp
View file

@ -97,8 +97,8 @@ void DialogEndLine::ChoosedObject(qint64 id, const Scene::Scenes &type)
{ {
if (type == Scene::Point) if (type == Scene::Point)
{ {
VPointF point = data->GetPoint(id); const VPointF *point = data->GeometricObject<const VPointF *>(id);
ChangeCurrentText(ui->comboBoxBasePoint, point.name()); ChangeCurrentText(ui->comboBoxBasePoint, point->name());
emit ToolTip(""); emit ToolTip("");
this->show(); this->show();
} }

8
src/dialogs/dialogheight.cpp
View file

@ -90,21 +90,21 @@ void DialogHeight::ChoosedObject(qint64 id, const Scene::Scenes &type)
{ {
if (type == Scene::Point) if (type == Scene::Point)
{ {
VPointF point = data->GetPoint(id); const VPointF *point = data->GeometricObject<const VPointF *>(id);
switch (number) switch (number)
{ {
case (0): case (0):
ChangeCurrentText(ui->comboBoxBasePoint, point.name()); ChangeCurrentText(ui->comboBoxBasePoint, point->name());
number++; number++;
emit ToolTip(tr("Select first point of line")); emit ToolTip(tr("Select first point of line"));
break; break;
case (1): case (1):
ChangeCurrentText(ui->comboBoxP1Line, point.name()); ChangeCurrentText(ui->comboBoxP1Line, point->name());
number++; number++;
emit ToolTip(tr("Select second point of line")); emit ToolTip(tr("Select second point of line"));
break; break;
case (2): case (2):
ChangeCurrentText(ui->comboBoxP2Line, point.name()); ChangeCurrentText(ui->comboBoxP2Line, point->name());
number = 0; number = 0;
emit ToolTip(tr("")); emit ToolTip(tr(""));
if (isInitialized == false) if (isInitialized == false)

138
src/dialogs/dialoghistory.cpp
View file

@ -175,53 +175,72 @@ QString DialogHistory::Record(const VToolRecord &tool)
case Tool::ArrowTool: case Tool::ArrowTool:
break; break;
case Tool::SinglePointTool: case Tool::SinglePointTool:
record = QString(tr("%1 - Base point")).arg(data->GetPoint(tool.getId()).name()); {
QString name = data->GeometricObject<const VPointF *>(tool.getId())->name();
record = QString(tr("%1 - Base point")).arg(name);
break; break;
}
case Tool::EndLineTool: case Tool::EndLineTool:
{
domElement = doc->elementById(QString().setNum(tool.getId())); domElement = doc->elementById(QString().setNum(tool.getId()));
if (domElement.isElement()) if (domElement.isElement())
{ {
basePointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrBasePoint, "0"); basePointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrBasePoint, "0");
} }
record = QString(tr("%1_%2 - Line from point %1 to point %2")).arg(data->GetPoint(basePointId).name(), QString basePointIdName = data->GeometricObject<const VPointF *>(basePointId)->name();
data->GetPoint(tool.getId()).name()); QString toolIdName = data->GeometricObject<const VPointF *>(tool.getId())->name();
record = QString(tr("%1_%2 - Line from point %1 to point %2")).arg(basePointIdName, toolIdName);
break; break;
}
case Tool::LineTool: case Tool::LineTool:
{
domElement = doc->elementById(QString().setNum(tool.getId())); domElement = doc->elementById(QString().setNum(tool.getId()));
if (domElement.isElement()) if (domElement.isElement())
{ {
firstPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrFirstPoint, "0"); firstPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrFirstPoint, "0");
secondPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrSecondPoint, "0"); secondPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrSecondPoint, "0");
} }
record = QString(tr("%1_%2 - Line from point %1 to point %2")).arg(data->GetPoint(firstPointId).name(), QString firstPointIdName = data->GeometricObject<const VPointF *>(firstPointId)->name();
data->GetPoint(secondPointId).name()); QString secondPointIdName = data->GeometricObject<const VPointF *>(secondPointId)->name();
record = QString(tr("%1_%2 - Line from point %1 to point %2")).arg(firstPointIdName, secondPointIdName);
break; break;
}
case Tool::AlongLineTool: case Tool::AlongLineTool:
{
domElement = doc->elementById(QString().setNum(tool.getId())); domElement = doc->elementById(QString().setNum(tool.getId()));
if (domElement.isElement()) if (domElement.isElement())
{ {
basePointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrFirstPoint, "0"); basePointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrFirstPoint, "0");
secondPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrSecondPoint, "0"); secondPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrSecondPoint, "0");
} }
record = QString(tr("%3 - Point along line %1_%2")).arg(data->GetPoint(basePointId).name(), QString basePointIdName = data->GeometricObject<const VPointF *>(basePointId)->name();
data->GetPoint(secondPointId).name(), QString secondPointIdName = data->GeometricObject<const VPointF *>(secondPointId)->name();
data->GetPoint(tool.getId()).name()); QString toolIdName = data->GeometricObject<const VPointF *>(tool.getId())->name();
record = QString(tr("%3 - Point along line %1_%2")).arg(basePointIdName, secondPointIdName, toolIdName);
break; break;
}
case Tool::ShoulderPointTool: case Tool::ShoulderPointTool:
record = QString(tr("%1 - Point of shoulder")).arg(data->GetPoint(tool.getId()).name()); {
QString name = data->GeometricObject<const VPointF *>(tool.getId())->name();
record = QString(tr("%1 - Point of shoulder")).arg(name);
break; break;
}
case Tool::NormalTool: case Tool::NormalTool:
{
domElement = doc->elementById(QString().setNum(tool.getId())); domElement = doc->elementById(QString().setNum(tool.getId()));
if (domElement.isElement()) if (domElement.isElement())
{ {
basePointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrFirstPoint, "0"); basePointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrFirstPoint, "0");
secondPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrSecondPoint, "0"); secondPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrSecondPoint, "0");
} }
record = QString(tr("%3 - normal to line %1_%2")).arg(data->GetPoint(basePointId).name(), QString basePointIdName = data->GeometricObject<const VPointF *>(basePointId)->name();
data->GetPoint(secondPointId).name(), QString secondPointIdName = data->GeometricObject<const VPointF *>(secondPointId)->name();
data->GetPoint(tool.getId()).name()); QString toolIdName = data->GeometricObject<const VPointF *>(tool.getId())->name();
record = QString(tr("%3 - normal to line %1_%2")).arg(basePointIdName, secondPointIdName, toolIdName);
break; break;
}
case Tool::BisectorTool: case Tool::BisectorTool:
{
domElement = doc->elementById(QString().setNum(tool.getId())); domElement = doc->elementById(QString().setNum(tool.getId()));
if (domElement.isElement()) if (domElement.isElement())
{ {
@ -229,12 +248,16 @@ QString DialogHistory::Record(const VToolRecord &tool)
secondPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrSecondPoint, "0"); secondPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrSecondPoint, "0");
thirdPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrThirdPoint, "0"); thirdPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrThirdPoint, "0");
} }
record = QString(tr("%4 - bisector of angle %1_%2_%3")).arg(data->GetPoint(firstPointId).name(), QString firstPointIdName = data->GeometricObject<const VPointF *>(firstPointId)->name();
data->GetPoint(basePointId).name(), QString basePointIdName = data->GeometricObject<const VPointF *>(basePointId)->name();
data->GetPoint(thirdPointId).name(), QString thirdPointIdName = data->GeometricObject<const VPointF *>(thirdPointId)->name();
data->GetPoint(tool.getId()).name()); QString toolIdName = data->GeometricObject<const VPointF *>(tool.getId())->name();
record = QString(tr("%4 - bisector of angle %1_%2_%3")).arg(firstPointIdName, basePointIdName,
thirdPointIdName, toolIdName);
break; break;
}
case Tool::LineIntersectTool: case Tool::LineIntersectTool:
{
domElement = doc->elementById(QString().setNum(tool.getId())); domElement = doc->elementById(QString().setNum(tool.getId()));
if (domElement.isElement()) if (domElement.isElement())
{ {
@ -243,41 +266,50 @@ QString DialogHistory::Record(const VToolRecord &tool)
p1Line2 = doc->GetParametrLongLong(domElement, VAbstractTool::AttrP1Line2, "0"); p1Line2 = doc->GetParametrLongLong(domElement, VAbstractTool::AttrP1Line2, "0");
p2Line2 = doc->GetParametrLongLong(domElement, VAbstractTool::AttrP2Line2, "0"); p2Line2 = doc->GetParametrLongLong(domElement, VAbstractTool::AttrP2Line2, "0");
} }
record = QString(tr("%5 - intersection of lines %1_%2 and %3_%4")).arg(data->GetPoint(p1Line1).name(), QString p1Line1Name = data->GeometricObject<const VPointF *>(p1Line1)->name();
data->GetPoint(p2Line1).name(), QString p2Line1Name = data->GeometricObject<const VPointF *>(p2Line1)->name();
data->GetPoint(p1Line2).name(), QString p1Line2Name = data->GeometricObject<const VPointF *>(p1Line2)->name();
data->GetPoint(p2Line2).name(), QString p2Line2Name = data->GeometricObject<const VPointF *>(p2Line2)->name();
data->GetPoint(tool.getId()).name()); QString toolIdName = data->GeometricObject<const VPointF *>(tool.getId())->name();
record = QString(tr("%5 - intersection of lines %1_%2 and %3_%4")).arg(p1Line1Name, p2Line1Name,
p1Line2Name, p2Line2Name,
toolIdName);
break; break;
}
case Tool::SplineTool: case Tool::SplineTool:
{ {
VSpline spl = data->GetSpline(tool.getId()); const VSpline *spl = data->GeometricObject<const VSpline *>(tool.getId());
record = QString(tr("Curve %1_%2")).arg(data->GetPoint(spl.GetP1()).name(), QString splP1Name = data->GeometricObject<const VSpline *>(spl->GetP1().id())->name();
data->GetPoint(spl.GetP4()).name()); QString splP4Name = data->GeometricObject<const VSpline *>(spl->GetP4().id())->name();
record = QString(tr("Curve %1_%2")).arg(splP1Name, splP4Name);
} }
break; break;
case Tool::ArcTool: case Tool::ArcTool:
{ {
VArc arc = data->GetArc(tool.getId()); const VArc *arc = data->GeometricObject<const VArc *>(tool.getId());
record = QString(tr("Arc with center in point %1")).arg(data->GetPoint(arc.GetCenter()).name()); QString arcCenterName = data->GeometricObject<const VArc *>(arc->GetCenter().id())->name();
record = QString(tr("Arc with center in point %1")).arg(arcCenterName);
} }
break; break;
case Tool::SplinePathTool: case Tool::SplinePathTool:
{ {
VSplinePath splPath = data->GetSplinePath(tool.getId()); const VSplinePath *splPath = data->GeometricObject<const VSplinePath *>(tool.getId());
QVector<VSplinePoint> points = splPath.GetSplinePath(); QVector<VSplinePoint> points = splPath->GetSplinePath();
if (points.size() != 0 ) if (points.size() != 0 )
{ {
record = QString(tr("Curve point %1")).arg(data->GetPoint(points[0].P()).name()); QString pName = data->GeometricObject<const VPointF *>(points[0].P().id())->name();
record = QString(tr("Curve point %1")).arg(pName);
for (qint32 i = 1; i< points.size(); ++i) for (qint32 i = 1; i< points.size(); ++i)
{ {
QString name = QString("_%1").arg(data->GetPoint(points[i].P()).name()); pName = data->GeometricObject<const VPointF *>(points[i].P().id())->name();
QString name = QString("_%1").arg(pName);
record.append(name); record.append(name);
} }
} }
} }
break; break;
case Tool::PointOfContact: case Tool::PointOfContact:
{
domElement = doc->elementById(QString().setNum(tool.getId())); domElement = doc->elementById(QString().setNum(tool.getId()));
if (domElement.isElement()) if (domElement.isElement())
{ {
@ -285,10 +317,14 @@ QString DialogHistory::Record(const VToolRecord &tool)
firstPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrFirstPoint, "0"); firstPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrFirstPoint, "0");
secondPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrSecondPoint, "0"); secondPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrSecondPoint, "0");
} }
QString firstPointIdName = data->GeometricObject<const VPointF *>(firstPointId)->name();
QString centerName = data->GeometricObject<const VPointF *>(center)->name();
QString secondPointIdName = data->GeometricObject<const VPointF *>(secondPointId)->name();
QString toolIdName = data->GeometricObject<const VPointF *>(tool.getId())->name();
record = QString(tr("%4 - point of contact of arc with the center in point %1 and line %2_%3")).arg( record = QString(tr("%4 - point of contact of arc with the center in point %1 and line %2_%3")).arg(
data->GetPoint(center).name(), data->GetPoint(firstPointId).name(), centerName, firstPointIdName, secondPointIdName, toolIdName);
data->GetPoint(secondPointId).name(), data->GetPoint(tool.getId()).name());
break; break;
}
case Tool::Height: case Tool::Height:
{ {
qint64 p1LineId = 0; qint64 p1LineId = 0;
@ -300,9 +336,11 @@ QString DialogHistory::Record(const VToolRecord &tool)
p1LineId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrP1Line, "0"); p1LineId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrP1Line, "0");
p2LineId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrP2Line, "0"); p2LineId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrP2Line, "0");
} }
record = QString(tr("Point of perpendicular from point %1 to line %2_%3")).arg( QString basePointIdName = data->GeometricObject<const VPointF *>(basePointId)->name();
data->GetPoint(basePointId).name(), data->GetPoint(p1LineId).name(), QString p1LineIdName = data->GeometricObject<const VPointF *>(p1LineId)->name();
data->GetPoint(p2LineId).name()); QString p2LineIdName = data->GeometricObject<const VPointF *>(p2LineId)->name();
record = QString(tr("Point of perpendicular from point %1 to line %2_%3")).arg( basePointIdName,
p1LineIdName, p2LineIdName);
break; break;
} }
case Tool::Triangle: case Tool::Triangle:
@ -317,9 +355,12 @@ QString DialogHistory::Record(const VToolRecord &tool)
firstPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrFirstPoint, "0"); firstPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrFirstPoint, "0");
secondPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrSecondPoint, "0"); secondPointId = doc->GetParametrLongLong(domElement, VAbstractTool::AttrSecondPoint, "0");
} }
record = QString(tr("Triangle: axis %1_%2, points %3 and %4")).arg( QString axisP1IdName = data->GeometricObject<const VPointF *>(axisP1Id)->name();
data->GetPoint(axisP1Id).name(), data->GetPoint(axisP2Id).name(), QString axisP2IdName = data->GeometricObject<const VPointF *>(axisP2Id)->name();
data->GetPoint(firstPointId).name(), data->GetPoint(secondPointId).name()); QString firstPointIdName = data->GeometricObject<const VPointF *>(firstPointId)->name();
QString secondPointIdName = data->GeometricObject<const VPointF *>(secondPointId)->name();
record = QString(tr("Triangle: axis %1_%2, points %3 and %4")).arg( axisP1IdName, axisP2IdName,
firstPointIdName, secondPointIdName);
break; break;
} }
case Tool::CutSplineTool: case Tool::CutSplineTool:
@ -330,10 +371,11 @@ QString DialogHistory::Record(const VToolRecord &tool)
{ {
splineId = doc->GetParametrLongLong(domElement, VToolCutSpline::AttrSpline, "0"); splineId = doc->GetParametrLongLong(domElement, VToolCutSpline::AttrSpline, "0");
} }
VSpline spl = data->GetSpline(splineId); const VSpline *spl = data->GeometricObject<const VSpline *>(splineId);
record = QString(tr("%1 - cut curve %2_%3")).arg(data->GetPoint(tool.getId()).name(), QString toolIdName = data->GeometricObject<const VPointF *>(tool.getId())->name();
data->GetPoint(spl.GetP1()).name(), QString splP1Name = data->GeometricObject<const VPointF *>(spl->GetP1().id())->name();
data->GetPoint(spl.GetP4()).name()); QString splP4Name = data->GeometricObject<const VPointF *>(spl->GetP4().id())->name();
record = QString(tr("%1 - cut curve %2_%3")).arg(toolIdName, splP1Name, splP4Name);
} }
break; break;
case Tool::CutSplinePathTool: case Tool::CutSplinePathTool:
@ -344,15 +386,17 @@ QString DialogHistory::Record(const VToolRecord &tool)
{ {
splinePathId = doc->GetParametrLongLong(domElement, VToolCutSplinePath::AttrSplinePath, "0"); splinePathId = doc->GetParametrLongLong(domElement, VToolCutSplinePath::AttrSplinePath, "0");
} }
VSplinePath splPath = data->GetSplinePath(splinePathId); const VSplinePath *splPath = data->GeometricObject<const VSplinePath *>(splinePathId);
QVector<VSplinePoint> points = splPath.GetSplinePath(); QVector<VSplinePoint> points = splPath->GetSplinePath();
if (points.size() != 0 ) if (points.size() != 0 )
{ {
record = QString(tr("%1 - cut curve point %2")).arg(data->GetPoint(tool.getId()).name(), QString toolIdName = data->GeometricObject<const VPointF *>(tool.getId())->name();
data->GetPoint(points[0].P()).name()); QString pName = data->GeometricObject<const VPointF *>(points[0].P().id())->name();
record = QString(tr("%1 - cut curve point %2")).arg(toolIdName, pName);
for (qint32 i = 1; i< points.size(); ++i) for (qint32 i = 1; i< points.size(); ++i)
{ {
QString name = QString("_%1").arg(data->GetPoint(points[i].P()).name()); pName = data->GeometricObject<const VPointF *>(points[i].P().id())->name();
QString name = QString("_%1").arg(pName);
record.append(name); record.append(name);
} }
} }

41
src/dialogs/dialogincrements.cpp
View file

@ -69,14 +69,14 @@ DialogIncrements::DialogIncrements(VContainer *data, VDomDocument *doc, QWidget
void DialogIncrements::FillStandartTable() void DialogIncrements::FillStandartTable()
{ {
const QHash<QString, VStandartTableRow> *standartTable = data->DataStandartTable(); const QHash<QString, VStandartTableRow *> *standartTable = data->DataStandartTable();
qint32 currentRow = -1; qint32 currentRow = -1;
QHashIterator<QString, VStandartTableRow> i(*standartTable); QHashIterator<QString, VStandartTableRow *> i(*standartTable);
ui->tableWidgetStandart->setRowCount ( standartTable->size() ); ui->tableWidgetStandart->setRowCount ( standartTable->size() );
while (i.hasNext()) while (i.hasNext())
{ {
i.next(); i.next();
VStandartTableRow cell = i.value(); VStandartTableRow *cell = i.value();
currentRow++; currentRow++;
QTableWidgetItem *item = new QTableWidgetItem(QString(i.key())); QTableWidgetItem *item = new QTableWidgetItem(QString(i.key()));
@ -88,19 +88,19 @@ void DialogIncrements::FillStandartTable()
item->setTextAlignment(Qt::AlignHCenter); item->setTextAlignment(Qt::AlignHCenter);
ui->tableWidgetStandart->setItem(currentRow, 1, item); ui->tableWidgetStandart->setItem(currentRow, 1, item);
item = new QTableWidgetItem(QString().setNum(cell.GetBase())); item = new QTableWidgetItem(QString().setNum(cell->GetBase()));
item->setTextAlignment(Qt::AlignHCenter); item->setTextAlignment(Qt::AlignHCenter);
ui->tableWidgetStandart->setItem(currentRow, 2, item); ui->tableWidgetStandart->setItem(currentRow, 2, item);
item = new QTableWidgetItem(QString().setNum(cell.GetKsize())); item = new QTableWidgetItem(QString().setNum(cell->GetKsize()));
item->setTextAlignment(Qt::AlignHCenter); item->setTextAlignment(Qt::AlignHCenter);
ui->tableWidgetStandart->setItem(currentRow, 3, item); ui->tableWidgetStandart->setItem(currentRow, 3, item);
item = new QTableWidgetItem(QString().setNum(cell.GetKgrowth())); item = new QTableWidgetItem(QString().setNum(cell->GetKgrowth()));
item->setTextAlignment(Qt::AlignHCenter); item->setTextAlignment(Qt::AlignHCenter);
ui->tableWidgetStandart->setItem(currentRow, 4, item); ui->tableWidgetStandart->setItem(currentRow, 4, item);
item = new QTableWidgetItem(cell.GetDescription()); item = new QTableWidgetItem(cell->GetDescription());
item->setTextAlignment(Qt::AlignHCenter); item->setTextAlignment(Qt::AlignHCenter);
ui->tableWidgetStandart->setItem(currentRow, 5, item); ui->tableWidgetStandart->setItem(currentRow, 5, item);
} }
@ -111,15 +111,15 @@ void DialogIncrements::FillStandartTable()
void DialogIncrements::FillIncrementTable() void DialogIncrements::FillIncrementTable()
{ {
const QHash<QString, VIncrementTableRow> *incrementTable = data->DataIncrementTable(); const QHash<QString, VIncrementTableRow *> *incrementTable = data->DataIncrementTable();
QHashIterator<QString, VIncrementTableRow> i(*incrementTable); QHashIterator<QString, VIncrementTableRow *> i(*incrementTable);
QMap<qint64, QString> map; QMap<qint64, QString> map;
//Sorting QHash by id //Sorting QHash by id
while (i.hasNext()) while (i.hasNext())
{ {
i.next(); i.next();
VIncrementTableRow cell = i.value(); VIncrementTableRow *cell = i.value();
map.insert(cell.getId(), i.key()); map.insert(cell->getId(), i.key());
} }
qint32 currentRow = -1; qint32 currentRow = -1;
@ -127,14 +127,14 @@ void DialogIncrements::FillIncrementTable()
while (iMap.hasNext()) while (iMap.hasNext())
{ {
iMap.next(); iMap.next();
VIncrementTableRow cell = incrementTable->value(iMap.value()); VIncrementTableRow *cell = incrementTable->value(iMap.value());
currentRow++; currentRow++;
ui->tableWidgetIncrement->setRowCount ( incrementTable->size() ); ui->tableWidgetIncrement->setRowCount ( incrementTable->size() );
QTableWidgetItem *item = new QTableWidgetItem(iMap.value()); QTableWidgetItem *item = new QTableWidgetItem(iMap.value());
item->setTextAlignment(Qt::AlignHCenter); item->setTextAlignment(Qt::AlignHCenter);
item->setFont(QFont("Times", 12, QFont::Bold)); item->setFont(QFont("Times", 12, QFont::Bold));
item->setData(Qt::UserRole, cell.getId()); item->setData(Qt::UserRole, cell->getId());
ui->tableWidgetIncrement->setItem(currentRow, 0, item); ui->tableWidgetIncrement->setItem(currentRow, 0, item);
item = new QTableWidgetItem(QString().setNum(data->GetValueIncrementTableRow(iMap.value()))); item = new QTableWidgetItem(QString().setNum(data->GetValueIncrementTableRow(iMap.value())));
@ -145,19 +145,19 @@ void DialogIncrements::FillIncrementTable()
item->setFlags(flags); item->setFlags(flags);
ui->tableWidgetIncrement->setItem(currentRow, 1, item); ui->tableWidgetIncrement->setItem(currentRow, 1, item);
item = new QTableWidgetItem(QString().setNum(cell.getBase())); item = new QTableWidgetItem(QString().setNum(cell->getBase()));
item->setTextAlignment(Qt::AlignHCenter); item->setTextAlignment(Qt::AlignHCenter);
ui->tableWidgetIncrement->setItem(currentRow, 2, item); ui->tableWidgetIncrement->setItem(currentRow, 2, item);
item = new QTableWidgetItem(QString().setNum(cell.getKsize())); item = new QTableWidgetItem(QString().setNum(cell->getKsize()));
item->setTextAlignment(Qt::AlignHCenter); item->setTextAlignment(Qt::AlignHCenter);
ui->tableWidgetIncrement->setItem(currentRow, 3, item); ui->tableWidgetIncrement->setItem(currentRow, 3, item);
item = new QTableWidgetItem(QString().setNum(cell.getKgrowth())); item = new QTableWidgetItem(QString().setNum(cell->getKgrowth()));
item->setTextAlignment(Qt::AlignHCenter); item->setTextAlignment(Qt::AlignHCenter);
ui->tableWidgetIncrement->setItem(currentRow, 4, item); ui->tableWidgetIncrement->setItem(currentRow, 4, item);
item = new QTableWidgetItem(cell.getDescription()); item = new QTableWidgetItem(cell->getDescription());
item->setTextAlignment(Qt::AlignLeft); item->setTextAlignment(Qt::AlignLeft);
ui->tableWidgetIncrement->setItem(currentRow, 5, item); ui->tableWidgetIncrement->setItem(currentRow, 5, item);
} }
@ -325,7 +325,7 @@ void DialogIncrements::clickedToolButtonAdd()
qreal ksize = 0; qreal ksize = 0;
qreal kgrowth = 0; qreal kgrowth = 0;
QString description = QString(tr("Description")); QString description = QString(tr("Description"));
VIncrementTableRow incrementRow = VIncrementTableRow(id, base, ksize, kgrowth, description); VIncrementTableRow *incrementRow = new VIncrementTableRow(id, base, ksize, kgrowth, description);
data->AddIncrementTableRow(name, incrementRow); data->AddIncrementTableRow(name, incrementRow);
AddIncrementToFile(id, name, base, ksize, kgrowth, description); AddIncrementToFile(id, name, base, ksize, kgrowth, description);
@ -499,8 +499,9 @@ void DialogIncrements::cellChanged ( qint32 row, qint32 column )
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute("description", item->text()); domElement.setAttribute("description", item->text());
VIncrementTableRow incr = data->GetIncrementTableRow(itemName->text()); VIncrementTableRow *incr = new VIncrementTableRow(*data->GetIncrementTableRow(itemName->text()));
incr.setDescription(item->text()); Q_ASSERT(incr != 0);
incr->setDescription(item->text());
data->UpdateIncrementTableRow(itemName->text(), incr); data->UpdateIncrementTableRow(itemName->text(), incr);
ui->tableWidgetIncrement->resizeColumnsToContents(); ui->tableWidgetIncrement->resizeColumnsToContents();
ui->tableWidgetIncrement->resizeRowsToContents(); ui->tableWidgetIncrement->resizeRowsToContents();

14
src/dialogs/dialogline.cpp
View file

@ -54,8 +54,8 @@ DialogLine::~DialogLine()
void DialogLine::setSecondPoint(const qint64 &value) void DialogLine::setSecondPoint(const qint64 &value)
{ {
secondPoint = value; secondPoint = value;
VPointF point = data->GetPoint(value); const VPointF *point = data->GeometricObject<const VPointF *>(value);
qint32 index = ui->comboBoxSecondPoint->findText(point.name()); qint32 index = ui->comboBoxSecondPoint->findText(point->name());
if (index != -1) if (index != -1)
{ {
ui->comboBoxSecondPoint->setCurrentIndex(index); ui->comboBoxSecondPoint->setCurrentIndex(index);
@ -65,8 +65,8 @@ void DialogLine::setSecondPoint(const qint64 &value)
void DialogLine::setFirstPoint(const qint64 &value) void DialogLine::setFirstPoint(const qint64 &value)
{ {
firstPoint = value; firstPoint = value;
VPointF point = data->GetPoint(value); const VPointF *point = data->GeometricObject<const VPointF *>(value);
qint32 index = ui->comboBoxFirstPoint->findText(point.name()); qint32 index = ui->comboBoxFirstPoint->findText(point->name());
if (index != -1) if (index != -1)
{ {
ui->comboBoxFirstPoint->setCurrentIndex(index); ui->comboBoxFirstPoint->setCurrentIndex(index);
@ -87,10 +87,10 @@ void DialogLine::ChoosedObject(qint64 id, const Scene::Scenes &type)
{ {
if (type == Scene::Point) if (type == Scene::Point)
{ {
VPointF point = data->GetPoint(id); const VPointF *point = data->GeometricObject<const VPointF *>(id);
if (number == 0) if (number == 0)
{ {
qint32 index = ui->comboBoxFirstPoint->findText(point.name()); qint32 index = ui->comboBoxFirstPoint->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxFirstPoint->setCurrentIndex(index); ui->comboBoxFirstPoint->setCurrentIndex(index);
@ -101,7 +101,7 @@ void DialogLine::ChoosedObject(qint64 id, const Scene::Scenes &type)
} }
if (number == 1) if (number == 1)
{ {
qint32 index = ui->comboBoxSecondPoint->findText(point.name()); qint32 index = ui->comboBoxSecondPoint->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxSecondPoint->setCurrentIndex(index); ui->comboBoxSecondPoint->setCurrentIndex(index);

22
src/dialogs/dialoglineintersect.cpp
View file

@ -61,10 +61,10 @@ void DialogLineIntersect::ChoosedObject(qint64 id, const Scene::Scenes &type)
{ {
if (type == Scene::Point) if (type == Scene::Point)
{ {
VPointF point = data->GetPoint(id); const VPointF *point = data->GeometricObject<const VPointF *>(id);
if (number == 0) if (number == 0)
{ {
qint32 index = ui->comboBoxP1Line1->findText(point.name()); qint32 index = ui->comboBoxP1Line1->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxP1Line1->setCurrentIndex(index); ui->comboBoxP1Line1->setCurrentIndex(index);
@ -76,7 +76,7 @@ void DialogLineIntersect::ChoosedObject(qint64 id, const Scene::Scenes &type)
} }
if (number == 1) if (number == 1)
{ {
qint32 index = ui->comboBoxP2Line1->findText(point.name()); qint32 index = ui->comboBoxP2Line1->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxP2Line1->setCurrentIndex(index); ui->comboBoxP2Line1->setCurrentIndex(index);
@ -88,7 +88,7 @@ void DialogLineIntersect::ChoosedObject(qint64 id, const Scene::Scenes &type)
} }
if (number == 2) if (number == 2)
{ {
qint32 index = ui->comboBoxP1Line2->findText(point.name()); qint32 index = ui->comboBoxP1Line2->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxP1Line2->setCurrentIndex(index); ui->comboBoxP1Line2->setCurrentIndex(index);
@ -100,7 +100,7 @@ void DialogLineIntersect::ChoosedObject(qint64 id, const Scene::Scenes &type)
} }
if (number == 3) if (number == 3)
{ {
qint32 index = ui->comboBoxP2Line2->findText(point.name()); qint32 index = ui->comboBoxP2Line2->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxP2Line2->setCurrentIndex(index); ui->comboBoxP2Line2->setCurrentIndex(index);
@ -176,13 +176,13 @@ void DialogLineIntersect::CheckState()
bool DialogLineIntersect::CheckIntersecion() bool DialogLineIntersect::CheckIntersecion()
{ {
VPointF p1L1 = data->GetPoint(p1Line1); const VPointF *p1L1 = data->GeometricObject<const VPointF *>(p1Line1);
VPointF p2L1 = data->GetPoint(p2Line1); const VPointF *p2L1 = data->GeometricObject<const VPointF *>(p2Line1);
VPointF p1L2 = data->GetPoint(p1Line2); const VPointF *p1L2 = data->GeometricObject<const VPointF *>(p1Line2);
VPointF p2L2 = data->GetPoint(p2Line2); const VPointF *p2L2 = data->GeometricObject<const VPointF *>(p2Line2);
QLineF line1(p1L1.toQPointF(), p2L1.toQPointF()); QLineF line1(p1L1->toQPointF(), p2L1->toQPointF());
QLineF line2(p1L2.toQPointF(), p2L2.toQPointF()); QLineF line2(p1L2->toQPointF(), p2L2->toQPointF());
QPointF fPoint; QPointF fPoint;
QLineF::IntersectType intersect = line1.intersect(line2, &fPoint); QLineF::IntersectType intersect = line1.intersect(line2, &fPoint);
if (intersect == QLineF::UnboundedIntersection || intersect == QLineF::BoundedIntersection) if (intersect == QLineF::UnboundedIntersection || intersect == QLineF::BoundedIntersection)

6
src/dialogs/dialognormal.cpp
View file

@ -102,10 +102,10 @@ void DialogNormal::ChoosedObject(qint64 id, const Scene::Scenes &type)
{ {
if (type == Scene::Point) if (type == Scene::Point)
{ {
VPointF point = data->GetPoint(id); const VPointF *point = data->GeometricObject<const VPointF *>(id);
if (number == 0) if (number == 0)
{ {
qint32 index = ui->comboBoxFirstPoint->findText(point.name()); qint32 index = ui->comboBoxFirstPoint->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxFirstPoint->setCurrentIndex(index); ui->comboBoxFirstPoint->setCurrentIndex(index);
@ -116,7 +116,7 @@ void DialogNormal::ChoosedObject(qint64 id, const Scene::Scenes &type)
} }
if (number == 1) if (number == 1)
{ {
qint32 index = ui->comboBoxSecondPoint->findText(point.name()); qint32 index = ui->comboBoxSecondPoint->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxSecondPoint->setCurrentIndex(index); ui->comboBoxSecondPoint->setCurrentIndex(index);

8
src/dialogs/dialogpointofcontact.cpp
View file

@ -79,10 +79,10 @@ void DialogPointOfContact::ChoosedObject(qint64 id, const Scene::Scenes &type)
{ {
if (type == Scene::Point) if (type == Scene::Point)
{ {
VPointF point = data->GetPoint(id); const VPointF *point = data->GeometricObject<const VPointF *>(id);
if (number == 0) if (number == 0)
{ {
qint32 index = ui.comboBoxFirstPoint->findText(point.name()); qint32 index = ui.comboBoxFirstPoint->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui.comboBoxFirstPoint->setCurrentIndex(index); ui.comboBoxFirstPoint->setCurrentIndex(index);
@ -93,7 +93,7 @@ void DialogPointOfContact::ChoosedObject(qint64 id, const Scene::Scenes &type)
} }
if (number == 1) if (number == 1)
{ {
qint32 index = ui.comboBoxSecondPoint->findText(point.name()); qint32 index = ui.comboBoxSecondPoint->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui.comboBoxSecondPoint->setCurrentIndex(index); ui.comboBoxSecondPoint->setCurrentIndex(index);
@ -104,7 +104,7 @@ void DialogPointOfContact::ChoosedObject(qint64 id, const Scene::Scenes &type)
} }
if (number == 2) if (number == 2)
{ {
qint32 index = ui.comboBoxCenter->findText(point.name()); qint32 index = ui.comboBoxCenter->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui.comboBoxCenter->setCurrentIndex(index); ui.comboBoxCenter->setCurrentIndex(index);

6
src/dialogs/dialogpointofintersection.cpp
View file

@ -65,10 +65,10 @@ void DialogPointOfIntersection::ChoosedObject(qint64 id, const Scene::Scenes &ty
{ {
if (type == Scene::Point) if (type == Scene::Point)
{ {
VPointF point = data->GetPoint(id); const VPointF *point = data->GeometricObject<const VPointF *>(id);
if (number == 0) if (number == 0)
{ {
qint32 index = ui->comboBoxFirstPoint->findText(point.name()); qint32 index = ui->comboBoxFirstPoint->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxFirstPoint->setCurrentIndex(index); ui->comboBoxFirstPoint->setCurrentIndex(index);
@ -79,7 +79,7 @@ void DialogPointOfIntersection::ChoosedObject(qint64 id, const Scene::Scenes &ty
} }
if (number == 1) if (number == 1)
{ {
qint32 index = ui->comboBoxSecondPoint->findText(point.name()); qint32 index = ui->comboBoxSecondPoint->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxSecondPoint->setCurrentIndex(index); ui->comboBoxSecondPoint->setCurrentIndex(index);

1
src/dialogs/dialogs.h
View file

@ -47,5 +47,6 @@
#include "dialogheight.h" #include "dialogheight.h"
#include "dialogcutspline.h" #include "dialogcutspline.h"
#include "dialogcutsplinepath.h" #include "dialogcutsplinepath.h"
#include "dialoguniondetails.h"
#endif // DIALOGS_H #endif // DIALOGS_H

8
src/dialogs/dialogshoulderpoint.cpp
View file

@ -87,10 +87,10 @@ void DialogShoulderPoint::ChoosedObject(qint64 id, const Scene::Scenes &type)
{ {
if (type == Scene::Point) if (type == Scene::Point)
{ {
VPointF point = data->GetPoint(id); const VPointF *point = data->GeometricObject<const VPointF *>(id);
if (number == 0) if (number == 0)
{ {
qint32 index = ui->comboBoxP1Line->findText(point.name()); qint32 index = ui->comboBoxP1Line->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxP1Line->setCurrentIndex(index); ui->comboBoxP1Line->setCurrentIndex(index);
@ -101,7 +101,7 @@ void DialogShoulderPoint::ChoosedObject(qint64 id, const Scene::Scenes &type)
} }
if (number == 1) if (number == 1)
{ {
qint32 index = ui->comboBoxP2Line->findText(point.name()); qint32 index = ui->comboBoxP2Line->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxP2Line->setCurrentIndex(index); ui->comboBoxP2Line->setCurrentIndex(index);
@ -112,7 +112,7 @@ void DialogShoulderPoint::ChoosedObject(qint64 id, const Scene::Scenes &type)
} }
if (number == 2) if (number == 2)
{ {
qint32 index = ui->comboBoxPShoulder->findText(point.name()); qint32 index = ui->comboBoxPShoulder->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxPShoulder->setCurrentIndex(index); ui->comboBoxPShoulder->setCurrentIndex(index);

20
src/dialogs/dialogspline.cpp
View file

@ -51,14 +51,19 @@ DialogSpline::~DialogSpline()
delete ui; delete ui;
} }
qint64 DialogSpline::getP1() const
{
return p1;
}
void DialogSpline::ChoosedObject(qint64 id, const Scene::Scenes &type) void DialogSpline::ChoosedObject(qint64 id, const Scene::Scenes &type)
{ {
if (type == Scene::Point) if (type == Scene::Point)
{ {
VPointF point = data->GetPoint(id); const VPointF *point = data->GeometricObject<const VPointF *>(id);
if (number == 0) if (number == 0)
{ {
qint32 index = ui->comboBoxP1->findText(point.name()); qint32 index = ui->comboBoxP1->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxP1->setCurrentIndex(index); ui->comboBoxP1->setCurrentIndex(index);
@ -69,7 +74,7 @@ void DialogSpline::ChoosedObject(qint64 id, const Scene::Scenes &type)
} }
if (number == 1) if (number == 1)
{ {
qint32 index = ui->comboBoxP4->findText(point.name()); qint32 index = ui->comboBoxP4->findText(point->name());
if ( index != -1 ) if ( index != -1 )
{ // -1 for not found { // -1 for not found
ui->comboBoxP4->setCurrentIndex(index); ui->comboBoxP4->setCurrentIndex(index);
@ -78,8 +83,8 @@ void DialogSpline::ChoosedObject(qint64 id, const Scene::Scenes &type)
index = ui->comboBoxP1->currentIndex(); index = ui->comboBoxP1->currentIndex();
qint64 p1Id = qvariant_cast<qint64>(ui->comboBoxP1->itemData(index)); qint64 p1Id = qvariant_cast<qint64>(ui->comboBoxP1->itemData(index));
QPointF p1 = data->GetPoint(p1Id).toQPointF(); QPointF p1 = data->GeometricObject<const VPointF *>(p1Id)->toQPointF();
QPointF p4 = data->GetPoint(id).toQPointF(); QPointF p4 = data->GeometricObject<const VPointF *>(id)->toQPointF();
ui->spinBoxAngle1->setValue(static_cast<qint32>(QLineF(p1, p4).angle())); ui->spinBoxAngle1->setValue(static_cast<qint32>(QLineF(p1, p4).angle()));
ui->spinBoxAngle2->setValue(static_cast<qint32>(QLineF(p4, p1).angle())); ui->spinBoxAngle2->setValue(static_cast<qint32>(QLineF(p4, p1).angle()));
@ -145,3 +150,8 @@ void DialogSpline::setP1(const qint64 &value)
p1 = value; p1 = value;
ChangeCurrentData(ui->comboBoxP1, value); ChangeCurrentData(ui->comboBoxP1, value);
} }
qint64 DialogSpline::getP4() const
{
return p4;
}

4
src/dialogs/dialogspline.h
View file

@ -54,7 +54,7 @@ public:
* @brief getP1 return id first point of spline * @brief getP1 return id first point of spline
* @return id * @return id
*/ */
inline qint64 getP1() const {return p1;} qint64 getP1() const;
/** /**
* @brief setP1 set id first point of spline * @brief setP1 set id first point of spline
* @param value id * @param value id
@ -64,7 +64,7 @@ public:
* @brief getP4 return id fourth point of spline * @brief getP4 return id fourth point of spline
* @return id * @return id
*/ */
inline qint64 getP4() const {return p4;} qint64 getP4() const;
/** /**
* @brief setP4 set id fourth point of spline * @brief setP4 set id fourth point of spline
* @param value id * @param value id

21
src/dialogs/dialogsplinepath.cpp
View file

@ -44,8 +44,6 @@ DialogSplinePath::DialogSplinePath(const VContainer *data, QWidget *parent)
FillComboBoxPoints(ui->comboBoxPoint); FillComboBoxPoints(ui->comboBoxPoint);
path = VSplinePath(data->DataPoints());
connect(ui->listWidget, &QListWidget::currentRowChanged, this, &DialogSplinePath::PointChenged); connect(ui->listWidget, &QListWidget::currentRowChanged, this, &DialogSplinePath::PointChenged);
connect(ui->comboBoxPoint, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), connect(ui->comboBoxPoint, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
this, &DialogSplinePath::currentPointChanged); this, &DialogSplinePath::currentPointChanged);
@ -70,7 +68,7 @@ void DialogSplinePath::SetPath(const VSplinePath &value)
ui->listWidget->clear(); ui->listWidget->clear();
for (qint32 i = 0; i < path.CountPoint(); ++i) for (qint32 i = 0; i < path.CountPoint(); ++i)
{ {
NewItem(path[i].P(), path[i].KAsm1(), path[i].Angle2(), path[i].KAsm2()); NewItem(path[i].P().id(), path[i].KAsm1(), path[i].Angle2(), path[i].KAsm2());
} }
ui->listWidget->setFocus(Qt::OtherFocusReason); ui->listWidget->setFocus(Qt::OtherFocusReason);
ui->doubleSpinBoxKcurve->setValue(path.getKCurve()); ui->doubleSpinBoxKcurve->setValue(path.getKCurve());
@ -108,7 +106,7 @@ void DialogSplinePath::PointChenged(int row)
} }
QListWidgetItem *item = ui->listWidget->item( row ); QListWidgetItem *item = ui->listWidget->item( row );
VSplinePoint p = qvariant_cast<VSplinePoint>(item->data(Qt::UserRole)); VSplinePoint p = qvariant_cast<VSplinePoint>(item->data(Qt::UserRole));
DataPoint(p.P(), p.KAsm1(), p.Angle1(), p.KAsm2(), p.Angle2()); DataPoint(p.P().id(), p.KAsm1(), p.Angle1(), p.KAsm2(), p.Angle2());
EnableFields(); EnableFields();
} }
@ -118,8 +116,9 @@ void DialogSplinePath::currentPointChanged(int index)
qint32 row = ui->listWidget->currentRow(); qint32 row = ui->listWidget->currentRow();
QListWidgetItem *item = ui->listWidget->item( row ); QListWidgetItem *item = ui->listWidget->item( row );
VSplinePoint p = qvariant_cast<VSplinePoint>(item->data(Qt::UserRole)); VSplinePoint p = qvariant_cast<VSplinePoint>(item->data(Qt::UserRole));
p.SetP(id); const VPointF *point = data->GeometricObject<const VPointF *>(id);
DataPoint(p.P(), p.KAsm1(), p.Angle1(), p.KAsm2(), p.Angle2()); p.SetP(*point);
DataPoint(p.P().id(), p.KAsm1(), p.Angle1(), p.KAsm2(), p.Angle2());
EnableFields(); EnableFields();
item->setData(Qt::UserRole, QVariant::fromValue(p)); item->setData(Qt::UserRole, QVariant::fromValue(p));
} }
@ -154,11 +153,11 @@ void DialogSplinePath::KAsm2Changed(qreal d)
void DialogSplinePath::NewItem(qint64 id, qreal kAsm1, qreal angle, qreal kAsm2) void DialogSplinePath::NewItem(qint64 id, qreal kAsm1, qreal angle, qreal kAsm2)
{ {
VPointF point = data->GetPoint(id); const VPointF *point = data->GeometricObject<const VPointF *>(id);
QListWidgetItem *item = new QListWidgetItem(point.name()); QListWidgetItem *item = new QListWidgetItem(point->name());
item->setFont(QFont("Times", 12, QFont::Bold)); item->setFont(QFont("Times", 12, QFont::Bold));
VSplinePoint p(id, kAsm1, angle, kAsm2); VSplinePoint p(*point, kAsm1, angle, kAsm2);
DataPoint(id, kAsm1, angle+180, kAsm2, angle); DataPoint(point->id(), kAsm1, angle+180, kAsm2, angle);
item->setData(Qt::UserRole, QVariant::fromValue(p)); item->setData(Qt::UserRole, QVariant::fromValue(p));
ui->listWidget->addItem(item); ui->listWidget->addItem(item);
EnableFields(); EnableFields();
@ -222,6 +221,6 @@ void DialogSplinePath::SetAngle(qint32 angle)
QListWidgetItem *item = ui->listWidget->item( row ); QListWidgetItem *item = ui->listWidget->item( row );
VSplinePoint p = qvariant_cast<VSplinePoint>(item->data(Qt::UserRole)); VSplinePoint p = qvariant_cast<VSplinePoint>(item->data(Qt::UserRole));
p.SetAngle(angle); p.SetAngle(angle);
DataPoint(p.P(), p.KAsm1(), p.Angle1(), p.KAsm2(), p.Angle2()); DataPoint(p.P().id(), p.KAsm1(), p.Angle1(), p.KAsm2(), p.Angle2());
item->setData(Qt::UserRole, QVariant::fromValue(p)); item->setData(Qt::UserRole, QVariant::fromValue(p));
} }

61
src/dialogs/dialogtool.cpp
View file

@ -28,6 +28,7 @@
#include "dialogtool.h" #include "dialogtool.h"
#include "../container/calculator.h" #include "../container/calculator.h"
#include "../geometry/vgobject.h"
#include <QtWidgets> #include <QtWidgets>
@ -66,15 +67,19 @@ void DialogTool::FillComboBoxPoints(QComboBox *box, const qint64 &id) const
{ {
Q_ASSERT(box != 0); Q_ASSERT(box != 0);
box->clear(); box->clear();
const QHash<qint64, VPointF> *points = data->DataPoints(); const QHash<qint64, VGObject*> *objs = data->DataGObjects();
QHashIterator<qint64, VPointF> i(*points); QHashIterator<qint64, VGObject*> i(*objs);
while (i.hasNext()) while (i.hasNext())
{ {
i.next(); i.next();
if (i.key() != id) if (i.key() != id)
{ {
VPointF point = i.value(); VGObject *obj = i.value();
box->addItem(point.name(), i.key()); if(obj->getType() == GObject::Point && obj->getMode() == Draw::Calculation)
{
const VPointF *point = data->GeometricObject<const VPointF *>(i.key());
box->addItem(point->name(), i.key());
}
} }
} }
} }
@ -83,8 +88,8 @@ void DialogTool::FillComboBoxSplines(QComboBox *box, const qint64 &id, ComboMode
{ {
Q_ASSERT(box != 0); Q_ASSERT(box != 0);
box->clear(); box->clear();
const QHash<qint64, VSpline> *spls = data->DataSplines(); const QHash<qint64, VGObject *> *objs = data->DataGObjects();
QHashIterator<qint64, VSpline> i(*spls); QHashIterator<qint64, VGObject*> i(*objs);
while (i.hasNext()) while (i.hasNext())
{ {
i.next(); i.next();
@ -92,16 +97,24 @@ void DialogTool::FillComboBoxSplines(QComboBox *box, const qint64 &id, ComboMode
{ {
if (i.key() != id + 1 && i.key() != id + 2) if (i.key() != id + 1 && i.key() != id + 2)
{ {
VSpline spl = i.value(); VGObject *obj = i.value();
box->addItem(spl.name(), i.key()); if(obj->getType() == GObject::Spline && obj->getMode() == Draw::Calculation)
{
const VSpline *spl = data->GeometricObject<const VSpline *>(i.key());
box->addItem(spl->name(), i.key());
}
} }
} }
else else
{ {
if (i.key() != id) if (i.key() != id)
{ {
VSpline spl = i.value(); VGObject *obj = i.value();
box->addItem(spl.name(), i.key()); if(obj->getType() == GObject::Spline && obj->getMode() == Draw::Calculation)
{
const VSpline *spl = data->GeometricObject<const VSpline *>(i.key());
box->addItem(spl->name(), i.key());
}
} }
} }
} }
@ -111,8 +124,8 @@ void DialogTool::FillComboBoxSplinesPath(QComboBox *box, const qint64 &id, Combo
{ {
Q_ASSERT(box != 0); Q_ASSERT(box != 0);
box->clear(); box->clear();
const QHash<qint64, VSplinePath> *splPaths = data->DataSplinePaths(); const QHash<qint64, VGObject *> *objs = data->DataGObjects();
QHashIterator<qint64, VSplinePath> i(*splPaths); QHashIterator<qint64, VGObject *> i(*objs);
while (i.hasNext()) while (i.hasNext())
{ {
i.next(); i.next();
@ -120,16 +133,24 @@ void DialogTool::FillComboBoxSplinesPath(QComboBox *box, const qint64 &id, Combo
{ {
if (i.key() != id + 1 && i.key() != id + 2) if (i.key() != id + 1 && i.key() != id + 2)
{ {
VSplinePath splPath = i.value(); VGObject *obj = i.value();
box->addItem(splPath.name(), i.key()); if(obj->getType() == GObject::SplinePath && obj->getMode() == Draw::Calculation)
{
const VSplinePath *splPath = data->GeometricObject<const VSplinePath *>(i.key());
box->addItem(splPath->name(), i.key());
}
} }
} }
else else
{ {
if (i.key() != id) if (i.key() != id)
{ {
VSplinePath splPath = i.value(); VGObject *obj = i.value();
box->addItem(splPath.name(), i.key()); if(obj->getType() == GObject::SplinePath && obj->getMode() == Draw::Calculation)
{
const VSplinePath *splPath = data->GeometricObject<const VSplinePath *>(i.key());
box->addItem(splPath->name(), i.key());
}
} }
} }
} }
@ -489,17 +510,17 @@ void DialogTool::ValChenged(int row)
} }
if (radioButtonStandartTable->isChecked()) if (radioButtonStandartTable->isChecked())
{ {
VStandartTableRow stable = data->GetStandartTableCell(item->text()); const VStandartTableRow *stable = data->GetStandartTableCell(item->text());
QString desc = QString("%1(%2) - %3").arg(item->text()).arg(data->GetValueStandartTableCell(item->text())) QString desc = QString("%1(%2) - %3").arg(item->text()).arg(data->GetValueStandartTableCell(item->text()))
.arg(stable.GetDescription()); .arg(stable->GetDescription());
labelDescription->setText(desc); labelDescription->setText(desc);
return; return;
} }
if (radioButtonIncrements->isChecked()) if (radioButtonIncrements->isChecked())
{ {
VIncrementTableRow itable = data->GetIncrementTableRow(item->text()); const VIncrementTableRow *itable = data->GetIncrementTableRow(item->text());
QString desc = QString("%1(%2) - %3").arg(item->text()).arg(data->GetValueIncrementTableRow(item->text())) QString desc = QString("%1(%2) - %3").arg(item->text()).arg(data->GetValueIncrementTableRow(item->text()))
.arg(itable.getDescription()); .arg(itable->getDescription());
labelDescription->setText(desc); labelDescription->setText(desc);
return; return;
} }

10
src/dialogs/dialogtriangle.cpp
View file

@ -61,26 +61,26 @@ void DialogTriangle::ChoosedObject(qint64 id, const Scene::Scenes &type)
{ {
if (type == Scene::Point) if (type == Scene::Point)
{ {
VPointF point = data->GetPoint(id); const VPointF *point = data->GeometricObject<const VPointF *>(id);
switch (number) switch (number)
{ {
case (0): case (0):
ChangeCurrentText(ui->comboBoxAxisP1, point.name()); ChangeCurrentText(ui->comboBoxAxisP1, point->name());
number++; number++;
emit ToolTip(tr("Select second point of axis")); emit ToolTip(tr("Select second point of axis"));
break; break;
case (1): case (1):
ChangeCurrentText(ui->comboBoxAxisP2, point.name()); ChangeCurrentText(ui->comboBoxAxisP2, point->name());
number++; number++;
emit ToolTip(tr("Select first point")); emit ToolTip(tr("Select first point"));
break; break;
case (2): case (2):
ChangeCurrentText(ui->comboBoxFirstPoint, point.name()); ChangeCurrentText(ui->comboBoxFirstPoint, point->name());
number++; number++;
emit ToolTip(tr("Select second point")); emit ToolTip(tr("Select second point"));
break; break;
case (3): case (3):
ChangeCurrentText(ui->comboBoxSecondPoint, point.name()); ChangeCurrentText(ui->comboBoxSecondPoint, point->name());
number = 0; number = 0;
emit ToolTip(tr("")); emit ToolTip(tr(""));
if (isInitialized == false) if (isInitialized == false)

11
src/dialogs/dialoguniondetails.cpp
View file

@ -30,7 +30,7 @@
#include "ui_dialoguniondetails.h" #include "ui_dialoguniondetails.h"
DialogUnionDetails::DialogUnionDetails(const VContainer *data, QWidget *parent) : DialogUnionDetails::DialogUnionDetails(const VContainer *data, QWidget *parent) :
DialogTool(data, parent), ui(new Ui::DialogUnionDetails), details(VDetail()), d1(0), d2(0), d1P1(0), d1P2(0), DialogTool(data, parent), ui(new Ui::DialogUnionDetails), d1(0), d2(0), d1P1(0), d1P2(0),
d2P1(0), d2P2(0), numberD(0), numberP(0) d2P1(0), d2P2(0), numberD(0), numberP(0)
{ {
ui->setupUi(this); ui->setupUi(this);
@ -59,7 +59,6 @@ void DialogUnionDetails::ChoosedObject(qint64 id, const Scene::Scenes &type)
void DialogUnionDetails::DialogAccepted() void DialogUnionDetails::DialogAccepted()
{ {
emit ToolTip("");
emit DialogClosed(QDialog::Accepted); emit DialogClosed(QDialog::Accepted);
} }
@ -69,8 +68,8 @@ bool DialogUnionDetails::CheckObject(const qint64 &id, const qint64 &idDetail) c
{ {
return false; return false;
} }
VDetail det = data->GetDetail(idDetail); const VDetail *det = data->GetDetail(idDetail);
return det.Containes(id); return det->Containes(id);
} }
void DialogUnionDetails::ChoosedDetail(const qint64 &id, const Scene::Scenes &type, qint64 &idDetail, qint64 &p1, void DialogUnionDetails::ChoosedDetail(const qint64 &id, const Scene::Scenes &type, qint64 &idDetail, qint64 &p1,
@ -99,6 +98,10 @@ void DialogUnionDetails::ChoosedDetail(const qint64 &id, const Scene::Scenes &ty
} }
if (numberP == 1) if (numberP == 1)
{ {
if(id == p1)
{
return;
}
p2 = id; p2 = id;
++numberD; ++numberD;
if(numberD > 1) if(numberD > 1)

10
src/dialogs/dialoguniondetails.h
View file

@ -41,6 +41,12 @@ class DialogUnionDetails : public DialogTool
public: public:
explicit DialogUnionDetails(const VContainer *data, QWidget *parent = 0); explicit DialogUnionDetails(const VContainer *data, QWidget *parent = 0);
~DialogUnionDetails(); ~DialogUnionDetails();
inline qint64 getD1() const {return d1;}
inline qint64 getD2() const {return d2;}
inline qint64 getD1P1() const {return d1P1;}
inline qint64 getD1P2() const {return d1P2;}
inline qint64 getD2P1() const {return d2P1;}
inline qint64 getD2P2() const {return d2P2;}
public slots: public slots:
/** /**
* @brief ChoosedObject gets id and type of selected object. Save correct data and ignore wrong. * @brief ChoosedObject gets id and type of selected object. Save correct data and ignore wrong.
@ -55,10 +61,6 @@ public slots:
private: private:
Q_DISABLE_COPY(DialogUnionDetails) Q_DISABLE_COPY(DialogUnionDetails)
Ui::DialogUnionDetails *ui; Ui::DialogUnionDetails *ui;
/**
* @brief details detail
*/
VDetail details;
qint64 d1; qint64 d1;
qint64 d2; qint64 d2;
qint64 d1P1; qint64 d1P1;

8
src/geometry/geometry.pri
View file

@ -4,7 +4,9 @@ HEADERS += \
src/geometry/vspline.h \ src/geometry/vspline.h \
src/geometry/vnodedetail.h \ src/geometry/vnodedetail.h \
src/geometry/vdetail.h \ src/geometry/vdetail.h \
src/geometry/varc.h src/geometry/varc.h \
src/geometry/vgobject.h \
src/geometry/vpointf.h
SOURCES += \ SOURCES += \
src/geometry/vsplinepoint.cpp \ src/geometry/vsplinepoint.cpp \
@ -12,4 +14,6 @@ SOURCES += \
src/geometry/vspline.cpp \ src/geometry/vspline.cpp \
src/geometry/vnodedetail.cpp \ src/geometry/vnodedetail.cpp \
src/geometry/vdetail.cpp \ src/geometry/vdetail.cpp \
src/geometry/varc.cpp src/geometry/varc.cpp \
src/geometry/vgobject.cpp \
src/geometry/vpointf.cpp

67
src/geometry/varc.cpp
View file

@ -27,33 +27,36 @@
*************************************************************************/ *************************************************************************/
#include "varc.h" #include "varc.h"
#include "vspline.h"
#include "../exception/vexception.h" #include "../exception/vexception.h"
class QRectF; class QRectF;
VArc::VArc () VArc::VArc ()
: f1(0), formulaF1(QString()), f2(0), formulaF2(QString()), radius(0), formulaRadius(QString()), :VGObject(GObject::Arc), f1(0), formulaF1(QString()), f2(0), formulaF2(QString()), radius(0),
center(0), points(QHash<qint64, VPointF>()), idObject(0), _name(QString()){} formulaRadius(QString()), center(VPointF())
VArc::VArc (const QHash<qint64, VPointF> *points, qint64 center, qreal radius, QString formulaRadius,
qreal f1, QString formulaF1, qreal f2, QString formulaF2, qint64 idObject)
: f1(f1), formulaF1(formulaF1), f2(f2), formulaF2(formulaF2), radius(radius), formulaRadius(formulaRadius),
center(center), points(*points), idObject(idObject), _name(QString())
{ {
/** }
* @todo Change name of arc in formula. Name now not unique.
*/ VArc::VArc (VPointF center, qreal radius, QString formulaRadius, qreal f1, QString formulaF1, qreal f2,
_name = QString ("Arc_%1").arg(this->GetCenterVPoint().name()); QString formulaF2, qint64 idObject, Draw::Draws mode)
: VGObject(GObject::Arc, idObject, mode), f1(f1), formulaF1(formulaF1), f2(f2), formulaF2(formulaF2), radius(radius),
formulaRadius(formulaRadius),center(center)
{
//TODO Change name of arc in formula. Name now not unique.
_name = QString ("Arc_%1").arg(this->GetCenter().name());
} }
VArc::VArc(const VArc &arc) VArc::VArc(const VArc &arc)
: f1(arc.GetF1()), formulaF1(arc.GetFormulaF1()), f2(arc.GetF2()), : VGObject(arc), f1(arc.GetF1()), formulaF1(arc.GetFormulaF1()), f2(arc.GetF2()),
formulaF2(arc.GetFormulaF2()), radius(arc.GetRadius()), formulaRadius(arc.GetFormulaRadius()), formulaF2(arc.GetFormulaF2()), radius(arc.GetRadius()), formulaRadius(arc.GetFormulaRadius()),
center(arc.GetCenter()), points(arc.GetDataPoints()), idObject(arc.getIdObject()), _name(arc.name()){} center(arc.GetCenter())
{
}
VArc &VArc::operator =(const VArc &arc) VArc &VArc::operator =(const VArc &arc)
{ {
this->points = arc.GetDataPoints(); VGObject::operator=(arc);
this->f1 = arc.GetF1(); this->f1 = arc.GetF1();
this->formulaF1 = arc.GetFormulaF1(); this->formulaF1 = arc.GetFormulaF1();
this->f2 = arc.GetF2(); this->f2 = arc.GetF2();
@ -61,55 +64,29 @@ VArc &VArc::operator =(const VArc &arc)
this->radius = arc.GetRadius(); this->radius = arc.GetRadius();
this->formulaRadius = arc.GetFormulaRadius(); this->formulaRadius = arc.GetFormulaRadius();
this->center = arc.GetCenter(); this->center = arc.GetCenter();
this->idObject = arc.getIdObject();
this->_name = arc.name();
return *this; return *this;
} }
QPointF VArc::GetCenterPoint() const
{
return GetCenterVPoint().toQPointF();
}
VPointF VArc::GetCenterVPoint() const
{
if (points.contains(center))
{
return points.value(center);
}
else
{
QString error = QString(tr("Can't find id = %1 in table.")).arg(center);
throw VException(error);
}
return VPointF();
}
QPointF VArc::GetP1() const QPointF VArc::GetP1() const
{ {
QPointF p1 ( GetCenterPoint().x () + radius, GetCenterPoint().y () ); QPointF p1 ( GetCenter().x () + radius, GetCenter().y () );
QLineF centerP1(GetCenterPoint(), p1); QLineF centerP1(GetCenter().toQPointF(), p1);
centerP1.setAngle(f1); centerP1.setAngle(f1);
return centerP1.p2(); return centerP1.p2();
} }
QPointF VArc::GetP2 () const QPointF VArc::GetP2 () const
{ {
QPointF p2 ( GetCenterPoint().x () + radius, GetCenterPoint().y () ); QPointF p2 ( GetCenter().x () + radius, GetCenter().y () );
QLineF centerP2(GetCenterPoint(), p2); QLineF centerP2(GetCenter().toQPointF(), p2);
centerP2.setAngle(f2); centerP2.setAngle(f2);
return centerP2.p2(); return centerP2.p2();
} }
const QHash<qint64, VPointF> VArc::GetDataPoints() const
{
return points;
}
QPainterPath VArc::GetPath() const QPainterPath VArc::GetPath() const
{ {
QPainterPath Path; QPainterPath Path;
QPointF center = GetCenterPoint(); QPointF center = GetCenter().toQPointF();
QRectF rect(center.x()-radius, center.y()-radius, radius*2, radius*2); QRectF rect(center.x()-radius, center.y()-radius, radius*2, radius*2);
Path.moveTo(GetP1()); Path.moveTo(GetP1());
qreal angle = QLineF(center, GetP1()).angleTo(QLineF(center, GetP2())); qreal angle = QLineF(center, GetP1()).angleTo(QLineF(center, GetP2()));

65
src/geometry/varc.h
View file

@ -29,18 +29,18 @@
#ifndef VARC_H #ifndef VARC_H
#define VARC_H #define VARC_H
#include "vspline.h" #include "vgobject.h"
#include <QCoreApplication> #include <QCoreApplication>
#include "../options.h" #include "../options.h"
#include "vpointf.h"
class QString; class QString;
class QLineF; class QLineF;
class QPainterPath; class QPainterPath;
class QPointF;
/** /**
* @brief VArc клас, що реалізує дугу. Дуга розраховується за годиниковою стрілкою. * @brief VArc клас, що реалізує дугу. Дуга розраховується за годиниковою стрілкою.
*/ */
class VArc class VArc: public VGObject
{ {
Q_DECLARE_TR_FUNCTIONS(VArc) Q_DECLARE_TR_FUNCTIONS(VArc)
public: public:
@ -55,8 +55,8 @@ public:
* @param f1 початковий кут в градусах. * @param f1 початковий кут в градусах.
* @param f2 кінцевий кут в градусах. * @param f2 кінцевий кут в градусах.
*/ */
VArc (const QHash<qint64, VPointF> *points, qint64 center, qreal radius, QString formulaRadius, VArc (VPointF center, qreal radius, QString formulaRadius, qreal f1, QString formulaF1, qreal f2,
qreal f1, QString formulaF1, qreal f2, QString formulaF2, qint64 idObject = 0); QString formulaF2, qint64 idObject = 0, Draw::Draws mode = Draw::Calculation);
/** /**
* @brief VArc * @brief VArc
* @param arc * @param arc
@ -107,32 +107,17 @@ public:
* @brief GetCenter повертає точку центра дуги. * @brief GetCenter повертає точку центра дуги.
* @return повертає точку центра дуги. * @return повертає точку центра дуги.
*/ */
inline qint64 GetCenter () const {return center;} inline VPointF GetCenter () const {return center;}
/**
* @brief GetCenterPoint
* @return
*/
QPointF GetCenterPoint() const;
/**
* @brief GetCenterVPoint
* @return
*/
VPointF GetCenterVPoint() const;
/** /**
* @brief GetP1 повертає першу точку з якої починається дуга. * @brief GetP1 повертає першу точку з якої починається дуга.
* @return точку початку дуги. * @return точку початку дуги.
*/ */
QPointF GetP1 () const; QPointF GetP1() const;
/** /**
* @brief GetP2 повертає другу точку в якій закінчується дуга. * @brief GetP2 повертає другу точку в якій закінчується дуга.
* @return точку кінця дуги. * @return точку кінця дуги.
*/ */
QPointF GetP2 () const; QPointF GetP2 () const;
/**
* @brief GetDataPoints
* @return
*/
const QHash<qint64, VPointF> GetDataPoints() const;
/** /**
* @brief GetPath будує шлях по даній дузі. * @brief GetPath будує шлях по даній дузі.
* @return повертає шлях. * @return повертає шлях.
@ -158,27 +143,7 @@ public:
* @param number * @param number
* @return * @return
*/ */
QVector<QPointF> SplOfArc( qint32 number ) const; QVector<QPointF> SplOfArc( qint32 number ) const;
/**
* @brief getIdObject
* @return
*/
inline qint64 getIdObject() const {return idObject;}
/**
* @brief setIdObject
* @param value
*/
inline void setIdObject(const qint64 &value) {idObject = value;}
/**
* @brief name
* @return
*/
QString name() const {return _name;}
/**
* @brief setName
* @param name
*/
void setName(const QString &name) {_name = name;}
private: private:
/** /**
* @brief f1 початковий кут в градусах * @brief f1 початковий кут в градусах
@ -207,19 +172,7 @@ private:
/** /**
* @brief center центральна точка дуги. * @brief center центральна точка дуги.
*/ */
qint64 center; VPointF center;
/**
* @brief points
*/
QHash<qint64, VPointF> points;
/**
* @brief idObject
*/
qint64 idObject;
/**
* @brief _name
*/
QString _name;
}; };
#endif // VARC_H #endif // VARC_H

36
src/geometry/vdetail.cpp
View file

@ -29,16 +29,16 @@
#include "vdetail.h" #include "vdetail.h"
VDetail::VDetail() VDetail::VDetail()
:nodes(QVector<VNodeDetail>()), name(QString()), mx(0), my(0), supplement(true), closed(true), width(10){} :_id(0), nodes(QVector<VNodeDetail>()), name(QString()), mx(0), my(0), supplement(true), closed(true), width(10){}
VDetail::VDetail(const QString &name, const QVector<VNodeDetail> &nodes) VDetail::VDetail(const QString &name, const QVector<VNodeDetail> &nodes)
:nodes(QVector<VNodeDetail>()), name(name), mx(0), my(0), supplement(true), closed(true), width(10) :_id(0), nodes(QVector<VNodeDetail>()), name(name), mx(0), my(0), supplement(true), closed(true), width(10)
{ {
this->nodes = nodes; this->nodes = nodes;
} }
VDetail::VDetail(const VDetail &detail) VDetail::VDetail(const VDetail &detail)
:nodes(detail.getNodes()), name(detail.getName()), mx(detail.getMx()), my(detail.getMy()), :_id(0), nodes(detail.getNodes()), name(detail.getName()), mx(detail.getMx()), my(detail.getMy()),
supplement(detail.getSupplement()), closed(detail.getClosed()), width(detail.getWidth()){} supplement(detail.getSupplement()), closed(detail.getClosed()), width(detail.getWidth()){}
VDetail &VDetail::operator =(const VDetail &detail) VDetail &VDetail::operator =(const VDetail &detail)
@ -66,7 +66,7 @@ void VDetail::Clear()
bool VDetail::Containes(const qint64 &id) const bool VDetail::Containes(const qint64 &id) const
{ {
for (qint32 i = 0; i < nodes.size(); ++i) for (ptrdiff_t i = 0; i < nodes.size(); ++i)
{ {
VNodeDetail node = nodes[i]; VNodeDetail node = nodes[i];
if (node.getId() == id) if (node.getId() == id)
@ -81,3 +81,31 @@ VNodeDetail &VDetail::operator [](ptrdiff_t indx)
{ {
return nodes[indx]; return nodes[indx];
} }
const VNodeDetail &VDetail::at(ptrdiff_t indx) const
{
return nodes[indx];
}
ptrdiff_t VDetail::indexOfNode(const qint64 &id) const
{
for (ptrdiff_t i = 0; i < nodes.size(); ++i)
{
VNodeDetail node = nodes[i];
if (node.getId() == id)
{
return i;
}
}
return -1;
}
qint64 VDetail::id() const
{
return _id;
}
void VDetail::setId(const qint64 &id)
{
_id = id;
}

6
src/geometry/vdetail.h
View file

@ -104,6 +104,7 @@ public:
* @return * @return
*/ */
VNodeDetail & operator[](ptrdiff_t indx); VNodeDetail & operator[](ptrdiff_t indx);
const VNodeDetail & at ( ptrdiff_t indx ) const;
/** /**
* @brief getName * @brief getName
* @return * @return
@ -174,7 +175,12 @@ public:
* @param value * @param value
*/ */
inline void setNodes(const QVector<VNodeDetail> &value) {nodes = value;} inline void setNodes(const QVector<VNodeDetail> &value) {nodes = value;}
ptrdiff_t indexOfNode(const qint64 &id) const;
qint64 id() const;
void setId(const qint64 &id);
private: private:
qint64 _id;
/** /**
* @brief nodes * @brief nodes
*/ */

99
src/geometry/vgobject.cpp Normal file
View file

@ -0,0 +1,99 @@
/************************************************************************
**
** @file vgobject.cpp
** @author Roman Telezhinsky <dismine@gmail.com>
** @date 27 12, 2013
**
** @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) 2013 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 "vgobject.h"
VGObject::VGObject()
:_id(0), type(GObject::Point), idObject(0), _name(QString()), mode(Draw::Calculation)
{
}
VGObject::VGObject(const GObject::Type &type, const qint64 &idObject, const Draw::Draws &mode)
:_id(0), type(type), idObject(idObject), _name(QString()), mode(mode)
{
}
VGObject::VGObject(const VGObject &obj)
:_id(obj.id()), type(obj.getType()), idObject(obj.getIdObject()), _name(obj.name()), mode(obj.getMode())
{
}
VGObject &VGObject::operator=(const VGObject &obj)
{
this->_id = obj.id();
this->type = obj.getType();
this->idObject = obj.getIdObject();
this->_name = obj.name();
this->mode = obj.getMode();
return *this;
}
qint64 VGObject::getIdObject() const
{
return idObject;
}
void VGObject::setIdObject(const qint64 &value)
{
idObject = value;
}
QString VGObject::name() const
{
return _name;
}
void VGObject::setName(const QString &name)
{
_name = name;
}
Draw::Draws VGObject::getMode() const
{
return mode;
}
void VGObject::setMode(const Draw::Draws &value)
{
mode = value;
}
GObject::Type VGObject::getType() const
{
return type;
}
qint64 VGObject::id() const
{
return _id;
}
void VGObject::setId(const qint64 &id)
{
_id = id;
}

89
src/geometry/vgobject.h Normal file
View file

@ -0,0 +1,89 @@
/************************************************************************
**
** @file vgobject.h
** @author Roman Telezhinsky <dismine@gmail.com>
** @date 27 12, 2013
**
** @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) 2013 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 VGOBJECT_H
#define VGOBJECT_H
#include "../options.h"
#include "../exception/vexception.h"
#include <QCoreApplication>
#include <QHash>
namespace GObject
{
/**
* @brief The NodeDetail enum
*/
enum Type { Point, Arc, Spline, SplinePath };
Q_DECLARE_FLAGS(Types, Type)
}
Q_DECLARE_OPERATORS_FOR_FLAGS(GObject::Types)
class VGObject
{
Q_DECLARE_TR_FUNCTIONS(VGObject)
public:
VGObject();
VGObject(const GObject::Type &type, const qint64 &idObject = 0, const Draw::Draws &mode = Draw::Calculation);
VGObject(const VGObject &obj);
VGObject& operator= (const VGObject &obj);
virtual ~VGObject(){}
qint64 getIdObject() const;
void setIdObject(const qint64 &value);
virtual QString name() const;
void setName(const QString &name);
Draw::Draws getMode() const;
void setMode(const Draw::Draws &value);
GObject::Type getType() const;
qint64 id() const;
void setId(const qint64 &id);
protected:
/**
* @brief _id id in container. Ned for arcs, spline and spline paths.
*/
qint64 _id;
/**
* @brief type type of graphical object
*/
GObject::Type type;
/**
* @brief idObject id of parent object. Only for modeling. All another return 0.
*/
qint64 idObject;
/**
* @brief _name object name
*/
QString _name;
/**
* @brief mode object created in calculation or drawing mode
*/
Draw::Draws mode;
};
#endif // VGOBJECT_H

9
src/container/vpointf.cpp → src/geometry/vpointf.cpp
View file

@ -28,13 +28,18 @@
#include "vpointf.h" #include "vpointf.h"
VPointF::VPointF(qreal x, qreal y, QString name, qreal mx, qreal my, qint64 idObject, Draw::Draws mode)
:VGObject(GObject::Point, idObject, mode), _mx(mx), _my(my), _x(x), _y(y)
{
this->_name = name;
}
VPointF &VPointF::operator =(const VPointF &point) VPointF &VPointF::operator =(const VPointF &point)
{ {
_name = point.name(); VGObject::operator=(point);
_mx = point.mx(); _mx = point.mx();
_my = point.my(); _my = point.my();
_x = point.x(); _x = point.x();
_y = point.y(); _y = point.y();
idObject = point.getIdObject();
return *this; return *this;
} }

44
src/container/vpointf.h → src/geometry/vpointf.h
View file

@ -32,36 +32,36 @@
#include <QPointF> #include <QPointF>
#include <QString> #include <QString>
#include "../options.h" #include "../options.h"
#include "vgobject.h"
/** /**
* @brief The VPointF class keep data of point. * @brief The VPointF class keep data of point.
*/ */
class VPointF class VPointF:public VGObject
{ {
public: public:
/** /**
* @brief VPointF creat empty point * @brief VPointF creat empty point
*/ */
inline VPointF () inline VPointF ()
:_name(QString()), _mx(0), _my(0), _x(0), _y(0), idObject(0){} :VGObject(GObject::Point, 0, Draw::Calculation), _mx(0), _my(0), _x(0), _y(0){}
/** /**
* @brief VPointF copy constructor * @brief VPointF copy constructor
* @param point * @param point
*/ */
inline VPointF (const VPointF &point ) inline VPointF (const VPointF &point )
:_name(point.name()), _mx(point.mx()), _my(point.my()), _x(point.x()), _y(point.y()), :VGObject(point), _mx(point.mx()), _my(point.my()), _x(point.x()), _y(point.y()){}
idObject(point.getIdObject()){} inline VPointF (const QPointF &point )
:VGObject(VPointF()), _mx(0), _my(0), _x(point.x()), _y(point.y()){}
/** /**
* @brief VPointF create new point * @brief VPointF create new point
* @param x x coordinate * @param x x coordinate
* @param y y coordinate * @param y y coordinate
* @param name name of point
* @param mx offset name respect to x * @param mx offset name respect to x
* @param my offset name respect to y * @param my offset name respect to y
* @param idObject point modeling keep here id of parent point
*/ */
inline VPointF ( qreal x, qreal y, QString name, qreal mx, qreal my, qint64 idObject = 0) VPointF ( qreal x, qreal y, QString name, qreal mx, qreal my, qint64 idObject = 0,
:_name(name), _mx(mx), _my(my), _x(x), _y(y), idObject(idObject){} Draw::Draws mode = Draw::Calculation);
/** /**
* @brief operator = assignment operator * @brief operator = assignment operator
* @param point point * @param point point
@ -69,11 +69,6 @@ public:
*/ */
VPointF &operator=(const VPointF &point); VPointF &operator=(const VPointF &point);
~VPointF(){} ~VPointF(){}
/**
* @brief name return name of point
* @return name
*/
inline QString name() const { return _name;}
/** /**
* @brief mx return offset name respect to x * @brief mx return offset name respect to x
* @return offset * @return offset
@ -84,11 +79,6 @@ public:
* @return offset * @return offset
*/ */
inline qreal my() const {return _my;} inline qreal my() const {return _my;}
/**
* @brief setName set name of point
* @param name name
*/
inline void setName(const QString &name) {_name = name;}
/** /**
* @brief setMx set offset name respect to x * @brief setMx set offset name respect to x
* @param mx offset * @param mx offset
@ -124,21 +114,7 @@ public:
* @param value y coordinate * @param value y coordinate
*/ */
inline void setY(const qreal &value){_y = value;} inline void setY(const qreal &value){_y = value;}
/**
* @brief getIdObject return id of parrent.
* @return id
*/
inline qint64 getIdObject() const {return idObject;}
/**
* @brief setIdObject set id of parent
* @param value id
*/
inline void setIdObject(const qint64 &value) {idObject = value;}
private: private:
/**
* @brief _name name of point
*/
QString _name;
/** /**
* @brief _mx offset name respect to x * @brief _mx offset name respect to x
*/ */
@ -155,10 +131,6 @@ private:
* @brief _y y coordinate * @brief _y y coordinate
*/ */
qreal _y; qreal _y;
/**
* @brief idObject id of parent. Only for point modeling. All another return 0.
*/
qint64 idObject;
}; };
#endif // VPOINTF_H #endif // VPOINTF_H

330
src/geometry/vspline.cpp
View file

@ -31,34 +31,21 @@
#include <QDebug> #include <QDebug>
VSpline::VSpline() VSpline::VSpline()
:p1(0), p2(QPointF()), p3(QPointF()), p4(0), angle1(0), angle2(0), kAsm1(1), kAsm2(1), kCurve(1), :VGObject(GObject::Spline), p1(VPointF()), p2(QPointF()), p3(QPointF()), p4(VPointF()), angle1(0), angle2(0),
points(QHash<qint64, VPointF>()), idObject(0), _name(QString()){} kAsm1(1), kAsm2(1), kCurve(1){}
VSpline::VSpline ( const VSpline & spline ) VSpline::VSpline ( const VSpline & spline )
:p1(spline.GetP1 ()), p2(spline.GetP2 ()), p3(spline.GetP3 ()), p4(spline.GetP4 ()), angle1(spline.GetAngle1 ()), :VGObject(spline), p1(spline.GetP1 ()), p2(spline.GetP2 ()), p3(spline.GetP3 ()), p4(spline.GetP4 ()),
angle2(spline.GetAngle2 ()), kAsm1(spline.GetKasm1()), kAsm2(spline.GetKasm2()), kCurve(spline.GetKcurve()), angle1(spline.GetAngle1 ()), angle2(spline.GetAngle2 ()), kAsm1(spline.GetKasm1()), kAsm2(spline.GetKasm2()),
points(spline.GetDataPoints()), idObject(spline.getIdObject()), _name(spline.name()){} kCurve(spline.GetKcurve()){}
VSpline::VSpline (const QHash<qint64, VPointF> *points, qint64 p1, qint64 p4, qreal angle1, qreal angle2, VSpline::VSpline (VPointF p1, VPointF p4, qreal angle1, qreal angle2, qreal kAsm1, qreal kAsm2, qreal kCurve,
qreal kAsm1, qreal kAsm2, qreal kCurve, qint64 idObject) qint64 idObject, Draw::Draws mode)
:p1(p1), p2(QPointF()), p3(QPointF()), p4(p4), angle1(angle1), angle2(angle2), kAsm1(kAsm1), kAsm2(kAsm2), :VGObject(GObject::Spline, idObject, mode), p1(p1), p2(QPointF()), p3(QPointF()), p4(p4), angle1(angle1),
kCurve(kCurve), points(*points), idObject(idObject), _name(QString()) angle2(angle2), kAsm1(kAsm1), kAsm2(kAsm2), kCurve(kCurve)
{ {
_name = QString("Spl_%1_%2").arg(this->GetPointP1().name(), this->GetPointP4().name()); CreateName();
ModifiSpl ( p1, p4, angle1, angle2, kAsm1, kAsm2, kCurve );
}
VSpline::VSpline (const QHash<qint64, VPointF> *points, qint64 p1, QPointF p2, QPointF p3, qint64 p4,
qreal kCurve, qint64 idObject)
:p1(p1), p2(p2), p3(p3), p4(p4), angle1(0), angle2(0), kAsm1(1), kAsm2(1), kCurve(1), points(*points),
idObject(idObject), _name(QString())
{
_name = QString("Spl_%1_%2").arg(this->GetPointP1().name(), this->GetPointP4().name());
ModifiSpl ( p1, p2, p3, p4, kCurve);
}
void VSpline::ModifiSpl ( qint64 p1, qint64 p4, qreal angle1, qreal angle2, qreal kAsm1, qreal kAsm2, qreal kCurve)
{
this->p1 = p1; this->p1 = p1;
this->p4 = p4; this->p4 = p4;
this->angle1 = angle1; this->angle1 = angle1;
@ -66,130 +53,80 @@ void VSpline::ModifiSpl ( qint64 p1, qint64 p4, qreal angle1, qreal angle2, qrea
this->kAsm1 = kAsm1; this->kAsm1 = kAsm1;
this->kAsm2 = kAsm2; this->kAsm2 = kAsm2;
this->kCurve = kCurve; this->kCurve = kCurve;
QLineF p1pX(GetPointP1().x(), GetPointP1().y(), GetPointP1().x() + 100, GetPointP1().y()); QLineF p1pX(GetP1().x(), GetP1().y(), GetP1().x() + 100, GetP1().y());
p1pX.setAngle( angle1 ); p1pX.setAngle( angle1 );
qreal L = 0, radius = 0, angle = 90; qreal L = 0, radius = 0, angle = 90;
// angle = QLineF(GetPointP1(), p1pX.p2()).angleTo(QLineF(GetPointP1(), GetPointP4())); // angle = QLineF(GetPointP1(), p1pX.p2()).angleTo(QLineF(GetPointP1(), GetPointP4()));
// if ( angle > 180 ){ // if ( angle > 180 ){
// angle = 360 - angle; // angle = 360 - angle;
// } // }
QPointF point1 = GetPointP1().toQPointF(); QPointF point1 = GetP1().toQPointF();
QPointF point4 = GetPointP4().toQPointF(); QPointF point4 = GetP4().toQPointF();
radius = QLineF(QPointF(point1.x(), point4.y()), point4).length(); radius = QLineF(QPointF(point1.x(), point4.y()), point4).length();
// radius = QLineF(GetPointP1(), GetPointP4()).length() / 2 / sin( angle * M_PI / 180.0 ); // radius = QLineF(GetPointP1(), GetPointP4()).length() / 2 / sin( angle * M_PI / 180.0 );
L = kCurve * radius * 4 / 3 * tan( angle * M_PI / 180.0 / 4 ); L = kCurve * radius * 4 / 3 * tan( angle * M_PI / 180.0 / 4 );
QLineF p1p2(GetPointP1().x(), GetPointP1().y(), GetPointP1().x() + L * kAsm1, GetPointP1().y()); QLineF p1p2(GetP1().x(), GetP1().y(), GetP1().x() + L * kAsm1, GetP1().y());
p1p2.setAngle(angle1); p1p2.setAngle(angle1);
QLineF p4p3(GetPointP4().x(), GetPointP4().y(), GetPointP4().x() + L * kAsm2, GetPointP4().y()); QLineF p4p3(GetP4().x(), GetP4().y(), GetP4().x() + L * kAsm2, GetP4().y());
p4p3.setAngle(angle2); p4p3.setAngle(angle2);
this->p2 = p1p2.p2(); this->p2 = p1p2.p2();
this->p3 = p4p3.p2(); this->p3 = p4p3.p2();
} }
void VSpline::ModifiSpl (const qint64 &p1, const QPointF &p2, const QPointF &p3, const qint64 &p4, const qreal &kCurve) VSpline::VSpline (VPointF p1, QPointF p2, QPointF p3, VPointF p4, qreal kCurve, qint64 idObject, Draw::Draws mode)
:VGObject(GObject::Spline, idObject, mode), p1(p1), p2(p2), p3(p3), p4(p4), angle1(0), angle2(0), kAsm1(1), kAsm2(1),
kCurve(1)
{ {
CreateName();
this->p1 = p1; this->p1 = p1;
this->p2 = p2; this->p2 = p2;
this->p3 = p3; this->p3 = p3;
this->p4 = p4; this->p4 = p4;
this->angle1 = QLineF ( GetPointP1().toQPointF(), p2 ).angle(); this->angle1 = QLineF ( GetP1().toQPointF(), p2 ).angle();
this->angle2 = QLineF ( GetPointP4().toQPointF(), p3 ).angle(); this->angle2 = QLineF ( GetP4().toQPointF(), p3 ).angle();
QLineF p1pX(GetPointP1().x(), GetPointP1().y(), GetPointP1().x() + 100, GetPointP1().y()); QLineF p1pX(GetP1().x(), GetP1().y(), GetP1().x() + 100, GetP1().y());
p1pX.setAngle( angle1 ); p1pX.setAngle( angle1 );
qreal L = 0, radius = 0, angle = 90; qreal L = 0, radius = 0, angle = 90;
// angle = QLineF(GetPointP1(), p1pX.p2()).angleTo(QLineF(GetPointP1(), GetPointP4())); // angle = QLineF(GetPointP1(), p1pX.p2()).angleTo(QLineF(GetPointP1(), GetPointP4()));
// if ( angle >= 180 ){ // if ( angle >= 180 ){
// angle = 360 - angle; // angle = 360 - angle;
// } // }
QPointF point1 = GetPointP1().toQPointF(); QPointF point1 = GetP1().toQPointF();
QPointF point4 = GetPointP4().toQPointF(); QPointF point4 = GetP4().toQPointF();
radius = QLineF(QPointF(point1.x(), point4.y()), point4).length(); radius = QLineF(QPointF(point1.x(), point4.y()), point4).length();
// radius = QLineF(GetPointP1(), GetPointP4()).length() / 2 / sin( angle * M_PI / 180.0 ); // radius = QLineF(GetPointP1(), GetPointP4()).length() / 2 / sin( angle * M_PI / 180.0 );
L = kCurve * radius * 4 / 3 * tan( angle * M_PI / 180.0 / 4 ); L = kCurve * radius * 4 / 3 * tan( angle * M_PI / 180.0 / 4 );
this->kCurve = kCurve; this->kCurve = kCurve;
this->kAsm1 = QLineF ( GetPointP1().toQPointF(), p2 ).length()/L; this->kAsm1 = QLineF ( GetP1().toQPointF(), p2 ).length()/L;
this->kAsm2 = QLineF ( GetPointP4().toQPointF(), p3 ).length()/L; this->kAsm2 = QLineF ( GetP4().toQPointF(), p3 ).length()/L;
}
//void VSpline::RotationSpl (QPointF pRotate, qreal angle ){
// QLineF pRotateP1 (pRotate, p1);
// pRotateP1.setAngle(angle);
// p1 = pRotateP1.p2();
// QLineF pRotateP2 (pRotate, p2);
// pRotateP2.setAngle(angle);
// p2 = pRotateP2.p2();
// QLineF pRotateP3 (pRotate, p3);
// pRotateP3.setAngle(angle);
// p3 = pRotateP3.p2();
// QLineF pRotateP4 (pRotate, p4);
// pRotateP4.setAngle(angle);
// p4 = pRotateP4.p2();
// angle1 = QLineF(p1, p2).angle();
// angle2 = QLineF(p4, p2).angle();
//}
//void VSpline::BiasSpl ( qreal mx, qreal my ){
// p1 = QPointF(p1.x()+mx, p1.y()+my);
// p2 = QPointF(p2.x()+mx, p2.y()+my);
// p3 = QPointF(p3.x()+mx, p3.y()+my);
// p4 = QPointF(p4.x()+mx, p4.y()+my);
//}
VPointF VSpline::GetPointP1() const
{
if (points.contains(p1))
{
return points.value(p1);
}
else
{
qCritical()<<"Не можу знайти id = "<<p1<<" в таблиці.";
throw "Не можу знайти точку за id.";
}
return VPointF();
}
VPointF VSpline::GetPointP4() const
{
if (points.contains(p4))
{
return points.value(p4);
}
else
{
qCritical()<<"Не можу знайти id = "<<p4<<" в таблиці.";
throw "Не можу знайти точку за id.";
}
return VPointF();
} }
qreal VSpline::GetLength () const qreal VSpline::GetLength () const
{ {
return LengthBezier ( GetPointP1().toQPointF(), this->p2, this->p3, GetPointP4().toQPointF()); return LengthBezier ( GetP1().toQPointF(), this->p2, this->p3, GetP4().toQPointF());
} }
QString VSpline::GetName() const QString VSpline::name() const
{ {
VPointF first = GetPointP1(); return _name;
VPointF second = GetPointP4();
return QString("Spl_%1_%2").arg(first.name(), second.name());
} }
QLineF::IntersectType VSpline::CrossingSplLine ( const QLineF &line, QPointF *intersectionPoint ) const QLineF::IntersectType VSpline::CrossingSplLine ( const QLineF &line, QPointF *intersectionPoint ) const
{ {
QVector<qreal> px; QVector<qreal> px;
QVector<qreal> py; QVector<qreal> py;
px.append ( GetPointP1 ().x () ); px.append ( GetP1 ().x () );
py.append ( GetPointP1 ().y () ); py.append ( GetP1 ().y () );
QVector<qreal>& wpx = px; QVector<qreal>& wpx = px;
QVector<qreal>& wpy = py; QVector<qreal>& wpy = py;
PointBezier_r ( GetPointP1 ().x (), GetPointP1 ().y (), GetP2 ().x (), GetP2 ().y (), PointBezier_r ( GetP1 ().x (), GetP1 ().y (), GetP2 ().x (), GetP2 ().y (),
GetP3 ().x (), GetP3 ().y (), GetPointP4 ().x (), GetPointP4 ().y (), GetP3 ().x (), GetP3 ().y (), GetP4 ().x (), GetP4 ().y (),
0, wpx, wpy); 0, wpx, wpy);
px.append ( GetPointP4 ().x () ); px.append ( GetP4 ().x () );
py.append ( GetPointP4 ().y () ); py.append ( GetP4 ().y () );
qint32 i = 0; qint32 i = 0;
QPointF crosPoint; QPointF crosPoint;
QLineF::IntersectType type = QLineF::NoIntersection; QLineF::IntersectType type = QLineF::NoIntersection;
@ -213,7 +150,7 @@ qreal VSpline::LengthT(qreal t) const
qWarning()<<"Wrong value t."; qWarning()<<"Wrong value t.";
return 0; return 0;
} }
QLineF seg1_2 ( GetPointP1 ().toQPointF(), GetP2 () ); QLineF seg1_2 ( GetP1 ().toQPointF(), GetP2 () );
seg1_2.setLength(seg1_2.length () * t); seg1_2.setLength(seg1_2.length () * t);
QPointF p12 = seg1_2.p2(); QPointF p12 = seg1_2.p2();
@ -225,7 +162,7 @@ qreal VSpline::LengthT(qreal t) const
seg12_23.setLength(seg12_23.length () * t); seg12_23.setLength(seg12_23.length () * t);
QPointF p123 = seg12_23.p2(); QPointF p123 = seg12_23.p2();
QLineF seg3_4 ( GetP3 (), GetPointP4 ().toQPointF() ); QLineF seg3_4 ( GetP3 (), GetP4 ().toQPointF() );
seg3_4.setLength(seg3_4.length () * t); seg3_4.setLength(seg3_4.length () * t);
QPointF p34 = seg3_4.p2(); QPointF p34 = seg3_4.p2();
@ -237,7 +174,7 @@ qreal VSpline::LengthT(qreal t) const
seg123_234.setLength(seg123_234.length () * t); seg123_234.setLength(seg123_234.length () * t);
QPointF p1234 = seg123_234.p2(); QPointF p1234 = seg123_234.p2();
return LengthBezier ( GetPointP1().toQPointF(), p12, p123, p1234); return LengthBezier ( GetP1().toQPointF(), p12, p123, p1234);
} }
QPointF VSpline::CutSpline ( qreal length, QPointF &spl1p2, QPointF &spl1p3, QPointF &spl2p2, QPointF &spl2p3 ) const QPointF VSpline::CutSpline ( qreal length, QPointF &spl1p2, QPointF &spl1p3, QPointF &spl2p2, QPointF &spl2p3 ) const
@ -267,7 +204,7 @@ QPointF VSpline::CutSpline ( qreal length, QPointF &spl1p2, QPointF &spl1p3, QPo
} }
} }
QLineF seg1_2 ( GetPointP1 ().toQPointF(), GetP2 () ); QLineF seg1_2 ( GetP1 ().toQPointF(), GetP2 () );
seg1_2.setLength(seg1_2.length () * parT); seg1_2.setLength(seg1_2.length () * parT);
QPointF p12 = seg1_2.p2(); QPointF p12 = seg1_2.p2();
@ -279,7 +216,7 @@ QPointF VSpline::CutSpline ( qreal length, QPointF &spl1p2, QPointF &spl1p3, QPo
seg12_23.setLength(seg12_23.length () * parT); seg12_23.setLength(seg12_23.length () * parT);
QPointF p123 = seg12_23.p2(); QPointF p123 = seg12_23.p2();
QLineF seg3_4 ( GetP3 (), GetPointP4 ().toQPointF() ); QLineF seg3_4 ( GetP3 (), GetP4 ().toQPointF() );
seg3_4.setLength(seg3_4.length () * parT); seg3_4.setLength(seg3_4.length () * parT);
QPointF p34 = seg3_4.p2(); QPointF p34 = seg3_4.p2();
@ -298,59 +235,9 @@ QPointF VSpline::CutSpline ( qreal length, QPointF &spl1p2, QPointF &spl1p3, QPo
return p1234; return p1234;
} }
//void VSpline::CutSpline ( QPointF point, VSpline* curFir, VSpline* curSec ) const{
// qreal t = param_t (point);
// qreal length = t*this->GetLength();
// CutSpline ( length, curFir, curSec );
//}
//void VSpline::PutAlongSpl (QPointF &moveP, qreal move ) const{
// if ( GetLength () < move ){
// qDebug()<<"Довжина більше довжини сплайну.";
// qDebug()<<GetLength()<<"<"<<move;
// throw "Довжина більше довжини сплайну.";
// }
// if ( move <= 0 ){
// qDebug()<<"Довжина менше дорівнює нулю.";
// throw "Довжина менше дорівнює нулю.";
// }
// qreal t = 0;
// if ( move == 0 ){
// t = 0;
// } else {
// t = move / GetLength ();
// moveP.setX ( pow ( 1 - t, 3 ) * GetPointP1 ().x () + 3 * t * pow ( 1 - t, 2 ) *
// GetP2 ().x () + 3 * t * t * ( 1 - t ) * GetP3 ().x () +
// pow ( t, 3 ) * GetPointP4 ().x () );
// moveP.setY ( pow ( 1 - t, 3 ) * GetPointP1 ().y () + 3 * t * pow ( 1 - t, 2 ) *
// GetP2 ().y () + 3 * t * t * ( 1 - t ) * GetP3 ().y () +
// pow ( t, 3 ) * GetPointP4 ().y () );
// }
//}
QVector<QPointF> VSpline::GetPoints () const QVector<QPointF> VSpline::GetPoints () const
{ {
return GetPoints(GetPointP1().toQPointF(), p2, p3, GetPointP4().toQPointF()); return GetPoints(GetP1().toQPointF(), p2, p3, GetP4().toQPointF());
// QLineF line1(points.at(0).toPoint(), points.at(1).toPoint());
// line1.setLength(500);
// QLineF line2 = line1;
// line2.setAngle(line2.angle()+90);
// qreal xk1 = line1.p2().x();
// qreal xk0 = line1.p1().x();
// qreal y = line2.p2().y();
// qreal yk0 = line1.p1().y();
// qreal yk1 = line1.p2().y();
// qreal x = line2.p2().x();
// qreal check = (xk1 - xk0) * (y - yk0) - (yk1 - yk0) * (x - xk0);
// if(check > 0){
// return points;
// } else {
// QVector<QPointF> reversePoints;
// for (qint32 i = points.size() - 1; i >= 0; --i) {
// reversePoints.append(points.at(i));
// }
// return reversePoints;
// }
} }
QVector<QPointF> VSpline::GetPoints (const QPointF &p1, const QPointF &p2, const QPointF &p3, const QPointF &p4) QVector<QPointF> VSpline::GetPoints (const QPointF &p1, const QPointF &p2, const QPointF &p3, const QPointF &p4)
@ -681,6 +568,11 @@ qreal VSpline::CalcSqDistance (qreal x1, qreal y1, qreal x2, qreal y2)
return dx * dx + dy * dy; return dx * dx + dy * dy;
} }
void VSpline::CreateName()
{
_name = QString("Spl_%1_%2").arg(this->GetP1().name(), this->GetP4().name());
}
QPainterPath VSpline::GetPath() const QPainterPath VSpline::GetPath() const
{ {
QPainterPath splinePath; QPainterPath splinePath;
@ -700,130 +592,6 @@ QPainterPath VSpline::GetPath() const
return splinePath; return splinePath;
} }
/* Cubic equation solution. Real coefficients case.
int Cubic(double *x,double a,double b,double c);
Parameters:
x - solution array (size 3). On output:
3 real roots -> then x is filled with them;
1 real + 2 complex -> x[0] is real, x[1] is real part of
complex roots, x[2] - non-negative
imaginary part.
a, b, c - coefficients, as described
Returns: 3 - 3 real roots;
1 - 1 real root + 2 complex;
2 - 1 real root + complex roots imaginary part is zero
(i.e. 2 real roots).
*/
//qint32 VSpline::Cubic(qreal *x, qreal a, qreal b, qreal c){
// qreal q,r,r2,q3;
//
// q = (a*a - 3.*b)/9.;
// r = (a*(2.*a*a - 9.*b) + 27.*c)/54.;
// r2 = r*r;
// q3 = pow(q,3);
// if(r2<q3) {
// qreal t = acos(r/sqrt(q3));
// a/=3.;
// q = -2.*sqrt(q);
// x[0] = q*cos(t/3.)-a;
// x[1] = q*cos((t + M_2PI)/3.) - a;
// x[2] = q*cos((t - M_2PI)/3.) - a;
// return(3);
// } else {
// qreal aa,bb;
// if(r<=0.){
// r=-r;
// }
// aa = -pow(r + sqrt(r2-q3),1./3.);
// if(aa!=0.){
// bb=q/aa;
// } else {
// bb=0.;
// }
// a/=3.;
// q = aa+bb;
// r = aa-bb;
// x[0] = q-a;
// x[1] = (-0.5)*q-a;
// x[2] = (sqrt(3.)*0.5)*fabs(r);
// if(x[2]==0.){
// return(2);
// }
// return(1);
// }
//}
//
//qreal VSpline::calc_t (qreal curve_coord1, qreal curve_coord2, qreal curve_coord3,
// qreal curve_coord4, qreal point_coord) const{
// qreal P1, P2, P3, P4, Bt;
// qreal a, b, c, d, ret_t;
//
// qreal *t = static_cast<qreal *>(malloc(3*sizeof(qreal)));
// P1 = curve_coord1;
// P2 = curve_coord2;
// P3 = curve_coord3;
// P4 = curve_coord4;
// Bt = point_coord;
//
// a = -P1 + 3*P2 - 3*P3 + P4;
// b = 3*P1 - 6*P2 + 3*P3;
// c = -3*P1 + 3*P2;
// d = -Bt + P1;
//
// if(Cubic(t, b/a, c/a, d/a) == 3){
// ret_t = t[2];
// } else {
// ret_t = t[0];
// }
// /*
// * Повертається три значення, але експереминтально знайдено що шукане
// * значення знаходиться в третьому.
// */
//
// free(t);
// if(ret_t<0 || ret_t>1){
// qDebug()<<"Неправильне значення параметра. фунція calc_t";
// throw"Неправильне значення параметра. фунція calc_t";
// }
// return ret_t;
//}
/*
* Функція знаходить підходяще значення параметна t якому відповідає точка на сплайні.
*/
//qreal VSpline::param_t (QPointF pBt)const{
// qreal t_x, t_y;
// t_x = calc_t (GetPointP1().x(), p2.x(), p3.x(), GetPointP4().x(), pBt.x());
// t_y = calc_t (GetPointP1().y(), p2.y(), p3.y(), GetPointP4().y(), pBt.y());
// /*
// * Порівнюємо значення по х і по у і визначаємо найбільше. Це значення і
// * буде шуканим.
// */
// if(t_x>t_y)
// return t_x;
// else
// return t_y;
//}
//
//void VSpline::Mirror(const QPointF Pmirror){
// QPointF P1 = p1;
// P1 = QPointF(P1.x() - Pmirror.x(), P1.y() - Pmirror.y());
// P1 = QPointF(P1.x() * -1.0, P1.y() * 1.0);
// P1 = QPointF(P1.x() + Pmirror.x(), P1.y() + Pmirror.y());
// QPointF P2 = p2;
// P2 = QPointF(P2.x() - Pmirror.x(), P2.y() - Pmirror.y());
// P2 = QPointF(P2.x() * -1.0, P2.y() * 1.0);
// P2 = QPointF(P2.x() + Pmirror.x(), P2.y() + Pmirror.y());
// QPointF P3 = p3;
// P3 = QPointF(P3.x() - Pmirror.x(), P3.y() - Pmirror.y());
// P3 = QPointF(P3.x() * -1.0, P3.y() * 1.0);
// P3 = QPointF(P3.x() + Pmirror.x(), P3.y() + Pmirror.y());
// QPointF P4 = p4;
// P4 = QPointF(P4.x() - Pmirror.x(), P4.y() - Pmirror.y());
// P4 = QPointF(P4.x() * -1.0, P4.y() * 1.0);
// P4 = QPointF(P4.x() + Pmirror.x(), P4.y() + Pmirror.y());
// this->ModifiSpl(P1, P2, P3, P4);
//}
QVector<QPointF> VSpline::SplinePoints(const QPointF &p1, const QPointF &p4, qreal angle1, qreal angle2, qreal kAsm1, QVector<QPointF> VSpline::SplinePoints(const QPointF &p1, const QPointF &p4, qreal angle1, qreal angle2, qreal kAsm1,
qreal kAsm2, qreal kCurve) qreal kAsm2, qreal kCurve)
{ {
@ -843,6 +611,7 @@ QVector<QPointF> VSpline::SplinePoints(const QPointF &p1, const QPointF &p4, qre
VSpline &VSpline::operator =(const VSpline &spline) VSpline &VSpline::operator =(const VSpline &spline)
{ {
VGObject::operator=(spline);
this->p1 = spline.GetP1 (); this->p1 = spline.GetP1 ();
this->p2 = spline.GetP2 (); this->p2 = spline.GetP2 ();
this->p3 = spline.GetP3 (); this->p3 = spline.GetP3 ();
@ -852,8 +621,5 @@ VSpline &VSpline::operator =(const VSpline &spline)
this->kAsm1 = spline.GetKasm1(); this->kAsm1 = spline.GetKasm1();
this->kAsm2 = spline.GetKasm2(); this->kAsm2 = spline.GetKasm2();
this->kCurve = spline.GetKcurve(); this->kCurve = spline.GetKcurve();
this->points = spline.GetDataPoints();
this->idObject = spline.getIdObject();
this->_name = spline.name();
return *this; return *this;
} }

150
src/geometry/vspline.h
View file

@ -29,7 +29,8 @@
#ifndef VSPLINE_H #ifndef VSPLINE_H
#define VSPLINE_H #define VSPLINE_H
#include "../container/vpointf.h" #include "vpointf.h"
#include "vgobject.h"
#include <QHash> #include <QHash>
#include <QLineF> #include <QLineF>
@ -42,7 +43,7 @@ class QString;
/** /**
* @brief VSpline class that implements the spline. * @brief VSpline class that implements the spline.
*/ */
class VSpline class VSpline :public VGObject
{ {
public: public:
/** /**
@ -64,8 +65,8 @@ public:
* @param kAsm1 коефіцієнт довжини першої напрямної. * @param kAsm1 коефіцієнт довжини першої напрямної.
* @param kAsm2 коефіцієнт довжини другої напрямної. * @param kAsm2 коефіцієнт довжини другої напрямної.
*/ */
VSpline (const QHash<qint64, VPointF> *points, qint64 p1, qint64 p4, qreal angle1, qreal angle2, qreal kAsm1, VSpline (VPointF p1, VPointF p4, qreal angle1, qreal angle2, qreal kAsm1, qreal kAsm2, qreal kCurve,
qreal kAsm2, qreal kCurve, qint64 idObject = 0); qint64 idObject = 0, Draw::Draws mode = Draw::Calculation);
/** /**
* @brief VSpline конструктор. * @brief VSpline конструктор.
* @param p1 початкова точка сплайну. * @param p1 початкова точка сплайну.
@ -73,51 +74,13 @@ public:
* @param p3 друга контролююча точка сплайну. * @param p3 друга контролююча точка сплайну.
* @param p4 кінцева точка сплайну. * @param p4 кінцева точка сплайну.
*/ */
VSpline (const QHash<qint64, VPointF> *points, qint64 p1, QPointF p2, QPointF p3, qint64 p4, VSpline (VPointF p1, QPointF p2, QPointF p3, VPointF p4, qreal kCurve, qint64 idObject = 0,
qreal kCurve, qint64 idObject = 0); Draw::Draws mode = Draw::Calculation);
/**
* @brief ModifiSpl модифікує сплайн.
* @param p1 початкова точка сплайну.
* @param p4 кінцева точка сплайну.
* @param angle1 кут в градусах першої напрямної.
* @param angle2 кут в градусах другої напрямної.
* @param kCurve коефіцієнт кривизни сплайну.
* @param kAsm1 коефіцієнт довжини першої напрямної.
* @param kAsm2 коефіцієнт довжини другої напрямної.
*/
void ModifiSpl ( qint64 p1, qint64 p4, qreal angle1, qreal angle2, qreal kAsm1, qreal kAsm2,
qreal kCurve);
/**
* @brief ModifiSpl модифікує сплайн.
* @param p1 початкова точка сплайну.
* @param p2 перша контролююча точка сплайну.
* @param p3 друга контролююча точка сплайну.
* @param p4 кінцева точка сплайну.
*/
void ModifiSpl (const qint64 &p1, const QPointF &p2, const QPointF &p3, const qint64 &p4,
const qreal &kCurve);
// /**
// * @brief RotationSpl поворот сплайна навколо точки на кут в градусах проти годиникової стрілки.
// * @param pRotate точка навколо якої повертаємо.
// * @param angle кут в градусах.
// */
// void RotationSpl ( QPointF pRotate, qreal angle );
// /**
// * @brief BiasSpl зміщує сплайн.
// * @param mx зміщення по х координаті.
// * @param my зміщення по у координаті.
// */
// void BiasSpl ( qreal mx, qreal my );
/** /**
* @brief GetP1 повертає першу точку сплайну. * @brief GetP1 повертає першу точку сплайну.
* @return перша точка сплайну. * @return перша точка сплайну.
*/ */
qint64 GetP1 () const {return p1;} VPointF GetP1 () const {return p1;}
/**
* @brief GetPointP1
* @return
*/
VPointF GetPointP1() const;
/** /**
* @brief GetP2 повертує першу контрольну точку сплайну. * @brief GetP2 повертує першу контрольну точку сплайну.
* @return перша контрольна точка сплайну. * @return перша контрольна точка сплайну.
@ -132,12 +95,7 @@ public:
* @brief GetP4 повертає останню точку сплайну. * @brief GetP4 повертає останню точку сплайну.
* @return остання точка сплайну. * @return остання точка сплайну.
*/ */
inline qint64 GetP4 () const {return p4;} inline VPointF GetP4 () const {return p4;}
/**
* @brief GetPointP4
* @return
*/
VPointF GetPointP4 () const;
/** /**
* @brief GetAngle1 повертає кут першої напрямної. * @brief GetAngle1 повертає кут першої напрямної.
* @return кут в градусах. * @return кут в градусах.
@ -154,10 +112,10 @@ public:
*/ */
qreal GetLength () const; qreal GetLength () const;
/** /**
* @brief GetName * @brief name
* @return * @return
*/ */
QString GetName () const; QString name () const;
/** /**
* @brief GetKasm1 * @brief GetKasm1
* @return * @return
@ -173,11 +131,6 @@ public:
* @return * @return
*/ */
inline qreal GetKcurve() const {return kCurve;} inline qreal GetKcurve() const {return kCurve;}
/**
* @brief GetDataPoints
* @return
*/
inline const QHash<qint64, VPointF> GetDataPoints() const {return points;}
/** /**
* @brief CrossingSplLine перевіряє перетин сплайну з лінією. * @brief CrossingSplLine перевіряє перетин сплайну з лінією.
* @param line лінія з якою перевіряється перетин. * @param line лінія з якою перевіряється перетин.
@ -197,19 +150,6 @@ public:
* @return point of cutting. This point is forth point of first spline and first point of second spline. * @return point of cutting. This point is forth point of first spline and first point of second spline.
*/ */
QPointF CutSpline ( qreal length, QPointF &spl1p2, QPointF &spl1p3, QPointF &spl2p2, QPointF &spl2p3) const; QPointF CutSpline ( qreal length, QPointF &spl1p2, QPointF &spl1p3, QPointF &spl2p2, QPointF &spl2p3) const;
/**
* @brief CutSpline розрізає сплайн.
* @param point точка що ділить сплайн.
* @param curFir перший сплайн.
* @param curSec другий сплайн.
*/
// void CutSpline (QPointF point, VSpline* curFir, VSpline* curSec ) const;
/**
* @brief PutAlongSpl розміщає точку на сплайні.
* @param moveP точка яка розміщується на сплайні.
* @param move довжина від початку сплайну.
*/
// void PutAlongSpl ( QPointF &moveP, qreal move ) const;
/** /**
* @brief GetPoints повертає точки з яких складається сплайн. * @brief GetPoints повертає точки з яких складається сплайн.
* @return список точок. * @return список точок.
@ -220,11 +160,6 @@ public:
* @return шлях. * @return шлях.
*/ */
QPainterPath GetPath() const; QPainterPath GetPath() const;
/**
* @brief Mirror вертикальне дзеркалення сплайну відносно точки.
* @param Pmirror точка відносно якої відбувається вертикальне дзеркалення сплайну.
*/
// void Mirror(const QPointF Pmirror);
/** /**
* @brief SplinePoints * @brief SplinePoints
* @param p1 * @param p1
@ -238,32 +173,12 @@ public:
*/ */
static QVector<QPointF> SplinePoints(const QPointF &p1, const QPointF &p4, qreal angle1, qreal angle2, qreal kAsm1, static QVector<QPointF> SplinePoints(const QPointF &p1, const QPointF &p4, qreal angle1, qreal angle2, qreal kAsm1,
qreal kAsm2, qreal kCurve); qreal kAsm2, qreal kCurve);
/**
* @brief getIdObject
* @return
*/
inline qint64 getIdObject() const {return idObject;}
/**
* @brief setIdObject
* @param value
*/
inline void setIdObject(const qint64 &value) {idObject = value;}
/** /**
* @brief operator = * @brief operator =
* @param spl * @param spl
* @return * @return
*/ */
VSpline &operator=(const VSpline &spl); VSpline &operator=(const VSpline &spl);
/**
* @brief name
* @return
*/
QString name() const {return _name;}
/**
* @brief setName
* @param name
*/
void setName(const QString &name) {_name = name;}
protected: protected:
/** /**
* @brief GetPoints повертає точки з яких складається сплайн. * @brief GetPoints повертає точки з яких складається сплайн.
@ -278,7 +193,7 @@ private:
/** /**
* @brief p1 початкова точка сплайну * @brief p1 початкова точка сплайну
*/ */
qint64 p1; // перша точка VPointF p1; // перша точка
/** /**
* @brief p2 перша контрольна точка сплайну. * @brief p2 перша контрольна точка сплайну.
*/ */
@ -290,7 +205,7 @@ private:
/** /**
* @brief p4 кінцеві точка сплайну. * @brief p4 кінцеві точка сплайну.
*/ */
qint64 p4; // четверта точка VPointF p4; // четверта точка
/** /**
* @brief angle1 кут в градусах першої напрямної. * @brief angle1 кут в градусах першої напрямної.
*/ */
@ -311,18 +226,6 @@ private:
* @brief kCurve * @brief kCurve
*/ */
qreal kCurve; qreal kCurve;
/**
* @brief points
*/
QHash<qint64, VPointF> points;
/**
* @brief idObject
*/
qint64 idObject;
/**
* @brief _name
*/
QString _name;
/** /**
* @brief LengthBezier повертає дожину сплайну за його чотирьма точками. * @brief LengthBezier повертає дожину сплайну за його чотирьма точками.
* @param p1 початкова точка сплайну. * @param p1 початкова точка сплайну.
@ -357,32 +260,7 @@ private:
* @return довжину. * @return довжину.
*/ */
static qreal CalcSqDistance ( qreal x1, qreal y1, qreal x2, qreal y2); static qreal CalcSqDistance ( qreal x1, qreal y1, qreal x2, qreal y2);
// /** void CreateName();
// * @brief Cubic знаходить розв'язок кубічного рівняння.
// * @param x коефіцієнт.
// * @param a коефіцієнт.
// * @param b коефіцієнт.
// * @param c коефіцієнт.
// * @return повертає корені рівняння.
// */
// static qint32 Cubic(qreal *x, qreal a, qreal b, qreal c);
/**
* @brief calc_t знаходить параметр t якому відповідає точка на сплайні.
* @param curve_coord1 координата Х або У кривої.
* @param curve_coord2 координата Х або У кривої.
* @param curve_coord3 координата Х або У кривої.
* @param curve_coord4 координата Х або У кривої.
* @param point_coord координата Х або У точки на кривій.
* @return
*/
// static qreal calc_t (qreal curve_coord1, qreal curve_coord2, qreal curve_coord3, qreal curve_coord4,
// qreal point_coord)const;
/**
* @brief param_t знаходить підходяще значення параметра t якому відповідає точка на сплайні
* @param pBt точка для якої шукається значення параметра t.
* @return підходяще значення t.
*/
// qreal param_t (QPointF pBt)const;
}; };
#endif // VSPLINE_H #endif // VSPLINE_H

52
src/geometry/vsplinepath.cpp
View file

@ -29,16 +29,15 @@
#include "vsplinepath.h" #include "vsplinepath.h"
#include "../exception/vexception.h" #include "../exception/vexception.h"
VSplinePath::VSplinePath() VSplinePath::VSplinePath(qreal kCurve, qint64 idObject, Draw::Draws mode)
: path(QVector<VSplinePoint>()), kCurve(1), points(QHash<qint64, VPointF>()), idObject(0), _name(QString()){} : VGObject(GObject::SplinePath, idObject, mode), path(QVector<VSplinePoint>()), kCurve(kCurve)
{
VSplinePath::VSplinePath(const QHash<qint64, VPointF> *points, qreal kCurve, qint64 idObject) }
: path(QVector<VSplinePoint>()), kCurve(kCurve), points(*points), idObject(idObject), _name(QString())
{}
VSplinePath::VSplinePath(const VSplinePath &splPath) VSplinePath::VSplinePath(const VSplinePath &splPath)
: path(*splPath.GetPoint()), kCurve(splPath.getKCurve()), points(splPath.GetDataPoints()), : VGObject(splPath), path(*splPath.GetPoint()), kCurve(splPath.getKCurve())
idObject(splPath.getIdObject()), _name(splPath.name()){} {
}
void VSplinePath::append(const VSplinePoint &point) void VSplinePath::append(const VSplinePoint &point)
{ {
@ -47,8 +46,8 @@ void VSplinePath::append(const VSplinePoint &point)
for (qint32 i = 1; i <= this->Count(); ++i) for (qint32 i = 1; i <= this->Count(); ++i)
{ {
VSpline spl = this->GetSpline(i); VSpline spl = this->GetSpline(i);
VPointF first = spl.GetPointP1(); VPointF first = spl.GetP1();
VPointF second = spl.GetPointP4(); VPointF second = spl.GetP4();
QString splName = QString("_%1_%2").arg(first.name(), second.name()); QString splName = QString("_%1_%2").arg(first.name(), second.name());
_name.append(splName); _name.append(splName);
} }
@ -76,7 +75,7 @@ VSpline VSplinePath::GetSpline(qint32 index) const
{ {
throw VException(tr("This spline does not exist.")); throw VException(tr("This spline does not exist."));
} }
VSpline spl(&points, path[index-1].P(), path[index].P(), path[index-1].Angle2(), path[index].Angle1(), VSpline spl(path[index-1].P(), path[index].P(), path[index-1].Angle2(), path[index].Angle1(),
path[index-1].KAsm2(), path[index].KAsm1(), this->kCurve); path[index-1].KAsm2(), path[index].KAsm1(), this->kCurve);
return spl; return spl;
} }
@ -86,7 +85,7 @@ QPainterPath VSplinePath::GetPath() const
QPainterPath painterPath; QPainterPath painterPath;
for (qint32 i = 1; i <= Count(); ++i) for (qint32 i = 1; i <= Count(); ++i)
{ {
VSpline spl(&points, path[i-1].P(), path[i].P(), path[i-1].Angle2(), path[i].Angle1(), VSpline spl(path[i-1].P(), path[i].P(), path[i-1].Angle2(), path[i].Angle1(),
path[i-1].KAsm2(), path[i].KAsm1(), this->kCurve); path[i-1].KAsm2(), path[i].KAsm1(), this->kCurve);
painterPath.addPath(spl.GetPath()); painterPath.addPath(spl.GetPath());
} }
@ -98,8 +97,9 @@ QVector<QPointF> VSplinePath::GetPathPoints() const
QVector<QPointF> pathPoints; QVector<QPointF> pathPoints;
for (qint32 i = 1; i <= Count(); ++i) for (qint32 i = 1; i <= Count(); ++i)
{ {
VSpline spl(&points, path[i-1].P(), path[i].P(), path[i-1].Angle2(), path[i].Angle1(), VSpline spl(path[i-1].P(), path[i].P(), path[i-1].Angle2(), path[i].Angle1(),
path[i-1].KAsm2(), path[i].KAsm1(), this->kCurve); path[i-1].KAsm2(), path[i].KAsm1(), this->kCurve);
//TODO Use QVector<T> & QVector::operator+=(const QVector<T> & other) instead for.
QVector<QPointF> splP = spl.GetPoints(); QVector<QPointF> splP = spl.GetPoints();
for (qint32 j = 0; j < splP.size(); ++j) for (qint32 j = 0; j < splP.size(); ++j)
{ {
@ -114,7 +114,7 @@ qreal VSplinePath::GetLength() const
qreal length = 0; qreal length = 0;
for (qint32 i = 1; i <= Count(); ++i) for (qint32 i = 1; i <= Count(); ++i)
{ {
VSpline spl(&points, path[i-1].P(), path[i].P(), path[i-1].Angle2(), path[i].Angle1(), path[i-1].KAsm2(), VSpline spl(path[i-1].P(), path[i].P(), path[i-1].Angle2(), path[i].Angle1(), path[i-1].KAsm2(),
path[i].KAsm1(), kCurve); path[i].KAsm1(), kCurve);
length += spl.GetLength(); length += spl.GetLength();
} }
@ -155,11 +155,9 @@ VSplinePoint VSplinePath::GetSplinePoint(qint32 indexSpline, SplinePoint::Positi
VSplinePath &VSplinePath::operator =(const VSplinePath &path) VSplinePath &VSplinePath::operator =(const VSplinePath &path)
{ {
VGObject::operator=(path);
this->path = path.GetSplinePath(); this->path = path.GetSplinePath();
this->kCurve = path.getKCurve(); this->kCurve = path.getKCurve();
this->points = path.GetDataPoints();
this->idObject = path.getIdObject();
this->_name = path.name();
return *this; return *this;
} }
@ -168,6 +166,11 @@ VSplinePoint & VSplinePath::operator[](ptrdiff_t indx)
return path[indx]; return path[indx];
} }
const VSplinePoint &VSplinePath::at(ptrdiff_t indx) const
{
return path[indx];
}
QPointF VSplinePath::CutSplinePath(qreal length, qint32 &p1, qint32 &p2, QPointF &spl1p2, QPointF &spl1p3, QPointF VSplinePath::CutSplinePath(qreal length, qint32 &p1, qint32 &p2, QPointF &spl1p2, QPointF &spl1p3,
QPointF &spl2p2, QPointF &spl2p3) const QPointF &spl2p2, QPointF &spl2p3) const
{ {
@ -190,8 +193,8 @@ QPointF VSplinePath::CutSplinePath(qreal length, qint32 &p1, qint32 &p2, QPointF
fullLength = 0; fullLength = 0;
for (qint32 i = 1; i <= Count(); ++i) for (qint32 i = 1; i <= Count(); ++i)
{ {
VSpline spl = VSpline(&points, path[i-1].P(), path[i].P(), path[i-1].Angle2(), path[i].Angle1(), VSpline spl = VSpline(path[i-1].P(), path[i].P(), path[i-1].Angle2(), path[i].Angle1(), path[i-1].KAsm2(),
path[i-1].KAsm2(), path[i].KAsm1(), kCurve); path[i].KAsm1(), kCurve);
fullLength += spl.GetLength(); fullLength += spl.GetLength();
if(fullLength > length) if(fullLength > length)
{ {
@ -202,14 +205,3 @@ QPointF VSplinePath::CutSplinePath(qreal length, qint32 &p1, qint32 &p2, QPointF
} }
return QPointF(); return QPointF();
} }
QHash<qint64, VPointF> VSplinePath::getPoints() const
{
return points;
}
void VSplinePath::setPoints(const QHash<qint64, VPointF> *value)
{
points = *value;
}

52
src/geometry/vsplinepath.h
View file

@ -30,9 +30,11 @@
#define VSPLINEPATH_H #define VSPLINEPATH_H
#include "vsplinepoint.h" #include "vsplinepoint.h"
#include "../container/vpointf.h" #include "vpointf.h"
#include "vspline.h" #include "vspline.h"
#include "vgobject.h"
#include <QApplication> #include <QApplication>
#include "../container/vcontainer.h"
namespace SplinePoint namespace SplinePoint
{ {
@ -47,18 +49,14 @@ Q_DECLARE_OPERATORS_FOR_FLAGS( SplinePoint::Positions )
/** /**
* @brief The VSplinePath клас, що розраховує шлях сплайнів. * @brief The VSplinePath клас, що розраховує шлях сплайнів.
*/ */
class VSplinePath class VSplinePath :public VGObject
{ {
Q_DECLARE_TR_FUNCTIONS(VSplinePath) Q_DECLARE_TR_FUNCTIONS(VSplinePath)
public: public:
/** /**
* @brief VSplinePath конструктор по замовчуванню. * @brief VSplinePath конструктор по замовчуванню.
*/ */
VSplinePath(); VSplinePath(qreal kCurve = 1, qint64 idObject = 0, Draw::Draws mode = Draw::Calculation);
/**
* @brief VSplinePath конструктор по замовчуванню.
*/
VSplinePath(const QHash<qint64, VPointF> *points, qreal kCurve = 1, qint64 idObject = 0);
/** /**
* @brief VSplinePath * @brief VSplinePath
* @param splPath * @param splPath
@ -105,11 +103,6 @@ public:
* @return * @return
*/ */
qreal GetLength() const; qreal GetLength() const;
/**
* @brief GetDataPoints
* @return
*/
inline QHash<qint64, VPointF> GetDataPoints() const {return points;}
/** /**
* @brief UpdatePoint * @brief UpdatePoint
* @param indexSpline * @param indexSpline
@ -155,26 +148,7 @@ public:
* @return * @return
*/ */
VSplinePoint &operator[](ptrdiff_t indx); VSplinePoint &operator[](ptrdiff_t indx);
/** const VSplinePoint &at(ptrdiff_t indx) const;
* @brief getIdObject
* @return
*/
inline qint64 getIdObject() const {return idObject;}
/**
* @brief setIdObject
* @param value
*/
inline void setIdObject(const qint64 &value) {idObject = value;}
/**
* @brief name
* @return
*/
QString name() const {return _name;}
/**
* @brief setName
* @param name
*/
void setName(const QString &name) {_name = name;}
/** /**
* @brief CutSplinePath * @brief CutSplinePath
* @param length * @param length
@ -186,8 +160,6 @@ public:
*/ */
QPointF CutSplinePath(qreal length, qint32 &p1, qint32 &p2, QPointF &spl1p2, QPointF &spl1p3, QPointF &spl2p2, QPointF CutSplinePath(qreal length, qint32 &p1, qint32 &p2, QPointF &spl1p2, QPointF &spl1p3, QPointF &spl2p2,
QPointF &spl2p3) const; QPointF &spl2p3) const;
QHash<qint64, VPointF> getPoints() const;
void setPoints(const QHash<qint64, VPointF> *value);
protected: protected:
/** /**
* @brief path вектор з точок сплайна. * @brief path вектор з точок сплайна.
@ -197,18 +169,6 @@ protected:
* @brief kCurve * @brief kCurve
*/ */
qreal kCurve; qreal kCurve;
/**
* @brief points
*/
QHash<qint64, VPointF> points;
/**
* @brief idObject
*/
qint64 idObject;
/**
* @brief _name
*/
QString _name;
}; };
#endif // VSPLINEPATH_H #endif // VSPLINEPATH_H

4
src/geometry/vsplinepoint.cpp
View file

@ -29,9 +29,9 @@
#include "vsplinepoint.h" #include "vsplinepoint.h"
VSplinePoint::VSplinePoint() VSplinePoint::VSplinePoint()
:pSpline(0), angle(0), kAsm1(1), kAsm2(1){} :pSpline(VPointF()), angle(0), kAsm1(1), kAsm2(1){}
VSplinePoint::VSplinePoint(qint64 pSpline, qreal kAsm1, qreal angle, qreal kAsm2) VSplinePoint::VSplinePoint(VPointF pSpline, qreal kAsm1, qreal angle, qreal kAsm2)
:pSpline(pSpline), angle(angle), kAsm1(kAsm1), kAsm2(kAsm2){} :pSpline(pSpline), angle(angle), kAsm1(kAsm1), kAsm2(kAsm2){}
VSplinePoint::VSplinePoint(const VSplinePoint &point) VSplinePoint::VSplinePoint(const VSplinePoint &point)

9
src/geometry/vsplinepoint.h
View file

@ -30,6 +30,7 @@
#define VSPLINEPOINT_H #define VSPLINEPOINT_H
#include <QMetaType> #include <QMetaType>
#include "vpointf.h"
/** /**
* @brief The VSplinePoint клас, що містить у собі інформацію про точки сплайну. * @brief The VSplinePoint клас, що містить у собі інформацію про точки сплайну.
@ -47,7 +48,7 @@ public:
* @param angle кут дотичної сплайна. * @param angle кут дотичної сплайна.
* @param factor коефіцієнт довжини дотичної. * @param factor коефіцієнт довжини дотичної.
*/ */
VSplinePoint(qint64 pSpline, qreal kAsm1, qreal angle, qreal kAsm2); VSplinePoint(VPointF pSpline, qreal kAsm1, qreal angle, qreal kAsm2);
/** /**
* @brief VSplinePoint * @brief VSplinePoint
* @param point * @param point
@ -58,12 +59,12 @@ public:
* @brief P повертає точку. * @brief P повертає точку.
* @return точка. * @return точка.
*/ */
inline qint64 P() const {return pSpline;} inline VPointF P() const {return pSpline;}
/** /**
* @brief SetP * @brief SetP
* @param value * @param value
*/ */
inline void SetP(const qint64 &value) {pSpline = value;} inline void SetP(const VPointF &value) {pSpline = value;}
/** /**
* @brief Angle1 повертає кут дотичної сплайна. * @brief Angle1 повертає кут дотичної сплайна.
* @return кут в градусах. * @return кут в градусах.
@ -103,7 +104,7 @@ protected:
/** /**
* @brief pSpline точка сплайну. * @brief pSpline точка сплайну.
*/ */
qint64 pSpline; VPointF pSpline;
/** /**
* @brief angle кут дотичної сплайну. * @brief angle кут дотичної сплайну.
*/ */

54
src/mainwindow.cpp
View file

@ -45,8 +45,8 @@
#include <QFileDialog> #include <QFileDialog>
MainWindow::MainWindow(QWidget *parent) MainWindow::MainWindow(QWidget *parent)
:QMainWindow(parent), ui(new Ui::MainWindow), tool(Tool::ArrowTool), currentScene(0), sceneDraw(0), :QMainWindow(parent), ui(new Ui::MainWindow), pattern(0), doc(0), tool(Tool::ArrowTool), currentScene(0),
sceneDetails(0), mouseCoordinate(0), helpLabel(0), view(0), isInitialized(false), dialogTable(0), sceneDraw(0), sceneDetails(0), mouseCoordinate(0), helpLabel(0), view(0), isInitialized(false), dialogTable(0),
dialogEndLine(QSharedPointer<DialogEndLine>()), dialogLine(QSharedPointer<DialogLine>()), dialogEndLine(QSharedPointer<DialogEndLine>()), dialogLine(QSharedPointer<DialogLine>()),
dialogAlongLine(QSharedPointer<DialogAlongLine>()), dialogAlongLine(QSharedPointer<DialogAlongLine>()),
dialogShoulderPoint(QSharedPointer<DialogShoulderPoint>()), dialogNormal(QSharedPointer<DialogNormal>()), dialogShoulderPoint(QSharedPointer<DialogShoulderPoint>()), dialogNormal(QSharedPointer<DialogNormal>()),
@ -58,7 +58,8 @@ MainWindow::MainWindow(QWidget *parent)
dialogTriangle(QSharedPointer<DialogTriangle>()), dialogTriangle(QSharedPointer<DialogTriangle>()),
dialogPointOfIntersection(QSharedPointer<DialogPointOfIntersection>()), dialogPointOfIntersection(QSharedPointer<DialogPointOfIntersection>()),
dialogCutSpline(QSharedPointer<DialogCutSpline>()), dialogCutSplinePath (QSharedPointer<DialogCutSplinePath>()), dialogCutSpline(QSharedPointer<DialogCutSpline>()), dialogCutSplinePath (QSharedPointer<DialogCutSplinePath>()),
dialogHistory(0), doc(0), data(0), comboBoxDraws(0), fileName(QString()), changeInFile(false), dialogUnionDetails(QSharedPointer<DialogUnionDetails>()),
dialogHistory(0), comboBoxDraws(0), fileName(QString()), changeInFile(false),
mode(Draw::Calculation) mode(Draw::Calculation)
{ {
ui->setupUi(this); ui->setupUi(this);
@ -107,16 +108,14 @@ MainWindow::MainWindow(QWidget *parent)
connect(ui->toolButtonPointOfIntersection, &QToolButton::clicked, this, &MainWindow::ToolPointOfIntersection); connect(ui->toolButtonPointOfIntersection, &QToolButton::clicked, this, &MainWindow::ToolPointOfIntersection);
connect(ui->toolButtonSplineCutPoint, &QToolButton::clicked, this, &MainWindow::ToolCutSpline); connect(ui->toolButtonSplineCutPoint, &QToolButton::clicked, this, &MainWindow::ToolCutSpline);
connect(ui->toolButtonSplinePathCutPoint, &QToolButton::clicked, this, &MainWindow::ToolCutSplinePath); connect(ui->toolButtonSplinePathCutPoint, &QToolButton::clicked, this, &MainWindow::ToolCutSplinePath);
connect(ui->toolButtonUnionDetails, &QToolButton::clicked, this, &MainWindow::ToolUnionDetails);
data = new VContainer; pattern = new VContainer();
doc = new VDomDocument(data, comboBoxDraws, &mode); doc = new VDomDocument(pattern, comboBoxDraws, &mode);
doc->CreateEmptyFile(); doc->CreateEmptyFile();
connect(doc, &VDomDocument::haveChange, this, &MainWindow::haveChange); connect(doc, &VDomDocument::haveChange, this, &MainWindow::haveChange);
fileName.clear();
changeInFile = false;
//Autosaving file each 5 minutes //Autosaving file each 5 minutes
QTimer *timer = new QTimer(this); QTimer *timer = new QTimer(this);
timer->setTimerType(Qt::VeryCoarseTimer); timer->setTimerType(Qt::VeryCoarseTimer);
@ -180,10 +179,10 @@ void MainWindow::ActionNewDraw()
} }
connect(comboBoxDraws, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, connect(comboBoxDraws, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
&MainWindow::currentDrawChanged); &MainWindow::currentDrawChanged);
data->ClearObject(); pattern->ClearObject();
//Create single point //Create single point
qint64 id = data->AddPoint(VPointF(toPixel((10+comboBoxDraws->count()*5)), toPixel(10), "А", 5, 10)); qint64 id = pattern->AddGObject(new VPointF(toPixel((10+comboBoxDraws->count()*5)), toPixel(10), "А", 5, 10));
VToolSinglePoint *spoint = new VToolSinglePoint(doc, data, id, Tool::FromGui); VToolSinglePoint *spoint = new VToolSinglePoint(doc, pattern, id, Tool::FromGui);
sceneDraw->addItem(spoint); sceneDraw->addItem(spoint);
connect(spoint, &VToolPoint::ChoosedTool, sceneDraw, &VMainGraphicsScene::ChoosedItem); connect(spoint, &VToolPoint::ChoosedTool, sceneDraw, &VMainGraphicsScene::ChoosedItem);
connect(sceneDraw, &VMainGraphicsScene::NewFactor, spoint, &VToolSinglePoint::SetFactor); connect(sceneDraw, &VMainGraphicsScene::NewFactor, spoint, &VToolSinglePoint::SetFactor);
@ -251,7 +250,7 @@ void MainWindow::SetToolButton(bool checked, Tool::Tools t, const QString &curso
QCursor cur(pixmap, 2, 3); QCursor cur(pixmap, 2, 3);
view->setCursor(cur); view->setCursor(cur);
helpLabel->setText(toolTip); helpLabel->setText(toolTip);
dialog = QSharedPointer<Dialog>(new Dialog(data)); dialog = QSharedPointer<Dialog>(new Dialog(pattern));
connect(currentScene, &VMainGraphicsScene::ChoosedObject, dialog.data(), &Dialog::ChoosedObject); connect(currentScene, &VMainGraphicsScene::ChoosedObject, dialog.data(), &Dialog::ChoosedObject);
connect(dialog.data(), &Dialog::DialogClosed, this, closeDialogSlot); connect(dialog.data(), &Dialog::DialogClosed, this, closeDialogSlot);
connect(dialog.data(), &Dialog::ToolTip, this, &MainWindow::ShowToolTip); connect(dialog.data(), &Dialog::ToolTip, this, &MainWindow::ShowToolTip);
@ -282,7 +281,7 @@ void MainWindow::ClosedDialog(QSharedPointer<Dialog> &dialog, int result)
{ {
if (result == QDialog::Accepted) if (result == QDialog::Accepted)
{ {
DrawTool::Create(dialog, currentScene, doc, data); DrawTool::Create(dialog, currentScene, doc, pattern);
} }
ArrowTool(); ArrowTool();
} }
@ -443,7 +442,7 @@ void MainWindow::ToolDetail(bool checked)
QCursor cur(pixmap, 2, 3); QCursor cur(pixmap, 2, 3);
view->setCursor(cur); view->setCursor(cur);
helpLabel->setText(tr("Select points, arcs, curves clockwise.")); helpLabel->setText(tr("Select points, arcs, curves clockwise."));
dialogDetail = QSharedPointer<DialogDetail>(new DialogDetail(data)); dialogDetail = QSharedPointer<DialogDetail>(new DialogDetail(pattern));
connect(currentScene, &VMainGraphicsScene::ChoosedObject, dialogDetail.data(), connect(currentScene, &VMainGraphicsScene::ChoosedObject, dialogDetail.data(),
&DialogDetail::ChoosedObject); &DialogDetail::ChoosedObject);
connect(dialogDetail.data(), &DialogDetail::DialogClosed, this, &MainWindow::ClosedDialogDetail); connect(dialogDetail.data(), &DialogDetail::DialogClosed, this, &MainWindow::ClosedDialogDetail);
@ -462,7 +461,7 @@ void MainWindow::ClosedDialogDetail(int result)
{ {
if (result == QDialog::Accepted) if (result == QDialog::Accepted)
{ {
VToolDetail::Create(dialogDetail, sceneDetails, doc, data); VToolDetail::Create(dialogDetail, sceneDetails, doc, pattern);
} }
ArrowTool(); ArrowTool();
} }
@ -501,6 +500,17 @@ void MainWindow::ClosedDialogPointOfIntersection(int result)
ClosedDialog<VToolPointOfIntersection>(dialogPointOfIntersection, result); ClosedDialog<VToolPointOfIntersection>(dialogPointOfIntersection, result);
} }
void MainWindow::ToolUnionDetails(bool checked)
{
SetToolButton(checked, Tool::UnionDetails, ":/cursor/union_cursor.png",
tr("Select detail"), dialogUnionDetails, &MainWindow::ClosedDialogUnionDetails);
}
void MainWindow::ClosedDialogUnionDetails(int result)
{
ClosedDialog<VToolUnionDetails>(dialogUnionDetails, result);
}
void MainWindow::About() void MainWindow::About()
{ {
QString fullName = QString("Valentina %1").arg(APP_VERSION); QString fullName = QString("Valentina %1").arg(APP_VERSION);
@ -956,7 +966,7 @@ void MainWindow::Clear()
{ {
setWindowTitle("Valentina"); setWindowTitle("Valentina");
fileName.clear(); fileName.clear();
data->Clear(); pattern->Clear();
doc->clear(); doc->clear();
sceneDraw->clear(); sceneDraw->clear();
sceneDetails->clear(); sceneDetails->clear();
@ -991,14 +1001,14 @@ void MainWindow::haveChange()
void MainWindow::ChangedSize(const QString & text) void MainWindow::ChangedSize(const QString & text)
{ {
qint32 size = text.toInt(); qint32 size = text.toInt();
data->SetSize(size*10); pattern->SetSize(size*10);
doc->FullUpdateTree(); doc->FullUpdateTree();
} }
void MainWindow::ChangedGrowth(const QString &text) void MainWindow::ChangedGrowth(const QString &text)
{ {
qint32 growth = text.toInt(); qint32 growth = text.toInt();
data->SetGrowth(growth*10); pattern->SetGrowth(growth*10);
doc->FullUpdateTree(); doc->FullUpdateTree();
} }
@ -1020,7 +1030,7 @@ void MainWindow::ActionTable(bool checked)
{ {
if (checked) if (checked)
{ {
dialogTable = new DialogIncrements(data, doc, this); dialogTable = new DialogIncrements(pattern, doc, this);
connect(dialogTable, &DialogIncrements::DialogClosed, this, connect(dialogTable, &DialogIncrements::DialogClosed, this,
&MainWindow::ClosedActionTable); &MainWindow::ClosedActionTable);
dialogTable->show(); dialogTable->show();
@ -1042,7 +1052,7 @@ void MainWindow::ActionHistory(bool checked)
{ {
if (checked) if (checked)
{ {
dialogHistory = new DialogHistory(data, doc, this); dialogHistory = new DialogHistory(pattern, doc, this);
dialogHistory->setWindowFlags(Qt::Window); dialogHistory->setWindowFlags(Qt::Window);
connect(dialogHistory, &DialogHistory::DialogClosed, this, connect(dialogHistory, &DialogHistory::DialogClosed, this,
&MainWindow::ClosedActionHistory); &MainWindow::ClosedActionHistory);
@ -1060,7 +1070,7 @@ void MainWindow::ActionLayout(bool checked)
Q_UNUSED(checked); Q_UNUSED(checked);
hide(); hide();
QVector<VItem*> listDetails; QVector<VItem*> listDetails;
data->PrepareDetails(listDetails); pattern->PrepareDetails(listDetails);
emit ModelChosen(listDetails); emit ModelChosen(listDetails);
} }
@ -1205,7 +1215,7 @@ MainWindow::~MainWindow()
CanselTool(); CanselTool();
delete ui; delete ui;
delete data; delete pattern;
if (doc->isNull() == false) if (doc->isNull() == false)
{ {
delete doc; delete doc;

23
src/mainwindow.h
View file

@ -35,6 +35,7 @@
#include "widgets/vitem.h" #include "widgets/vitem.h"
#include "dialogs/dialogs.h" #include "dialogs/dialogs.h"
#include "tools/vtooldetail.h" #include "tools/vtooldetail.h"
#include "tools/vtooluniondetails.h"
#include "tools/drawTools/drawtools.h" #include "tools/drawTools/drawtools.h"
#include "xml/vdomdocument.h" #include "xml/vdomdocument.h"
@ -232,6 +233,7 @@ public slots:
* @param checked * @param checked
*/ */
void ToolPointOfIntersection(bool checked); void ToolPointOfIntersection(bool checked);
void ToolUnionDetails(bool checked);
/** /**
* @brief ClosedDialogEndLine * @brief ClosedDialogEndLine
* @param result * @param result
@ -312,6 +314,7 @@ public slots:
* @param result * @param result
*/ */
void ClosedDialogPointOfIntersection(int result); void ClosedDialogPointOfIntersection(int result);
void ClosedDialogUnionDetails(int result);
/** /**
* @brief ClosedDialogCutSpline handler close event tool CutSpline * @brief ClosedDialogCutSpline handler close event tool CutSpline
* @param result result of working of dialog * @param result result of working of dialog
@ -367,6 +370,14 @@ private:
* @brief ui keeps information about user interface * @brief ui keeps information about user interface
*/ */
Ui::MainWindow *ui; Ui::MainWindow *ui;
/**
* @brief pattern container with data (points, arcs, splines, spline paths, variables)
*/
VContainer *pattern;
/**
* @brief doc dom document container
*/
VDomDocument *doc;
/** /**
* @brief tool * @brief tool
*/ */
@ -471,18 +482,14 @@ private:
* @brief dialogCutSplinePath pointer to the dialog tool cut spline path * @brief dialogCutSplinePath pointer to the dialog tool cut spline path
*/ */
QSharedPointer<DialogCutSplinePath> dialogCutSplinePath; QSharedPointer<DialogCutSplinePath> dialogCutSplinePath;
/**
* @brief dialogUnionDetails
*/
QSharedPointer<DialogUnionDetails> dialogUnionDetails;
/** /**
* @brief dialogHistory * @brief dialogHistory
*/ */
DialogHistory *dialogHistory; DialogHistory *dialogHistory;
/**
* @brief doc dom document container
*/
VDomDocument *doc;
/**
* @brief data container with data
*/
VContainer *data;
/** /**
* @brief comboBoxDraws * @brief comboBoxDraws
*/ */

5
src/options.h
View file

@ -77,14 +77,15 @@ namespace Tool
NodeSplinePath, NodeSplinePath,
Height, Height,
Triangle, Triangle,
PointOfIntersection PointOfIntersection,
UnionDetails
}; };
Q_DECLARE_FLAGS(Tools, Tool) Q_DECLARE_FLAGS(Tools, Tool)
/** /**
* @brief The Source enum * @brief The Source enum
*/ */
enum Source { FromGui, FromFile }; enum Source { FromGui, FromFile, FromTool };
Q_DECLARE_FLAGS(Sources, Source) Q_DECLARE_FLAGS(Sources, Source)
} }
Q_DECLARE_OPERATORS_FOR_FLAGS( Tool::Tools ) Q_DECLARE_OPERATORS_FOR_FLAGS( Tool::Tools )

30
src/tools/drawTools/vtoolalongline.cpp
View file

@ -93,14 +93,14 @@ void VToolAlongLine::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
void VToolAlongLine::AddToFile() void VToolAlongLine::AddToFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->createElement(TagName); QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id); AddAttribute(domElement, AttrId, id);
AddAttribute(domElement, AttrType, ToolType); AddAttribute(domElement, AttrType, ToolType);
AddAttribute(domElement, AttrName, point.name()); AddAttribute(domElement, AttrName, point->name());
AddAttribute(domElement, AttrMx, toMM(point.mx())); AddAttribute(domElement, AttrMx, toMM(point->mx()));
AddAttribute(domElement, AttrMy, toMM(point.my())); AddAttribute(domElement, AttrMy, toMM(point->my()));
AddAttribute(domElement, AttrTypeLine, typeLine); AddAttribute(domElement, AttrTypeLine, typeLine);
AddAttribute(domElement, AttrLength, formula); AddAttribute(domElement, AttrLength, formula);
@ -112,13 +112,13 @@ void VToolAlongLine::AddToFile()
void VToolAlongLine::RefreshDataInFile() void VToolAlongLine::RefreshDataInFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute(AttrMx, toMM(point.mx())); domElement.setAttribute(AttrMx, toMM(point->mx()));
domElement.setAttribute(AttrMy, toMM(point.my())); domElement.setAttribute(AttrMy, toMM(point->my()));
domElement.setAttribute(AttrName, point.name()); domElement.setAttribute(AttrName, point->name());
domElement.setAttribute(AttrTypeLine, typeLine); domElement.setAttribute(AttrTypeLine, typeLine);
domElement.setAttribute(AttrLength, formula); domElement.setAttribute(AttrLength, formula);
domElement.setAttribute(AttrFirstPoint, basePointId); domElement.setAttribute(AttrFirstPoint, basePointId);
@ -135,12 +135,12 @@ void VToolAlongLine::RemoveReferens()
void VToolAlongLine::setDialog() void VToolAlongLine::setDialog()
{ {
Q_ASSERT(dialogAlongLine.isNull() == false); Q_ASSERT(dialogAlongLine.isNull() == false);
VPointF p = VAbstractTool::data.GetPoint(id); const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogAlongLine->setTypeLine(typeLine); dialogAlongLine->setTypeLine(typeLine);
dialogAlongLine->setFormula(formula); dialogAlongLine->setFormula(formula);
dialogAlongLine->setFirstPointId(basePointId, id); dialogAlongLine->setFirstPointId(basePointId, id);
dialogAlongLine->setSecondPointId(secondPointId, id); dialogAlongLine->setSecondPointId(secondPointId, id);
dialogAlongLine->setPointName(p.name()); dialogAlongLine->setPointName(p->name());
} }
void VToolAlongLine::Create(QSharedPointer<DialogAlongLine> &dialog, VMainGraphicsScene *scene, void VToolAlongLine::Create(QSharedPointer<DialogAlongLine> &dialog, VMainGraphicsScene *scene,
@ -160,9 +160,9 @@ void VToolAlongLine::Create(const qint64 _id, const QString &pointName, const QS
const qreal &mx, const qreal &my, VMainGraphicsScene *scene, VDomDocument *doc, const qreal &mx, const qreal &my, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data, const Document::Documents &parse, const Tool::Sources &typeCreation) VContainer *data, const Document::Documents &parse, const Tool::Sources &typeCreation)
{ {
VPointF firstPoint = data->GetPoint(firstPointId); const VPointF *firstPoint = data->GeometricObject<const VPointF *>(firstPointId);
VPointF secondPoint = data->GetPoint(secondPointId); const VPointF *secondPoint = data->GeometricObject<const VPointF *>(secondPointId);
QLineF line = QLineF(firstPoint.toQPointF(), secondPoint.toQPointF()); QLineF line = QLineF(firstPoint->toQPointF(), secondPoint->toQPointF());
Calculator cal(data); Calculator cal(data);
QString errorMsg; QString errorMsg;
qreal result = cal.eval(formula, &errorMsg); qreal result = cal.eval(formula, &errorMsg);
@ -172,13 +172,13 @@ void VToolAlongLine::Create(const qint64 _id, const QString &pointName, const QS
qint64 id = _id; qint64 id = _id;
if (typeCreation == Tool::FromGui) if (typeCreation == Tool::FromGui)
{ {
id = data->AddPoint(VPointF(line.p2().x(), line.p2().y(), pointName, mx, my)); id = data->AddGObject( new VPointF(line.p2().x(), line.p2().y(), pointName, mx, my));
data->AddLine(firstPointId, id); data->AddLine(firstPointId, id);
data->AddLine(id, secondPointId); data->AddLine(id, secondPointId);
} }
else else
{ {
data->UpdatePoint(id, VPointF(line.p2().x(), line.p2().y(), pointName, mx, my)); data->UpdateGObject(id, new VPointF(line.p2().x(), line.p2().y(), pointName, mx, my));
data->AddLine(firstPointId, id); data->AddLine(firstPointId, id);
data->AddLine(id, secondPointId); data->AddLine(id, secondPointId);
if (parse != Document::FullParse) if (parse != Document::FullParse)

54
src/tools/drawTools/vtoolarc.cpp
View file

@ -36,9 +36,9 @@ VToolArc::VToolArc(VDomDocument *doc, VContainer *data, qint64 id, const Tool::S
QGraphicsItem *parent) QGraphicsItem *parent)
:VDrawTool(doc, data, id), QGraphicsPathItem(parent), dialogArc(QSharedPointer<DialogArc>()) :VDrawTool(doc, data, id), QGraphicsPathItem(parent), dialogArc(QSharedPointer<DialogArc>())
{ {
VArc arc = data->GetArc(id); const VArc *arc = data->GeometricObject<const VArc *>(id);
QPainterPath path; QPainterPath path;
path.addPath(arc.GetPath()); path.addPath(arc->GetPath());
path.setFillRule( Qt::WindingFill ); path.setFillRule( Qt::WindingFill );
this->setPath(path); this->setPath(path);
this->setPen(QPen(Qt::black, widthHairLine/factor)); this->setPen(QPen(Qt::black, widthHairLine/factor));
@ -58,11 +58,11 @@ VToolArc::VToolArc(VDomDocument *doc, VContainer *data, qint64 id, const Tool::S
void VToolArc::setDialog() void VToolArc::setDialog()
{ {
Q_ASSERT(dialogArc.isNull() == false); Q_ASSERT(dialogArc.isNull() == false);
VArc arc = VAbstractTool::data.GetArc(id); const VArc *arc = VAbstractTool::data.GeometricObject<const VArc *>(id);
dialogArc->SetCenter(arc.GetCenter()); dialogArc->SetCenter(arc->GetCenter().id());
dialogArc->SetF1(arc.GetFormulaF1()); dialogArc->SetF1(arc->GetFormulaF1());
dialogArc->SetF2(arc.GetFormulaF2()); dialogArc->SetF2(arc->GetFormulaF2());
dialogArc->SetRadius(arc.GetFormulaRadius()); dialogArc->SetRadius(arc->GetFormulaRadius());
} }
void VToolArc::Create(QSharedPointer<DialogArc> &dialog, VMainGraphicsScene *scene, VDomDocument *doc, void VToolArc::Create(QSharedPointer<DialogArc> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
@ -103,17 +103,19 @@ void VToolArc::Create(const qint64 _id, const qint64 &center, const QString &rad
calcF2 = result; calcF2 = result;
} }
VArc arc = VArc(data->DataPoints(), center, calcRadius, radius, calcF1, f1, calcF2, f2 ); VPointF c = *data->GeometricObject<const VPointF *>(center);
VArc *arc = new VArc(c, calcRadius, radius, calcF1, f1, calcF2, f2 );
Q_ASSERT(arc != 0);
qint64 id = _id; qint64 id = _id;
if (typeCreation == Tool::FromGui) if (typeCreation == Tool::FromGui)
{ {
id = data->AddArc(arc); id = data->AddGObject(arc);
data->AddLengthArc(arc.name(), toMM(arc.GetLength())); data->AddLengthArc(arc->name(), toMM(arc->GetLength()));
} }
else else
{ {
data->UpdateArc(id, arc); data->UpdateGObject(id, arc);
data->AddLengthArc(arc.name(), toMM(arc.GetLength())); data->AddLengthArc(arc->name(), toMM(arc->GetLength()));
if (parse != Document::FullParse) if (parse != Document::FullParse)
{ {
doc->UpdateToolData(id, data); doc->UpdateToolData(id, data);
@ -190,29 +192,29 @@ void VToolArc::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
void VToolArc::AddToFile() void VToolArc::AddToFile()
{ {
VArc arc = VAbstractTool::data.GetArc(id); const VArc *arc = VAbstractTool::data.GeometricObject<const VArc *>(id);
QDomElement domElement = doc->createElement(TagName); QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id); AddAttribute(domElement, AttrId, id);
AddAttribute(domElement, AttrType, ToolType); AddAttribute(domElement, AttrType, ToolType);
AddAttribute(domElement, AttrCenter, arc.GetCenter()); AddAttribute(domElement, AttrCenter, arc->GetCenter().id());
AddAttribute(domElement, AttrRadius, arc.GetFormulaRadius()); AddAttribute(domElement, AttrRadius, arc->GetFormulaRadius());
AddAttribute(domElement, AttrAngle1, arc.GetFormulaF1()); AddAttribute(domElement, AttrAngle1, arc->GetFormulaF1());
AddAttribute(domElement, AttrAngle2, arc.GetFormulaF2()); AddAttribute(domElement, AttrAngle2, arc->GetFormulaF2());
AddToCalculation(domElement); AddToCalculation(domElement);
} }
void VToolArc::RefreshDataInFile() void VToolArc::RefreshDataInFile()
{ {
VArc arc = VAbstractTool::data.GetArc(id); const VArc *arc = VAbstractTool::data.GeometricObject<const VArc *>(id);
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute(AttrCenter, arc.GetCenter()); domElement.setAttribute(AttrCenter, arc->GetCenter().id());
domElement.setAttribute(AttrRadius, arc.GetFormulaRadius()); domElement.setAttribute(AttrRadius, arc->GetFormulaRadius());
domElement.setAttribute(AttrAngle1, arc.GetFormulaF1()); domElement.setAttribute(AttrAngle1, arc->GetFormulaF1());
domElement.setAttribute(AttrAngle2, arc.GetFormulaF2()); domElement.setAttribute(AttrAngle2, arc->GetFormulaF2());
} }
} }
@ -239,16 +241,16 @@ void VToolArc::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
void VToolArc::RemoveReferens() void VToolArc::RemoveReferens()
{ {
VArc arc = VAbstractTool::data.GetArc(id); const VArc *arc = VAbstractTool::data.GeometricObject<const VArc *>(id);
doc->DecrementReferens(arc.GetCenter()); doc->DecrementReferens(arc->GetCenter().id());
} }
void VToolArc::RefreshGeometry() void VToolArc::RefreshGeometry()
{ {
this->setPen(QPen(currentColor, widthHairLine/factor)); this->setPen(QPen(currentColor, widthHairLine/factor));
VArc arc = VAbstractTool::data.GetArc(id); const VArc *arc = VAbstractTool::data.GeometricObject<const VArc *>(id);
QPainterPath path; QPainterPath path;
path.addPath(arc.GetPath()); path.addPath(arc->GetPath());
path.setFillRule( Qt::WindingFill ); path.setFillRule( Qt::WindingFill );
this->setPath(path); this->setPath(path);
} }

34
src/tools/drawTools/vtoolbisector.cpp
View file

@ -73,13 +73,13 @@ QPointF VToolBisector::FindPoint(const QPointF &firstPoint, const QPointF &secon
void VToolBisector::setDialog() void VToolBisector::setDialog()
{ {
Q_ASSERT(dialogBisector.isNull() == false); Q_ASSERT(dialogBisector.isNull() == false);
VPointF p = VAbstractTool::data.GetPoint(id); const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogBisector->setTypeLine(typeLine); dialogBisector->setTypeLine(typeLine);
dialogBisector->setFormula(formula); dialogBisector->setFormula(formula);
dialogBisector->setFirstPointId(firstPointId, id); dialogBisector->setFirstPointId(firstPointId, id);
dialogBisector->setSecondPointId(basePointId, id); dialogBisector->setSecondPointId(basePointId, id);
dialogBisector->setThirdPointId(thirdPointId, id); dialogBisector->setThirdPointId(thirdPointId, id);
dialogBisector->setPointName(p.name()); dialogBisector->setPointName(p->name());
} }
void VToolBisector::Create(QSharedPointer<DialogBisector> &dialog, VMainGraphicsScene *scene, VDomDocument *doc, void VToolBisector::Create(QSharedPointer<DialogBisector> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
@ -101,26 +101,26 @@ void VToolBisector::Create(const qint64 _id, const QString &formula, const qint6
VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data,
const Document::Documents &parse, const Tool::Sources &typeCreation) const Document::Documents &parse, const Tool::Sources &typeCreation)
{ {
VPointF firstPoint = data->GetPoint(firstPointId); const VPointF *firstPoint = data->GeometricObject<const VPointF *>(firstPointId);
VPointF secondPoint = data->GetPoint(secondPointId); const VPointF *secondPoint = data->GeometricObject<const VPointF *>(secondPointId);
VPointF thirdPoint = data->GetPoint(thirdPointId); const VPointF *thirdPoint = data->GeometricObject<const VPointF *>(thirdPointId);
Calculator cal(data); Calculator cal(data);
QString errorMsg; QString errorMsg;
qreal result = cal.eval(formula, &errorMsg); qreal result = cal.eval(formula, &errorMsg);
if (errorMsg.isEmpty()) if (errorMsg.isEmpty())
{ {
QPointF fPoint = VToolBisector::FindPoint(firstPoint.toQPointF(), secondPoint.toQPointF(), QPointF fPoint = VToolBisector::FindPoint(firstPoint->toQPointF(), secondPoint->toQPointF(),
thirdPoint.toQPointF(), toPixel(result)); thirdPoint->toQPointF(), toPixel(result));
qint64 id = _id; qint64 id = _id;
if (typeCreation == Tool::FromGui) if (typeCreation == Tool::FromGui)
{ {
id = data->AddPoint(VPointF(fPoint.x(), fPoint.y(), pointName, mx, my)); id = data->AddGObject(new VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
data->AddLine(firstPointId, id); data->AddLine(firstPointId, id);
} }
else else
{ {
data->UpdatePoint(id, VPointF(fPoint.x(), fPoint.y(), pointName, mx, my)); data->UpdateGObject(id, new VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
data->AddLine(firstPointId, id); data->AddLine(firstPointId, id);
if (parse != Document::FullParse) if (parse != Document::FullParse)
{ {
@ -190,14 +190,14 @@ void VToolBisector::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
void VToolBisector::AddToFile() void VToolBisector::AddToFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->createElement(TagName); QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id); AddAttribute(domElement, AttrId, id);
AddAttribute(domElement, AttrType, ToolType); AddAttribute(domElement, AttrType, ToolType);
AddAttribute(domElement, AttrName, point.name()); AddAttribute(domElement, AttrName, point->name());
AddAttribute(domElement, AttrMx, toMM(point.mx())); AddAttribute(domElement, AttrMx, toMM(point->mx()));
AddAttribute(domElement, AttrMy, toMM(point.my())); AddAttribute(domElement, AttrMy, toMM(point->my()));
AddAttribute(domElement, AttrTypeLine, typeLine); AddAttribute(domElement, AttrTypeLine, typeLine);
AddAttribute(domElement, AttrLength, formula); AddAttribute(domElement, AttrLength, formula);
@ -210,13 +210,13 @@ void VToolBisector::AddToFile()
void VToolBisector::RefreshDataInFile() void VToolBisector::RefreshDataInFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute(AttrMx, toMM(point.mx())); domElement.setAttribute(AttrMx, toMM(point->mx()));
domElement.setAttribute(AttrMy, toMM(point.my())); domElement.setAttribute(AttrMy, toMM(point->my()));
domElement.setAttribute(AttrName, point.name()); domElement.setAttribute(AttrName, point->name());
domElement.setAttribute(AttrTypeLine, typeLine); domElement.setAttribute(AttrTypeLine, typeLine);
domElement.setAttribute(AttrLength, formula); domElement.setAttribute(AttrLength, formula);
domElement.setAttribute(AttrFirstPoint, firstPointId); domElement.setAttribute(AttrFirstPoint, firstPointId);

72
src/tools/drawTools/vtoolcutspline.cpp
View file

@ -67,10 +67,10 @@ VToolCutSpline::VToolCutSpline(VDomDocument *doc, VContainer *data, const qint64
void VToolCutSpline::setDialog() void VToolCutSpline::setDialog()
{ {
Q_ASSERT(dialogCutSpline.isNull() == false); Q_ASSERT(dialogCutSpline.isNull() == false);
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogCutSpline->setFormula(formula); dialogCutSpline->setFormula(formula);
dialogCutSpline->setSplineId(splineId, id); dialogCutSpline->setSplineId(splineId, id);
dialogCutSpline->setPointName(point.name()); dialogCutSpline->setPointName(point->name());
} }
void VToolCutSpline::Create(QSharedPointer<DialogCutSpline> &dialog, VMainGraphicsScene *scene, void VToolCutSpline::Create(QSharedPointer<DialogCutSpline> &dialog, VMainGraphicsScene *scene,
@ -87,53 +87,61 @@ void VToolCutSpline::Create(const qint64 _id, const QString &pointName,
VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data,
const Document::Documents &parse, const Tool::Sources &typeCreation) const Document::Documents &parse, const Tool::Sources &typeCreation)
{ {
VSpline spl = data->GetSpline(splineId); const VSpline *spl = data->GeometricObject<const VSpline *>(splineId);
Calculator cal(data); Calculator cal(data);
QString errorMsg; QString errorMsg;
qreal result = cal.eval(formula, &errorMsg); qreal result = cal.eval(formula, &errorMsg);
if (errorMsg.isEmpty()) if (errorMsg.isEmpty())
{ {
QPointF spl1p2, spl1p3, spl2p2, spl2p3; QPointF spl1p2, spl1p3, spl2p2, spl2p3;
QPointF point = spl.CutSpline(toPixel(result), spl1p2, spl1p3, spl2p2, spl2p3); QPointF point = spl->CutSpline(toPixel(result), spl1p2, spl1p3, spl2p2, spl2p3);
qint64 id = _id; qint64 id = _id;
qint64 spl1id = 0; qint64 spl1id = 0;
qint64 spl2id = 0; qint64 spl2id = 0;
if (typeCreation == Tool::FromGui) if (typeCreation == Tool::FromGui)
{ {
id = data->AddPoint(VPointF(point.x(), point.y(), pointName, mx, my)); VPointF *p = new VPointF(point.x(), point.y(), pointName, mx, my);
Q_ASSERT(p != 0);
id = data->AddGObject(p);
spl1id = id + 1; spl1id = id + 1;
spl2id = id + 2; spl2id = id + 2;
VSpline spline1 = VSpline(data->DataPoints(), spl.GetP1(), spl1p2, spl1p3, id, spl.GetKcurve()); VSpline *spline1 = new VSpline(spl->GetP1(), spl1p2, spl1p3, *p, spl->GetKcurve());
spl1id = data->AddSpline(spline1); Q_ASSERT(spline1);
data->AddLengthSpline(spline1.name(), toMM(spline1.GetLength())); spl1id = data->AddGObject(spline1);
data->AddLengthSpline(spline1->name(), toMM(spline1->GetLength()));
VSpline spline2 = VSpline(data->DataPoints(), id, spl2p2, spl2p3, spl.GetP4(), spl.GetKcurve()); VSpline *spline2 = new VSpline(*p, spl2p2, spl2p3, spl->GetP4(), spl->GetKcurve());
spl2id = data->AddSpline(spline2); Q_ASSERT(spline2);
data->AddLengthSpline(spline2.name(), toMM(spline2.GetLength())); spl2id = data->AddGObject(spline2);
data->AddLengthSpline(spline2->name(), toMM(spline2->GetLength()));
} }
else else
{ {
data->UpdatePoint(id, VPointF(point.x(), point.y(), pointName, mx, my)); VPointF *p = new VPointF(point.x(), point.y(), pointName, mx, my);
Q_ASSERT(p != 0);
data->UpdateGObject(id, p);
spl1id = id + 1; spl1id = id + 1;
spl2id = id + 2; spl2id = id + 2;
VSpline spline1 = VSpline(data->DataPoints(), spl.GetP1(), spl1p2, spl1p3, id, spl.GetKcurve()); VSpline *spline1 = new VSpline(spl->GetP1(), spl1p2, spl1p3, *p, spl->GetKcurve());
data->UpdateSpline(spl1id, spline1); Q_ASSERT(spline1);
data->AddLengthSpline(spline1.name(), toMM(spline1.GetLength())); data->UpdateGObject(spl1id, spline1);
data->AddLengthSpline(spline1->name(), toMM(spline1->GetLength()));
VSpline spline2 = VSpline(data->DataPoints(), id, spl2p2, spl2p3, spl.GetP4(), spl.GetKcurve()); VSpline *spline2 = new VSpline(*p, spl2p2, spl2p3, spl->GetP4(), spl->GetKcurve());
data->UpdateSpline(spl2id, spline2); Q_ASSERT(spline2);
data->AddLengthSpline(spline2.name(), toMM(spline2.GetLength())); data->UpdateGObject(spl2id, spline2);
data->AddLengthSpline(spline2->name(), toMM(spline2->GetLength()));
if (parse != Document::FullParse) if (parse != Document::FullParse)
{ {
doc->UpdateToolData(id, data); doc->UpdateToolData(id, data);
} }
} }
//VDrawTool::AddRecord(id, Tool::CutSplineTool, doc); VDrawTool::AddRecord(id, Tool::CutSplineTool, doc);
if (parse == Document::FullParse) if (parse == Document::FullParse)
{ {
VToolCutSpline *point = new VToolCutSpline(doc, data, id, formula, splineId, spl1id, spl2id, typeCreation); VToolCutSpline *point = new VToolCutSpline(doc, data, id, formula, splineId, spl1id, spl2id, typeCreation);
@ -211,14 +219,14 @@ void VToolCutSpline::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
void VToolCutSpline::AddToFile() void VToolCutSpline::AddToFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->createElement(TagName); QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id); AddAttribute(domElement, AttrId, id);
AddAttribute(domElement, AttrType, ToolType); AddAttribute(domElement, AttrType, ToolType);
AddAttribute(domElement, AttrName, point.name()); AddAttribute(domElement, AttrName, point->name());
AddAttribute(domElement, AttrMx, toMM(point.mx())); AddAttribute(domElement, AttrMx, toMM(point->mx()));
AddAttribute(domElement, AttrMy, toMM(point.my())); AddAttribute(domElement, AttrMy, toMM(point->my()));
AddAttribute(domElement, AttrLength, formula); AddAttribute(domElement, AttrLength, formula);
AddAttribute(domElement, AttrSpline, splineId); AddAttribute(domElement, AttrSpline, splineId);
@ -228,13 +236,13 @@ void VToolCutSpline::AddToFile()
void VToolCutSpline::RefreshDataInFile() void VToolCutSpline::RefreshDataInFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute(AttrName, point.name()); domElement.setAttribute(AttrName, point->name());
domElement.setAttribute(AttrMx, toMM(point.mx())); domElement.setAttribute(AttrMx, toMM(point->mx()));
domElement.setAttribute(AttrMy, toMM(point.my())); domElement.setAttribute(AttrMy, toMM(point->my()));
domElement.setAttribute(AttrLength, formula); domElement.setAttribute(AttrLength, formula);
domElement.setAttribute(AttrSpline, splineId); domElement.setAttribute(AttrSpline, splineId);
} }
@ -244,22 +252,22 @@ void VToolCutSpline::RefreshGeometry()
{ {
RefreshSpline(firstSpline, spl1id, SimpleSpline::ForthPoint); RefreshSpline(firstSpline, spl1id, SimpleSpline::ForthPoint);
RefreshSpline(secondSpline, spl2id, SimpleSpline::FirstPoint); RefreshSpline(secondSpline, spl2id, SimpleSpline::FirstPoint);
VToolPoint::RefreshPointGeometry(VDrawTool::data.GetPoint(id)); VToolPoint::RefreshPointGeometry(*VDrawTool::data.GeometricObject<const VPointF *>(id));
} }
void VToolCutSpline::RefreshSpline(VSimpleSpline *spline, qint64 splid, SimpleSpline::Translation tr) void VToolCutSpline::RefreshSpline(VSimpleSpline *spline, qint64 splid, SimpleSpline::Translation tr)
{ {
VSpline spl = VAbstractTool::data.GetSpline(splid); const VSpline *spl = VAbstractTool::data.GeometricObject<const VSpline *>(splid);
QPainterPath path; QPainterPath path;
path.addPath(spl.GetPath()); path.addPath(spl->GetPath());
path.setFillRule( Qt::WindingFill ); path.setFillRule( Qt::WindingFill );
if(tr == SimpleSpline::FirstPoint) if(tr == SimpleSpline::FirstPoint)
{ {
path.translate(-spl.GetPointP1().toQPointF().x(), -spl.GetPointP1().toQPointF().y()); path.translate(-spl->GetP1().toQPointF().x(), -spl->GetP1().toQPointF().y());
} }
else else
{ {
path.translate(-spl.GetPointP4().toQPointF().x(), -spl.GetPointP4().toQPointF().y()); path.translate(-spl->GetP4().toQPointF().x(), -spl->GetP4().toQPointF().y());
} }
spline->setPath(path); spline->setPath(path);
} }

130
src/tools/drawTools/vtoolcutsplinepath.cpp
View file

@ -69,10 +69,10 @@ VToolCutSplinePath::VToolCutSplinePath(VDomDocument *doc, VContainer *data, cons
void VToolCutSplinePath::setDialog() void VToolCutSplinePath::setDialog()
{ {
Q_ASSERT(dialogCutSplinePath.isNull() == false); Q_ASSERT(dialogCutSplinePath.isNull() == false);
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogCutSplinePath->setFormula(formula); dialogCutSplinePath->setFormula(formula);
dialogCutSplinePath->setSplinePathId(splinePathId, id); dialogCutSplinePath->setSplinePathId(splinePathId, id);
dialogCutSplinePath->setPointName(point.name()); dialogCutSplinePath->setPointName(point->name());
} }
void VToolCutSplinePath::Create(QSharedPointer<DialogCutSplinePath> &dialog, VMainGraphicsScene *scene, void VToolCutSplinePath::Create(QSharedPointer<DialogCutSplinePath> &dialog, VMainGraphicsScene *scene,
@ -89,7 +89,7 @@ void VToolCutSplinePath::Create(const qint64 _id, const QString &pointName, cons
VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data,
const Document::Documents &parse, const Tool::Sources &typeCreation) const Document::Documents &parse, const Tool::Sources &typeCreation)
{ {
VSplinePath splPath = data->GetSplinePath(splinePathId); const VSplinePath *splPath = data->GeometricObject<const VSplinePath *>(splinePathId);
Calculator cal(data); Calculator cal(data);
QString errorMsg; QString errorMsg;
qreal result = cal.eval(formula, &errorMsg); qreal result = cal.eval(formula, &errorMsg);
@ -97,109 +97,115 @@ void VToolCutSplinePath::Create(const qint64 _id, const QString &pointName, cons
{ {
QPointF spl1p2, spl1p3, spl2p2, spl2p3; QPointF spl1p2, spl1p3, spl2p2, spl2p3;
qint32 p1 = 0, p2 = 0; qint32 p1 = 0, p2 = 0;
QPointF point = splPath.CutSplinePath(toPixel(result), p1, p2, spl1p2, spl1p3, spl2p2, spl2p3); QPointF point = splPath->CutSplinePath(toPixel(result), p1, p2, spl1p2, spl1p3, spl2p2, spl2p3);
qint64 id = _id; qint64 id = _id;
qint64 splPath1id = 0; qint64 splPath1id = 0;
qint64 splPath2id = 0; qint64 splPath2id = 0;
if (typeCreation == Tool::FromGui) if (typeCreation == Tool::FromGui)
{ {
id = data->AddPoint(VPointF(point.x(), point.y(), pointName, mx, my)); VPointF *p = new VPointF(point.x(), point.y(), pointName, mx, my);
Q_ASSERT(p);
id = data->AddGObject(p);
splPath1id = id + 1; splPath1id = id + 1;
splPath2id = id + 2; splPath2id = id + 2;
VSplinePoint splP1 = splPath[p1]; VSplinePoint splP1 = splPath->at(p1);
VSplinePoint splP2 = splPath[p2]; VSplinePoint splP2 = splPath->at(p2);
VSpline spl1 = VSpline(data->DataPoints(), splP1.P(), spl1p2, spl1p3, id, splPath.getKCurve()); VSpline spl1 = VSpline(splP1.P(), spl1p2, spl1p3, *p, splPath->getKCurve());
VSpline spl2 = VSpline(data->DataPoints(), id, spl2p2, spl2p3, splP2.P(), splPath.getKCurve()); VSpline spl2 = VSpline(*p, spl2p2, spl2p3, splP2.P(), splPath->getKCurve());
VSplinePath splPath1, splPath2; VSplinePath *splPath1 = new VSplinePath();
splPath1.setPoints(data->DataPoints()); Q_ASSERT(splPath1);
splPath2.setPoints(data->DataPoints()); VSplinePath *splPath2 = new VSplinePath();
for(qint32 i = 0; i < splPath.CountPoint(); i++) Q_ASSERT(splPath2);
for(qint32 i = 0; i < splPath->CountPoint(); i++)
{ {
if(i <= p1 && i < p2){ if(i <= p1 && i < p2){
if(i == p1) if(i == p1)
{ {
splPath1.append(VSplinePoint(splP1.P(), splP1.KAsm1(), spl1.GetAngle1(), spl1.GetKasm1())); splPath1->append(VSplinePoint(splP1.P(), splP1.KAsm1(), spl1.GetAngle1(), spl1.GetKasm1()));
VSplinePoint cutPoint = VSplinePoint(id, spl1.GetKasm2(), spl1.GetAngle2()+180, spl2.GetKasm1()); VSplinePoint cutPoint = VSplinePoint(*p, spl1.GetKasm2(), spl1.GetAngle2()+180, spl2.GetKasm1());
splPath1.append(cutPoint); splPath1->append(cutPoint);
continue; continue;
} }
splPath1.append(splPath[i]); splPath1->append(splPath->at(i));
} }
else else
{ {
if(i == p2) if(i == p2)
{ {
VSplinePoint cutPoint = VSplinePoint(id, spl1.GetKasm2(), spl2.GetAngle1(), spl2.GetKasm1()); VSplinePoint cutPoint = VSplinePoint(*p, spl1.GetKasm2(), spl2.GetAngle1(), spl2.GetKasm1());
splPath2.append(cutPoint); splPath2->append(cutPoint);
splPath2.append(VSplinePoint(splP2.P(), spl2.GetKasm2(), spl2.GetAngle2()+180, splP2.KAsm2())); splPath2->append(VSplinePoint(splP2.P(), spl2.GetKasm2(), spl2.GetAngle2()+180, splP2.KAsm2()));
continue; continue;
} }
splPath2.append(splPath[i]); splPath2->append(splPath->at(i));
} }
} }
splPath1id = data->AddSplinePath(splPath1); splPath1id = data->AddGObject(splPath1);
data->AddLengthSpline(splPath1.name(), toMM(splPath1.GetLength())); data->AddLengthSpline(splPath1->name(), toMM(splPath1->GetLength()));
splPath2id = data->AddSplinePath(splPath2); splPath2id = data->AddGObject(splPath2);
data->AddLengthSpline(splPath2.name(), toMM(splPath2.GetLength())); data->AddLengthSpline(splPath2->name(), toMM(splPath2->GetLength()));
} }
else else
{ {
data->UpdatePoint(id, VPointF(point.x(), point.y(), pointName, mx, my)); VPointF *p = new VPointF(point.x(), point.y(), pointName, mx, my);
Q_ASSERT(p);
data->UpdateGObject(id, p);
splPath1id = id + 1; splPath1id = id + 1;
splPath2id = id + 2; splPath2id = id + 2;
VSplinePoint splP1 = splPath[p1]; VSplinePoint splP1 = splPath->at(p1);
VSplinePoint splP2 = splPath[p2]; VSplinePoint splP2 = splPath->at(p2);
VSpline spl1 = VSpline(data->DataPoints(), splP1.P(), spl1p2, spl1p3, id, splPath.getKCurve()); VSpline spl1 = VSpline(splP1.P(), spl1p2, spl1p3, *p, splPath->getKCurve());
VSpline spl2 = VSpline(data->DataPoints(), id, spl2p2, spl2p3, splP2.P(), splPath.getKCurve()); VSpline spl2 = VSpline(*p, spl2p2, spl2p3, splP2.P(), splPath->getKCurve());
VSplinePath splPath1, splPath2; VSplinePath *splPath1 = new VSplinePath();
splPath1.setPoints(data->DataPoints()); Q_ASSERT(splPath1 != 0);
splPath2.setPoints(data->DataPoints()); VSplinePath *splPath2 = new VSplinePath();
for(qint32 i = 0; i < splPath.CountPoint(); i++) Q_ASSERT(splPath2 != 0);
for(qint32 i = 0; i < splPath->CountPoint(); i++)
{ {
if(i <= p1 && i < p2){ if(i <= p1 && i < p2){
if(i == p1) if(i == p1)
{ {
splPath1.append(VSplinePoint(splP1.P(), splP1.KAsm1(), spl1.GetAngle1(), spl1.GetKasm1())); splPath1->append(VSplinePoint(splP1.P(), splP1.KAsm1(), spl1.GetAngle1(), spl1.GetKasm1()));
VSplinePoint cutPoint = VSplinePoint(id, spl1.GetKasm2(), spl1.GetAngle2()+180, spl2.GetKasm1()); VSplinePoint cutPoint = VSplinePoint(*p, spl1.GetKasm2(), spl1.GetAngle2()+180, spl2.GetKasm1());
splPath1.append(cutPoint); splPath1->append(cutPoint);
continue; continue;
} }
splPath1.append(splPath[i]); splPath1->append(splPath->at(i));
} }
else else
{ {
if(i == p2) if(i == p2)
{ {
VSplinePoint cutPoint = VSplinePoint(id, spl1.GetKasm2(), spl2.GetAngle1(), spl2.GetKasm1()); VSplinePoint cutPoint = VSplinePoint(*p, spl1.GetKasm2(), spl2.GetAngle1(), spl2.GetKasm1());
splPath2.append(cutPoint); splPath2->append(cutPoint);
splPath2.append(VSplinePoint(splP2.P(), spl2.GetKasm2(), spl2.GetAngle2()+180, splP2.KAsm2())); splPath2->append(VSplinePoint(splP2.P(), spl2.GetKasm2(), spl2.GetAngle2()+180, splP2.KAsm2()));
continue; continue;
} }
splPath2.append(splPath[i]); splPath2->append(splPath->at(i));
} }
} }
data->UpdateSplinePath(splPath1id, splPath1); data->UpdateGObject(splPath1id, splPath1);
data->AddLengthSpline(splPath1.name(), toMM(splPath1.GetLength())); data->AddLengthSpline(splPath1->name(), toMM(splPath1->GetLength()));
data->UpdateSplinePath(splPath2id, splPath2); data->UpdateGObject(splPath2id, splPath2);
data->AddLengthSpline(splPath2.name(), toMM(splPath2.GetLength())); data->AddLengthSpline(splPath2->name(), toMM(splPath2->GetLength()));
if (parse != Document::FullParse) if (parse != Document::FullParse)
{ {
doc->UpdateToolData(id, data); doc->UpdateToolData(id, data);
} }
} }
//VDrawTool::AddRecord(id, Tool::CutSplineTool, doc); VDrawTool::AddRecord(id, Tool::CutSplinePathTool, doc);
if (parse == Document::FullParse) if (parse == Document::FullParse)
{ {
VToolCutSplinePath *point = new VToolCutSplinePath(doc, data, id, formula, splinePathId, splPath1id, VToolCutSplinePath *point = new VToolCutSplinePath(doc, data, id, formula, splinePathId, splPath1id,
@ -278,14 +284,14 @@ void VToolCutSplinePath::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
void VToolCutSplinePath::AddToFile() void VToolCutSplinePath::AddToFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->createElement(TagName); QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id); AddAttribute(domElement, AttrId, id);
AddAttribute(domElement, AttrType, ToolType); AddAttribute(domElement, AttrType, ToolType);
AddAttribute(domElement, AttrName, point.name()); AddAttribute(domElement, AttrName, point->name());
AddAttribute(domElement, AttrMx, toMM(point.mx())); AddAttribute(domElement, AttrMx, toMM(point->mx()));
AddAttribute(domElement, AttrMy, toMM(point.my())); AddAttribute(domElement, AttrMy, toMM(point->my()));
AddAttribute(domElement, AttrLength, formula); AddAttribute(domElement, AttrLength, formula);
AddAttribute(domElement, AttrSplinePath, splinePathId); AddAttribute(domElement, AttrSplinePath, splinePathId);
@ -295,13 +301,13 @@ void VToolCutSplinePath::AddToFile()
void VToolCutSplinePath::RefreshDataInFile() void VToolCutSplinePath::RefreshDataInFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute(AttrName, point.name()); domElement.setAttribute(AttrName, point->name());
domElement.setAttribute(AttrMx, toMM(point.mx())); domElement.setAttribute(AttrMx, toMM(point->mx()));
domElement.setAttribute(AttrMy, toMM(point.my())); domElement.setAttribute(AttrMy, toMM(point->my()));
domElement.setAttribute(AttrLength, formula); domElement.setAttribute(AttrLength, formula);
domElement.setAttribute(AttrSplinePath, splinePathId); domElement.setAttribute(AttrSplinePath, splinePathId);
} }
@ -311,24 +317,24 @@ void VToolCutSplinePath::RefreshGeometry()
{ {
RefreshSpline(firstSpline, splPath1id, SimpleSpline::ForthPoint); RefreshSpline(firstSpline, splPath1id, SimpleSpline::ForthPoint);
RefreshSpline(secondSpline, splPath2id, SimpleSpline::FirstPoint); RefreshSpline(secondSpline, splPath2id, SimpleSpline::FirstPoint);
VToolPoint::RefreshPointGeometry(VDrawTool::data.GetPoint(id)); VToolPoint::RefreshPointGeometry(*VDrawTool::data.GeometricObject<const VPointF *>(id));
} }
void VToolCutSplinePath::RefreshSpline(VSimpleSpline *spline, qint64 splPathid, SimpleSpline::Translation tr) void VToolCutSplinePath::RefreshSpline(VSimpleSpline *spline, qint64 splPathid, SimpleSpline::Translation tr)
{ {
VSplinePath splPath = VAbstractTool::data.GetSplinePath(splPathid); const VSplinePath *splPath = VAbstractTool::data.GeometricObject<const VSplinePath *>(splPathid);
QPainterPath path; QPainterPath path;
path.addPath(splPath.GetPath()); path.addPath(splPath->GetPath());
path.setFillRule( Qt::WindingFill ); path.setFillRule( Qt::WindingFill );
if(tr == SimpleSpline::FirstPoint) if(tr == SimpleSpline::FirstPoint)
{ {
VSpline spl = splPath.GetSpline(1); VSpline spl = splPath->GetSpline(1);
path.translate(-spl.GetPointP1().toQPointF().x(), -spl.GetPointP1().toQPointF().y()); path.translate(-spl.GetP1().toQPointF().x(), -spl.GetP1().toQPointF().y());
} }
else else
{ {
VSpline spl = splPath.GetSpline(splPath.Count()); VSpline spl = splPath->GetSpline(splPath->Count());
path.translate(-spl.GetPointP4().toQPointF().x(), -spl.GetPointP4().toQPointF().y()); path.translate(-spl.GetP4().toQPointF().x(), -spl.GetP4().toQPointF().y());
} }
spline->setPath(path); spline->setPath(path);
} }

28
src/tools/drawTools/vtoolendline.cpp
View file

@ -52,12 +52,12 @@ VToolEndLine::VToolEndLine(VDomDocument *doc, VContainer *data, const qint64 &id
void VToolEndLine::setDialog() void VToolEndLine::setDialog()
{ {
Q_ASSERT(dialogEndLine.isNull() == false); Q_ASSERT(dialogEndLine.isNull() == false);
VPointF p = VAbstractTool::data.GetPoint(id); const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogEndLine->setTypeLine(typeLine); dialogEndLine->setTypeLine(typeLine);
dialogEndLine->setFormula(formula); dialogEndLine->setFormula(formula);
dialogEndLine->setAngle(angle); dialogEndLine->setAngle(angle);
dialogEndLine->setBasePointId(basePointId, id); dialogEndLine->setBasePointId(basePointId, id);
dialogEndLine->setPointName(p.name()); dialogEndLine->setPointName(p->name());
} }
void VToolEndLine::Create(QSharedPointer<DialogEndLine> &dialog, VMainGraphicsScene *scene, VDomDocument *doc, void VToolEndLine::Create(QSharedPointer<DialogEndLine> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
@ -77,8 +77,8 @@ void VToolEndLine::Create(const qint64 _id, const QString &pointName, const QStr
const qreal &mx, const qreal &my, VMainGraphicsScene *scene, VDomDocument *doc, const qreal &mx, const qreal &my, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data, const Document::Documents &parse, const Tool::Sources &typeCreation) VContainer *data, const Document::Documents &parse, const Tool::Sources &typeCreation)
{ {
VPointF basePoint = data->GetPoint(basePointId); const VPointF *basePoint = data->GeometricObject<const VPointF *>(basePointId);
QLineF line = QLineF(basePoint.toQPointF(), QPointF(basePoint.x()+100, basePoint.y())); QLineF line = QLineF(basePoint->toQPointF(), QPointF(basePoint->x()+100, basePoint->y()));
Calculator cal(data); Calculator cal(data);
QString errorMsg; QString errorMsg;
qreal result = cal.eval(formula, &errorMsg); qreal result = cal.eval(formula, &errorMsg);
@ -89,12 +89,12 @@ void VToolEndLine::Create(const qint64 _id, const QString &pointName, const QStr
qint64 id = _id; qint64 id = _id;
if (typeCreation == Tool::FromGui) if (typeCreation == Tool::FromGui)
{ {
id = data->AddPoint(VPointF(line.p2().x(), line.p2().y(), pointName, mx, my)); id = data->AddGObject(new VPointF(line.p2().x(), line.p2().y(), pointName, mx, my));
data->AddLine(basePointId, id); data->AddLine(basePointId, id);
} }
else else
{ {
data->UpdatePoint(id, VPointF(line.p2().x(), line.p2().y(), pointName, mx, my)); data->UpdateGObject(id, new VPointF(line.p2().x(), line.p2().y(), pointName, mx, my));
data->AddLine(basePointId, id); data->AddLine(basePointId, id);
if (parse != Document::FullParse) if (parse != Document::FullParse)
{ {
@ -154,14 +154,14 @@ void VToolEndLine::FullUpdateFromGui(int result)
void VToolEndLine::AddToFile() void VToolEndLine::AddToFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->createElement(TagName); QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id); AddAttribute(domElement, AttrId, id);
AddAttribute(domElement, AttrType, ToolType); AddAttribute(domElement, AttrType, ToolType);
AddAttribute(domElement, AttrName, point.name()); AddAttribute(domElement, AttrName, point->name());
AddAttribute(domElement, AttrMx, toMM(point.mx())); AddAttribute(domElement, AttrMx, toMM(point->mx()));
AddAttribute(domElement, AttrMy, toMM(point.my())); AddAttribute(domElement, AttrMy, toMM(point->my()));
AddAttribute(domElement, AttrTypeLine, typeLine); AddAttribute(domElement, AttrTypeLine, typeLine);
AddAttribute(domElement, AttrLength, formula); AddAttribute(domElement, AttrLength, formula);
@ -173,13 +173,13 @@ void VToolEndLine::AddToFile()
void VToolEndLine::RefreshDataInFile() void VToolEndLine::RefreshDataInFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute(AttrName, point.name()); domElement.setAttribute(AttrName, point->name());
domElement.setAttribute(AttrMx, toMM(point.mx())); domElement.setAttribute(AttrMx, toMM(point->mx()));
domElement.setAttribute(AttrMy, toMM(point.my())); domElement.setAttribute(AttrMy, toMM(point->my()));
domElement.setAttribute(AttrTypeLine, typeLine); domElement.setAttribute(AttrTypeLine, typeLine);
domElement.setAttribute(AttrLength, formula); domElement.setAttribute(AttrLength, formula);
domElement.setAttribute(AttrAngle, angle); domElement.setAttribute(AttrAngle, angle);

32
src/tools/drawTools/vtoolheight.cpp
View file

@ -50,12 +50,12 @@ VToolHeight::VToolHeight(VDomDocument *doc, VContainer *data, const qint64 &id,
void VToolHeight::setDialog() void VToolHeight::setDialog()
{ {
Q_ASSERT(dialogHeight.isNull() == false); Q_ASSERT(dialogHeight.isNull() == false);
VPointF p = VAbstractTool::data.GetPoint(id); const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogHeight->setTypeLine(typeLine); dialogHeight->setTypeLine(typeLine);
dialogHeight->setBasePointId(basePointId, id); dialogHeight->setBasePointId(basePointId, id);
dialogHeight->setP1LineId(p1LineId, id); dialogHeight->setP1LineId(p1LineId, id);
dialogHeight->setP2LineId(p2LineId, id); dialogHeight->setP2LineId(p2LineId, id);
dialogHeight->setPointName(p.name()); dialogHeight->setPointName(p->name());
} }
void VToolHeight::Create(QSharedPointer<DialogHeight> &dialog, VMainGraphicsScene *scene, VDomDocument *doc, void VToolHeight::Create(QSharedPointer<DialogHeight> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
@ -76,22 +76,22 @@ void VToolHeight::Create(const qint64 _id, const QString &pointName, const QStri
const qreal &mx, const qreal &my, VMainGraphicsScene *scene, VDomDocument *doc, const qreal &mx, const qreal &my, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data, const Document::Documents &parse, const Tool::Sources &typeCreation) VContainer *data, const Document::Documents &parse, const Tool::Sources &typeCreation)
{ {
VPointF basePoint = data->GetPoint(basePointId); const VPointF *basePoint = data->GeometricObject<const VPointF *>(basePointId);
VPointF p1Line = data->GetPoint(p1LineId); const VPointF *p1Line = data->GeometricObject<const VPointF *>(p1LineId);
VPointF p2Line = data->GetPoint(p2LineId); const VPointF *p2Line = data->GeometricObject<const VPointF *>(p2LineId);
QPointF pHeight = FindPoint(QLineF(p1Line.toQPointF(), p2Line.toQPointF()), basePoint.toQPointF()); QPointF pHeight = FindPoint(QLineF(p1Line->toQPointF(), p2Line->toQPointF()), basePoint->toQPointF());
qint64 id = _id; qint64 id = _id;
if (typeCreation == Tool::FromGui) if (typeCreation == Tool::FromGui)
{ {
id = data->AddPoint(VPointF(pHeight.x(), pHeight.y(), pointName, mx, my)); id = data->AddGObject(new VPointF(pHeight.x(), pHeight.y(), pointName, mx, my));
data->AddLine(basePointId, id); data->AddLine(basePointId, id);
data->AddLine(p1LineId, id); data->AddLine(p1LineId, id);
data->AddLine(p2LineId, id); data->AddLine(p2LineId, id);
} }
else else
{ {
data->UpdatePoint(id, VPointF(pHeight.x(), pHeight.y(), pointName, mx, my)); data->UpdateGObject(id, new VPointF(pHeight.x(), pHeight.y(), pointName, mx, my));
data->AddLine(basePointId, id); data->AddLine(basePointId, id);
data->AddLine(p1LineId, id); data->AddLine(p1LineId, id);
data->AddLine(p2LineId, id); data->AddLine(p2LineId, id);
@ -174,14 +174,14 @@ void VToolHeight::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
void VToolHeight::AddToFile() void VToolHeight::AddToFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->createElement(TagName); QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id); AddAttribute(domElement, AttrId, id);
AddAttribute(domElement, AttrType, ToolType); AddAttribute(domElement, AttrType, ToolType);
AddAttribute(domElement, AttrName, point.name()); AddAttribute(domElement, AttrName, point->name());
AddAttribute(domElement, AttrMx, toMM(point.mx())); AddAttribute(domElement, AttrMx, toMM(point->mx()));
AddAttribute(domElement, AttrMy, toMM(point.my())); AddAttribute(domElement, AttrMy, toMM(point->my()));
AddAttribute(domElement, AttrTypeLine, typeLine); AddAttribute(domElement, AttrTypeLine, typeLine);
AddAttribute(domElement, AttrBasePoint, basePointId); AddAttribute(domElement, AttrBasePoint, basePointId);
@ -194,13 +194,13 @@ void VToolHeight::AddToFile()
void VToolHeight::RefreshDataInFile() void VToolHeight::RefreshDataInFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute(AttrName, point.name()); domElement.setAttribute(AttrName, point->name());
domElement.setAttribute(AttrMx, toMM(point.mx())); domElement.setAttribute(AttrMx, toMM(point->mx()));
domElement.setAttribute(AttrMy, toMM(point.my())); domElement.setAttribute(AttrMy, toMM(point->my()));
domElement.setAttribute(AttrTypeLine, typeLine); domElement.setAttribute(AttrTypeLine, typeLine);
domElement.setAttribute(AttrBasePoint, basePointId); domElement.setAttribute(AttrBasePoint, basePointId);
domElement.setAttribute(AttrP1Line, p1LineId); domElement.setAttribute(AttrP1Line, p1LineId);

14
src/tools/drawTools/vtoolline.cpp
View file

@ -36,10 +36,10 @@ VToolLine::VToolLine(VDomDocument *doc, VContainer *data, qint64 id, qint64 firs
dialogLine(QSharedPointer<DialogLine>()) dialogLine(QSharedPointer<DialogLine>())
{ {
ignoreFullUpdate = true; ignoreFullUpdate = true;
//Лінія //Line
VPointF first = data->GetPoint(firstPoint); const VPointF *first = data->GeometricObject<const VPointF *>(firstPoint);
VPointF second = data->GetPoint(secondPoint); const VPointF *second = data->GeometricObject<const VPointF *>(secondPoint);
this->setLine(QLineF(first.toQPointF(), second.toQPointF())); this->setLine(QLineF(first->toQPointF(), second->toQPointF()));
this->setFlag(QGraphicsItem::ItemStacksBehindParent, true); this->setFlag(QGraphicsItem::ItemStacksBehindParent, true);
this->setFlag(QGraphicsItem::ItemIsSelectable, true); this->setFlag(QGraphicsItem::ItemIsSelectable, true);
this->setAcceptHoverEvents(true); this->setAcceptHoverEvents(true);
@ -206,8 +206,8 @@ void VToolLine::RefreshGeometry()
firstPoint = domElement.attribute(AttrFirstPoint, "").toLongLong(); firstPoint = domElement.attribute(AttrFirstPoint, "").toLongLong();
secondPoint = domElement.attribute(AttrSecondPoint, "").toLongLong(); secondPoint = domElement.attribute(AttrSecondPoint, "").toLongLong();
} }
VPointF first = VAbstractTool::data.GetPoint(firstPoint); const VPointF *first = VAbstractTool::data.GeometricObject<const VPointF *>(firstPoint);
VPointF second = VAbstractTool::data.GetPoint(secondPoint); const VPointF *second = VAbstractTool::data.GeometricObject<const VPointF *>(secondPoint);
this->setLine(QLineF(first.toQPointF(), second.toQPointF())); this->setLine(QLineF(first->toQPointF(), second->toQPointF()));
this->setPen(QPen(currentColor, widthHairLine/factor)); this->setPen(QPen(currentColor, widthHairLine/factor));
} }

40
src/tools/drawTools/vtoollineintersect.cpp
View file

@ -51,12 +51,12 @@ VToolLineIntersect::VToolLineIntersect(VDomDocument *doc, VContainer *data, cons
void VToolLineIntersect::setDialog() void VToolLineIntersect::setDialog()
{ {
Q_ASSERT(dialogLineIntersect.isNull() == false); Q_ASSERT(dialogLineIntersect.isNull() == false);
VPointF p = VAbstractTool::data.GetPoint(id); const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogLineIntersect->setP1Line1(p1Line1); dialogLineIntersect->setP1Line1(p1Line1);
dialogLineIntersect->setP2Line1(p2Line1); dialogLineIntersect->setP2Line1(p2Line1);
dialogLineIntersect->setP1Line2(p1Line2); dialogLineIntersect->setP1Line2(p1Line2);
dialogLineIntersect->setP2Line2(p2Line2); dialogLineIntersect->setP2Line2(p2Line2);
dialogLineIntersect->setPointName(p.name()); dialogLineIntersect->setPointName(p->name());
} }
void VToolLineIntersect::Create(QSharedPointer<DialogLineIntersect> &dialog, VMainGraphicsScene *scene, void VToolLineIntersect::Create(QSharedPointer<DialogLineIntersect> &dialog, VMainGraphicsScene *scene,
@ -77,13 +77,13 @@ void VToolLineIntersect::Create(const qint64 _id, const qint64 &p1Line1Id, const
VDomDocument *doc, VContainer *data, const Document::Documents &parse, VDomDocument *doc, VContainer *data, const Document::Documents &parse,
const Tool::Sources &typeCreation) const Tool::Sources &typeCreation)
{ {
VPointF p1Line1 = data->GetPoint(p1Line1Id); const VPointF *p1Line1 = data->GeometricObject<const VPointF *>(p1Line1Id);
VPointF p2Line1 = data->GetPoint(p2Line1Id); const VPointF *p2Line1 = data->GeometricObject<const VPointF *>(p2Line1Id);
VPointF p1Line2 = data->GetPoint(p1Line2Id); const VPointF *p1Line2 = data->GeometricObject<const VPointF *>(p1Line2Id);
VPointF p2Line2 = data->GetPoint(p2Line2Id); const VPointF *p2Line2 = data->GeometricObject<const VPointF *>(p2Line2Id);
QLineF line1(p1Line1.toQPointF(), p2Line1.toQPointF()); QLineF line1(p1Line1->toQPointF(), p2Line1->toQPointF());
QLineF line2(p1Line2.toQPointF(), p2Line2.toQPointF()); QLineF line2(p1Line2->toQPointF(), p2Line2->toQPointF());
QPointF fPoint; QPointF fPoint;
QLineF::IntersectType intersect = line1.intersect(line2, &fPoint); QLineF::IntersectType intersect = line1.intersect(line2, &fPoint);
if (intersect == QLineF::UnboundedIntersection || intersect == QLineF::BoundedIntersection) if (intersect == QLineF::UnboundedIntersection || intersect == QLineF::BoundedIntersection)
@ -91,7 +91,7 @@ void VToolLineIntersect::Create(const qint64 _id, const qint64 &p1Line1Id, const
qint64 id = _id; qint64 id = _id;
if (typeCreation == Tool::FromGui) if (typeCreation == Tool::FromGui)
{ {
id = data->AddPoint(VPointF(fPoint.x(), fPoint.y(), pointName, mx, my)); id = data->AddGObject(new VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
data->AddLine(p1Line1Id, id); data->AddLine(p1Line1Id, id);
data->AddLine(id, p2Line1Id); data->AddLine(id, p2Line1Id);
data->AddLine(p1Line2Id, id); data->AddLine(p1Line2Id, id);
@ -99,7 +99,7 @@ void VToolLineIntersect::Create(const qint64 _id, const qint64 &p1Line1Id, const
} }
else else
{ {
data->UpdatePoint(id, VPointF(fPoint.x(), fPoint.y(), pointName, mx, my)); data->UpdateGObject(id, new VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
data->AddLine(p1Line1Id, id); data->AddLine(p1Line1Id, id);
data->AddLine(id, p2Line1Id); data->AddLine(id, p2Line1Id);
data->AddLine(p1Line2Id, id); data->AddLine(p1Line2Id, id);
@ -137,7 +137,7 @@ void VToolLineIntersect::FullUpdateFromFile()
p1Line2 = domElement.attribute(AttrP1Line2, "").toLongLong(); p1Line2 = domElement.attribute(AttrP1Line2, "").toLongLong();
p2Line2 = domElement.attribute(AttrP2Line2, "").toLongLong(); p2Line2 = domElement.attribute(AttrP2Line2, "").toLongLong();
} }
RefreshPointGeometry(VAbstractTool::data.GetPoint(id)); RefreshPointGeometry(*VAbstractTool::data.GeometricObject<const VPointF *>(id));
} }
void VToolLineIntersect::FullUpdateFromGui(int result) void VToolLineIntersect::FullUpdateFromGui(int result)
@ -161,7 +161,7 @@ void VToolLineIntersect::FullUpdateFromGui(int result)
void VToolLineIntersect::SetFactor(qreal factor) void VToolLineIntersect::SetFactor(qreal factor)
{ {
VDrawTool::SetFactor(factor); VDrawTool::SetFactor(factor);
RefreshPointGeometry(VAbstractTool::data.GetPoint(id)); RefreshPointGeometry(*VAbstractTool::data.GeometricObject<const VPointF *>(id));
} }
void VToolLineIntersect::contextMenuEvent(QGraphicsSceneContextMenuEvent *event) void VToolLineIntersect::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
@ -171,14 +171,14 @@ void VToolLineIntersect::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
void VToolLineIntersect::AddToFile() void VToolLineIntersect::AddToFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->createElement(TagName); QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id); AddAttribute(domElement, AttrId, id);
AddAttribute(domElement, AttrType, ToolType); AddAttribute(domElement, AttrType, ToolType);
AddAttribute(domElement, AttrName, point.name()); AddAttribute(domElement, AttrName, point->name());
AddAttribute(domElement, AttrMx, toMM(point.mx())); AddAttribute(domElement, AttrMx, toMM(point->mx()));
AddAttribute(domElement, AttrMy, toMM(point.my())); AddAttribute(domElement, AttrMy, toMM(point->my()));
AddAttribute(domElement, AttrP1Line1, p1Line1); AddAttribute(domElement, AttrP1Line1, p1Line1);
AddAttribute(domElement, AttrP2Line1, p2Line1); AddAttribute(domElement, AttrP2Line1, p2Line1);
@ -190,13 +190,13 @@ void VToolLineIntersect::AddToFile()
void VToolLineIntersect::RefreshDataInFile() void VToolLineIntersect::RefreshDataInFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute(AttrName, point.name()); domElement.setAttribute(AttrName, point->name());
domElement.setAttribute(AttrMx, toMM(point.mx())); domElement.setAttribute(AttrMx, toMM(point->mx()));
domElement.setAttribute(AttrMy, toMM(point.my())); domElement.setAttribute(AttrMy, toMM(point->my()));
domElement.setAttribute(AttrP1Line1, p1Line1); domElement.setAttribute(AttrP1Line1, p1Line1);
domElement.setAttribute(AttrP2Line1, p2Line1); domElement.setAttribute(AttrP2Line1, p2Line1);
domElement.setAttribute(AttrP1Line2, p1Line2); domElement.setAttribute(AttrP1Line2, p1Line2);

10
src/tools/drawTools/vtoollinepoint.cpp
View file

@ -35,8 +35,8 @@ VToolLinePoint::VToolLinePoint(VDomDocument *doc, VContainer *data, const qint64
mainLine(0) mainLine(0)
{ {
Q_ASSERT_X(basePointId > 0, Q_FUNC_INFO, "basePointId <= 0"); Q_ASSERT_X(basePointId > 0, Q_FUNC_INFO, "basePointId <= 0");
QPointF point1 = data->GetPoint(basePointId).toQPointF(); QPointF point1 = data->GeometricObject<const VPointF *>(basePointId)->toQPointF();
QPointF point2 = data->GetPoint(id).toQPointF(); QPointF point2 = data->GeometricObject<const VPointF *>(id)->toQPointF();
mainLine = new QGraphicsLineItem(QLineF(point1 - point2, QPointF()), this); mainLine = new QGraphicsLineItem(QLineF(point1 - point2, QPointF()), this);
mainLine->setPen(QPen(Qt::black, widthHairLine/factor)); mainLine->setPen(QPen(Qt::black, widthHairLine/factor));
mainLine->setFlag(QGraphicsItem::ItemStacksBehindParent, true); mainLine->setFlag(QGraphicsItem::ItemStacksBehindParent, true);
@ -67,9 +67,9 @@ void VToolLinePoint::ChangedActivDraw(const QString &newName)
void VToolLinePoint::RefreshGeometry() void VToolLinePoint::RefreshGeometry()
{ {
mainLine->setPen(QPen(currentColor, widthHairLine/factor)); mainLine->setPen(QPen(currentColor, widthHairLine/factor));
VToolPoint::RefreshPointGeometry(VDrawTool::data.GetPoint(id)); VToolPoint::RefreshPointGeometry(*VDrawTool::data.GeometricObject<const VPointF *>(id));
QPointF point = VDrawTool::data.GetPoint(id).toQPointF(); QPointF point = VDrawTool::data.GeometricObject<const VPointF *>(id)->toQPointF();
QPointF basePoint = VDrawTool::data.GetPoint(basePointId).toQPointF(); QPointF basePoint = VDrawTool::data.GeometricObject<const VPointF *>(basePointId)->toQPointF();
mainLine->setLine(QLineF(basePoint - point, QPointF())); mainLine->setLine(QLineF(basePoint - point, QPointF()));
if (typeLine == TypeLineNone) if (typeLine == TypeLineNone)
{ {

30
src/tools/drawTools/vtoolnormal.cpp
View file

@ -51,13 +51,13 @@ VToolNormal::VToolNormal(VDomDocument *doc, VContainer *data, const qint64 &id,
void VToolNormal::setDialog() void VToolNormal::setDialog()
{ {
Q_ASSERT(dialogNormal.isNull() == false); Q_ASSERT(dialogNormal.isNull() == false);
VPointF p = VAbstractTool::data.GetPoint(id); const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogNormal->setTypeLine(typeLine); dialogNormal->setTypeLine(typeLine);
dialogNormal->setFormula(formula); dialogNormal->setFormula(formula);
dialogNormal->setAngle(angle); dialogNormal->setAngle(angle);
dialogNormal->setFirstPointId(basePointId, id); dialogNormal->setFirstPointId(basePointId, id);
dialogNormal->setSecondPointId(secondPointId, id); dialogNormal->setSecondPointId(secondPointId, id);
dialogNormal->setPointName(p.name()); dialogNormal->setPointName(p->name());
} }
void VToolNormal::Create(QSharedPointer<DialogNormal> &dialog, VMainGraphicsScene *scene, VDomDocument *doc, void VToolNormal::Create(QSharedPointer<DialogNormal> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
@ -79,24 +79,24 @@ void VToolNormal::Create(const qint64 _id, const QString &formula, const qint64
VDomDocument *doc, VContainer *data, const Document::Documents &parse, VDomDocument *doc, VContainer *data, const Document::Documents &parse,
const Tool::Sources &typeCreation) const Tool::Sources &typeCreation)
{ {
VPointF firstPoint = data->GetPoint(firstPointId); const VPointF *firstPoint = data->GeometricObject<const VPointF *>(firstPointId);
VPointF secondPoint = data->GetPoint(secondPointId); const VPointF *secondPoint = data->GeometricObject<const VPointF *>(secondPointId);
Calculator cal(data); Calculator cal(data);
QString errorMsg; QString errorMsg;
qreal result = cal.eval(formula, &errorMsg); qreal result = cal.eval(formula, &errorMsg);
if (errorMsg.isEmpty()) if (errorMsg.isEmpty())
{ {
QPointF fPoint = VToolNormal::FindPoint(firstPoint.toQPointF(), secondPoint.toQPointF(), QPointF fPoint = VToolNormal::FindPoint(firstPoint->toQPointF(), secondPoint->toQPointF(),
toPixel(result), angle); toPixel(result), angle);
qint64 id = _id; qint64 id = _id;
if (typeCreation == Tool::FromGui) if (typeCreation == Tool::FromGui)
{ {
id = data->AddPoint(VPointF(fPoint.x(), fPoint.y(), pointName, mx, my)); id = data->AddGObject(new VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
data->AddLine(firstPointId, id); data->AddLine(firstPointId, id);
} }
else else
{ {
data->UpdatePoint(id, VPointF(fPoint.x(), fPoint.y(), pointName, mx, my)); data->UpdateGObject(id, new VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
data->AddLine(firstPointId, id); data->AddLine(firstPointId, id);
if (parse != Document::FullParse) if (parse != Document::FullParse)
{ {
@ -175,14 +175,14 @@ void VToolNormal::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
void VToolNormal::AddToFile() void VToolNormal::AddToFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->createElement(TagName); QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id); AddAttribute(domElement, AttrId, id);
AddAttribute(domElement, AttrType, ToolType); AddAttribute(domElement, AttrType, ToolType);
AddAttribute(domElement, AttrName, point.name()); AddAttribute(domElement, AttrName, point->name());
AddAttribute(domElement, AttrMx, toMM(point.mx())); AddAttribute(domElement, AttrMx, toMM(point->mx()));
AddAttribute(domElement, AttrMy, toMM(point.my())); AddAttribute(domElement, AttrMy, toMM(point->my()));
AddAttribute(domElement, AttrTypeLine, typeLine); AddAttribute(domElement, AttrTypeLine, typeLine);
AddAttribute(domElement, AttrLength, formula); AddAttribute(domElement, AttrLength, formula);
@ -195,13 +195,13 @@ void VToolNormal::AddToFile()
void VToolNormal::RefreshDataInFile() void VToolNormal::RefreshDataInFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute(AttrName, point.name()); domElement.setAttribute(AttrName, point->name());
domElement.setAttribute(AttrMx, toMM(point.mx())); domElement.setAttribute(AttrMx, toMM(point->mx()));
domElement.setAttribute(AttrMy, toMM(point.my())); domElement.setAttribute(AttrMy, toMM(point->my()));
domElement.setAttribute(AttrTypeLine, typeLine); domElement.setAttribute(AttrTypeLine, typeLine);
domElement.setAttribute(AttrLength, formula); domElement.setAttribute(AttrLength, formula);
domElement.setAttribute(AttrAngle, angle); domElement.setAttribute(AttrAngle, angle);

19
src/tools/drawTools/vtoolpoint.cpp
View file

@ -40,18 +40,19 @@ VToolPoint::VToolPoint(VDomDocument *doc, VContainer *data, qint64 id, QGraphics
this->setBrush(QBrush(Qt::NoBrush)); this->setBrush(QBrush(Qt::NoBrush));
this->setFlag(QGraphicsItem::ItemIsSelectable, true); this->setFlag(QGraphicsItem::ItemIsSelectable, true);
this->setAcceptHoverEvents(true); this->setAcceptHoverEvents(true);
RefreshPointGeometry(VAbstractTool::data.GetPoint(id)); RefreshPointGeometry(*VAbstractTool::data.GeometricObject<const VPointF *>(id));
} }
void VToolPoint::NameChangePosition(const QPointF &pos) void VToolPoint::NameChangePosition(const QPointF &pos)
{ {
VPointF point = VAbstractTool::data.GetPoint(id); VPointF *point = new VPointF(*VAbstractTool::data.GeometricObject<const VPointF *>(id));
Q_ASSERT(point != 0);
QPointF p = pos - this->pos(); QPointF p = pos - this->pos();
point.setMx(p.x()); point->setMx(p.x());
point.setMy(p.y()); point->setMy(p.y());
RefreshLine(); RefreshLine();
UpdateNamePosition(point.mx(), point.my()); UpdateNamePosition(point->mx(), point->my());
VAbstractTool::data.UpdatePoint(id, point); VAbstractTool::data.UpdateGObject(id, point);
} }
void VToolPoint::UpdateNamePosition(qreal mx, qreal my) void VToolPoint::UpdateNamePosition(qreal mx, qreal my)
@ -59,8 +60,8 @@ void VToolPoint::UpdateNamePosition(qreal mx, qreal my)
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute(AttrMx, QString().setNum(toMM(mx))); domElement.setAttribute(AttrMx, toMM(mx));
domElement.setAttribute(AttrMy, QString().setNum(toMM(my))); domElement.setAttribute(AttrMy, toMM(my));
emit toolhaveChange(); emit toolhaveChange();
} }
} }
@ -98,7 +99,7 @@ void VToolPoint::ShowTool(qint64 id, Qt::GlobalColor color, bool enable)
void VToolPoint::SetFactor(qreal factor) void VToolPoint::SetFactor(qreal factor)
{ {
VDrawTool::SetFactor(factor); VDrawTool::SetFactor(factor);
RefreshPointGeometry(VAbstractTool::data.GetPoint(id)); RefreshPointGeometry(*VAbstractTool::data.GeometricObject<const VPointF *>(id));
} }
void VToolPoint::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) void VToolPoint::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)

38
src/tools/drawTools/vtoolpointofcontact.cpp
View file

@ -51,12 +51,12 @@ VToolPointOfContact::VToolPointOfContact(VDomDocument *doc, VContainer *data, co
void VToolPointOfContact::setDialog() void VToolPointOfContact::setDialog()
{ {
Q_ASSERT(dialogPointOfContact.isNull() == false); Q_ASSERT(dialogPointOfContact.isNull() == false);
VPointF p = VAbstractTool::data.GetPoint(id); const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogPointOfContact->setRadius(radius); dialogPointOfContact->setRadius(radius);
dialogPointOfContact->setCenter(center, id); dialogPointOfContact->setCenter(center, id);
dialogPointOfContact->setFirstPoint(firstPointId, id); dialogPointOfContact->setFirstPoint(firstPointId, id);
dialogPointOfContact->setSecondPoint(secondPointId, id); dialogPointOfContact->setSecondPoint(secondPointId, id);
dialogPointOfContact->setPointName(p.name()); dialogPointOfContact->setPointName(p->name());
} }
QPointF VToolPointOfContact::FindPoint(const qreal &radius, const QPointF &center, const QPointF &firstPoint, QPointF VToolPointOfContact::FindPoint(const qreal &radius, const QPointF &center, const QPointF &firstPoint,
@ -103,28 +103,28 @@ void VToolPointOfContact::Create(const qint64 _id, const QString &radius, const
VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data,
const Document::Documents &parse, const Tool::Sources &typeCreation) const Document::Documents &parse, const Tool::Sources &typeCreation)
{ {
VPointF centerP = data->GetPoint(center); const VPointF *centerP = data->GeometricObject<const VPointF *>(center);
VPointF firstP = data->GetPoint(firstPointId); const VPointF *firstP = data->GeometricObject<const VPointF *>(firstPointId);
VPointF secondP = data->GetPoint(secondPointId); const VPointF *secondP = data->GeometricObject<const VPointF *>(secondPointId);
Calculator cal(data); Calculator cal(data);
QString errorMsg; QString errorMsg;
qreal result = cal.eval(radius, &errorMsg); qreal result = cal.eval(radius, &errorMsg);
if (errorMsg.isEmpty()) if (errorMsg.isEmpty())
{ {
QPointF fPoint = VToolPointOfContact::FindPoint(toPixel(result), centerP.toQPointF(), QPointF fPoint = VToolPointOfContact::FindPoint(toPixel(result), centerP->toQPointF(),
firstP.toQPointF(), secondP.toQPointF()); firstP->toQPointF(), secondP->toQPointF());
qint64 id = _id; qint64 id = _id;
if (typeCreation == Tool::FromGui) if (typeCreation == Tool::FromGui)
{ {
id = data->AddPoint(VPointF(fPoint.x(), fPoint.y(), pointName, mx, my)); id = data->AddGObject(new VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
data->AddLine(firstPointId, id); data->AddLine(firstPointId, id);
data->AddLine(secondPointId, id); data->AddLine(secondPointId, id);
data->AddLine(center, id); data->AddLine(center, id);
} }
else else
{ {
data->UpdatePoint(id, VPointF(fPoint.x(), fPoint.y(), pointName, mx, my)); data->UpdateGObject(id, new VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
data->AddLine(firstPointId, id); data->AddLine(firstPointId, id);
data->AddLine(secondPointId, id); data->AddLine(secondPointId, id);
data->AddLine(center, id); data->AddLine(center, id);
@ -160,7 +160,7 @@ void VToolPointOfContact::FullUpdateFromFile()
firstPointId = domElement.attribute(AttrFirstPoint, "").toLongLong(); firstPointId = domElement.attribute(AttrFirstPoint, "").toLongLong();
secondPointId = domElement.attribute(AttrSecondPoint, "").toLongLong(); secondPointId = domElement.attribute(AttrSecondPoint, "").toLongLong();
} }
RefreshPointGeometry(VAbstractTool::data.GetPoint(id)); RefreshPointGeometry(*VAbstractTool::data.GeometricObject<const VPointF *>(id));
} }
void VToolPointOfContact::FullUpdateFromGui(int result) void VToolPointOfContact::FullUpdateFromGui(int result)
@ -184,7 +184,7 @@ void VToolPointOfContact::FullUpdateFromGui(int result)
void VToolPointOfContact::SetFactor(qreal factor) void VToolPointOfContact::SetFactor(qreal factor)
{ {
VDrawTool::SetFactor(factor); VDrawTool::SetFactor(factor);
RefreshPointGeometry(VAbstractTool::data.GetPoint(id)); RefreshPointGeometry(*VAbstractTool::data.GeometricObject<const VPointF *>(id));
} }
void VToolPointOfContact::contextMenuEvent(QGraphicsSceneContextMenuEvent *event) void VToolPointOfContact::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
@ -194,14 +194,14 @@ void VToolPointOfContact::contextMenuEvent(QGraphicsSceneContextMenuEvent *event
void VToolPointOfContact::AddToFile() void VToolPointOfContact::AddToFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->createElement(TagName); QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id); AddAttribute(domElement, AttrId, id);
AddAttribute(domElement, AttrType, ToolType); AddAttribute(domElement, AttrType, ToolType);
AddAttribute(domElement, AttrName, point.name()); AddAttribute(domElement, AttrName, point->name());
AddAttribute(domElement, AttrMx, toMM(point.mx())); AddAttribute(domElement, AttrMx, toMM(point->mx()));
AddAttribute(domElement, AttrMy, toMM(point.my())); AddAttribute(domElement, AttrMy, toMM(point->my()));
AddAttribute(domElement, AttrRadius, radius); AddAttribute(domElement, AttrRadius, radius);
AddAttribute(domElement, AttrCenter, center); AddAttribute(domElement, AttrCenter, center);
@ -213,13 +213,13 @@ void VToolPointOfContact::AddToFile()
void VToolPointOfContact::RefreshDataInFile() void VToolPointOfContact::RefreshDataInFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute(AttrName, point.name()); domElement.setAttribute(AttrName, point->name());
domElement.setAttribute(AttrMx, toMM(point.mx())); domElement.setAttribute(AttrMx, toMM(point->mx()));
domElement.setAttribute(AttrMy, toMM(point.my())); domElement.setAttribute(AttrMy, toMM(point->my()));
domElement.setAttribute(AttrRadius, radius); domElement.setAttribute(AttrRadius, radius);
domElement.setAttribute(AttrCenter, center); domElement.setAttribute(AttrCenter, center);
domElement.setAttribute(AttrFirstPoint, firstPointId); domElement.setAttribute(AttrFirstPoint, firstPointId);

32
src/tools/drawTools/vtoolpointofintersection.cpp
View file

@ -50,10 +50,10 @@ VToolPointOfIntersection::VToolPointOfIntersection(VDomDocument *doc, VContainer
void VToolPointOfIntersection::setDialog() void VToolPointOfIntersection::setDialog()
{ {
Q_ASSERT(dialogPointOfIntersection.isNull() == false); Q_ASSERT(dialogPointOfIntersection.isNull() == false);
VPointF p = VAbstractTool::data.GetPoint(id); const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogPointOfIntersection->setFirstPointId(firstPointId, id); dialogPointOfIntersection->setFirstPointId(firstPointId, id);
dialogPointOfIntersection->setSecondPointId(secondPointId, id); dialogPointOfIntersection->setSecondPointId(secondPointId, id);
dialogPointOfIntersection->setPointName(p.name()); dialogPointOfIntersection->setPointName(p->name());
} }
void VToolPointOfIntersection::Create(QSharedPointer<DialogPointOfIntersection> &dialog, VMainGraphicsScene *scene, void VToolPointOfIntersection::Create(QSharedPointer<DialogPointOfIntersection> &dialog, VMainGraphicsScene *scene,
@ -70,18 +70,18 @@ void VToolPointOfIntersection::Create(const qint64 _id, const QString &pointName
VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data,
const Document::Documents &parse, const Tool::Sources &typeCreation) const Document::Documents &parse, const Tool::Sources &typeCreation)
{ {
VPointF firstPoint = data->GetPoint(firstPointId); const VPointF *firstPoint = data->GeometricObject<const VPointF *>(firstPointId);
VPointF secondPoint = data->GetPoint(secondPointId); const VPointF *secondPoint = data->GeometricObject<const VPointF *>(secondPointId);
QPointF point(firstPoint.x(), secondPoint.y()); QPointF point(firstPoint->x(), secondPoint->y());
qint64 id = _id; qint64 id = _id;
if (typeCreation == Tool::FromGui) if (typeCreation == Tool::FromGui)
{ {
id = data->AddPoint(VPointF(point.x(), point.y(), pointName, mx, my)); id = data->AddGObject(new VPointF(point.x(), point.y(), pointName, mx, my));
} }
else else
{ {
data->UpdatePoint(id, VPointF(point.x(), point.y(), pointName, mx, my)); data->UpdateGObject(id, new VPointF(point.x(), point.y(), pointName, mx, my));
if (parse != Document::FullParse) if (parse != Document::FullParse)
{ {
doc->UpdateToolData(id, data); doc->UpdateToolData(id, data);
@ -110,7 +110,7 @@ void VToolPointOfIntersection::FullUpdateFromFile()
firstPointId = domElement.attribute(AttrFirstPoint, "").toLongLong(); firstPointId = domElement.attribute(AttrFirstPoint, "").toLongLong();
secondPointId = domElement.attribute(AttrSecondPoint, "").toLongLong(); secondPointId = domElement.attribute(AttrSecondPoint, "").toLongLong();
} }
VToolPoint::RefreshPointGeometry(VDrawTool::data.GetPoint(id)); VToolPoint::RefreshPointGeometry(*VDrawTool::data.GeometricObject<const VPointF *>(id));
} }
void VToolPointOfIntersection::FullUpdateFromGui(int result) void VToolPointOfIntersection::FullUpdateFromGui(int result)
@ -142,14 +142,14 @@ void VToolPointOfIntersection::contextMenuEvent(QGraphicsSceneContextMenuEvent *
void VToolPointOfIntersection::AddToFile() void VToolPointOfIntersection::AddToFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->createElement(TagName); QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id); AddAttribute(domElement, AttrId, id);
AddAttribute(domElement, AttrType, ToolType); AddAttribute(domElement, AttrType, ToolType);
AddAttribute(domElement, AttrName, point.name()); AddAttribute(domElement, AttrName, point->name());
AddAttribute(domElement, AttrMx, toMM(point.mx())); AddAttribute(domElement, AttrMx, toMM(point->mx()));
AddAttribute(domElement, AttrMy, toMM(point.my())); AddAttribute(domElement, AttrMy, toMM(point->my()));
AddAttribute(domElement, AttrFirstPoint, firstPointId); AddAttribute(domElement, AttrFirstPoint, firstPointId);
AddAttribute(domElement, AttrSecondPoint, secondPointId); AddAttribute(domElement, AttrSecondPoint, secondPointId);
@ -159,13 +159,13 @@ void VToolPointOfIntersection::AddToFile()
void VToolPointOfIntersection::RefreshDataInFile() void VToolPointOfIntersection::RefreshDataInFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute(AttrName, point.name()); domElement.setAttribute(AttrName, point->name());
domElement.setAttribute(AttrName, toMM(point.mx())); domElement.setAttribute(AttrName, toMM(point->mx()));
domElement.setAttribute(AttrName, toMM(point.my())); domElement.setAttribute(AttrName, toMM(point->my()));
domElement.setAttribute(AttrFirstPoint, firstPointId); domElement.setAttribute(AttrFirstPoint, firstPointId);
domElement.setAttribute(AttrSecondPoint, secondPointId); domElement.setAttribute(AttrSecondPoint, secondPointId);
} }

34
src/tools/drawTools/vtoolshoulderpoint.cpp
View file

@ -51,13 +51,13 @@ VToolShoulderPoint::VToolShoulderPoint(VDomDocument *doc, VContainer *data, cons
void VToolShoulderPoint::setDialog() void VToolShoulderPoint::setDialog()
{ {
Q_ASSERT(dialogShoulderPoint.isNull() == false); Q_ASSERT(dialogShoulderPoint.isNull() == false);
VPointF p = VAbstractTool::data.GetPoint(id); const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogShoulderPoint->setTypeLine(typeLine); dialogShoulderPoint->setTypeLine(typeLine);
dialogShoulderPoint->setFormula(formula); dialogShoulderPoint->setFormula(formula);
dialogShoulderPoint->setP1Line(basePointId, id); dialogShoulderPoint->setP1Line(basePointId, id);
dialogShoulderPoint->setP2Line(p2Line, id); dialogShoulderPoint->setP2Line(p2Line, id);
dialogShoulderPoint->setPShoulder(pShoulder, id); dialogShoulderPoint->setPShoulder(pShoulder, id);
dialogShoulderPoint->setPointName(p.name()); dialogShoulderPoint->setPointName(p->name());
} }
QPointF VToolShoulderPoint::FindPoint(const QPointF &p1Line, const QPointF &p2Line, const QPointF &pShoulder, QPointF VToolShoulderPoint::FindPoint(const QPointF &p1Line, const QPointF &p2Line, const QPointF &pShoulder,
@ -105,27 +105,27 @@ void VToolShoulderPoint::Create(const qint64 _id, const QString &formula, const
VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data,
const Document::Documents &parse, const Tool::Sources &typeCreation) const Document::Documents &parse, const Tool::Sources &typeCreation)
{ {
VPointF firstPoint = data->GetPoint(p1Line); const VPointF *firstPoint = data->GeometricObject<const VPointF *>(p1Line);
VPointF secondPoint = data->GetPoint(p2Line); const VPointF *secondPoint = data->GeometricObject<const VPointF *>(p2Line);
VPointF shoulderPoint = data->GetPoint(pShoulder); const VPointF *shoulderPoint = data->GeometricObject<const VPointF *>(pShoulder);
Calculator cal(data); Calculator cal(data);
QString errorMsg; QString errorMsg;
qreal result = cal.eval(formula, &errorMsg); qreal result = cal.eval(formula, &errorMsg);
if (errorMsg.isEmpty()) if (errorMsg.isEmpty())
{ {
QPointF fPoint = VToolShoulderPoint::FindPoint(firstPoint.toQPointF(), secondPoint.toQPointF(), QPointF fPoint = VToolShoulderPoint::FindPoint(firstPoint->toQPointF(), secondPoint->toQPointF(),
shoulderPoint.toQPointF(), toPixel(result)); shoulderPoint->toQPointF(), toPixel(result));
qint64 id = _id; qint64 id = _id;
if (typeCreation == Tool::FromGui) if (typeCreation == Tool::FromGui)
{ {
id = data->AddPoint(VPointF(fPoint.x(), fPoint.y(), pointName, mx, my)); id = data->AddGObject(new VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
data->AddLine(p1Line, id); data->AddLine(p1Line, id);
data->AddLine(p2Line, id); data->AddLine(p2Line, id);
} }
else else
{ {
data->UpdatePoint(id, VPointF(fPoint.x(), fPoint.y(), pointName, mx, my)); data->UpdateGObject(id, new VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
data->AddLine(p1Line, id); data->AddLine(p1Line, id);
data->AddLine(p2Line, id); data->AddLine(p2Line, id);
if (parse != Document::FullParse) if (parse != Document::FullParse)
@ -197,14 +197,14 @@ void VToolShoulderPoint::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
void VToolShoulderPoint::AddToFile() void VToolShoulderPoint::AddToFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->createElement(TagName); QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id); AddAttribute(domElement, AttrId, id);
AddAttribute(domElement, AttrType, ToolType); AddAttribute(domElement, AttrType, ToolType);
AddAttribute(domElement, AttrName, point.name()); AddAttribute(domElement, AttrName, point->name());
AddAttribute(domElement, AttrMx, toMM(point.mx())); AddAttribute(domElement, AttrMx, toMM(point->mx()));
AddAttribute(domElement, AttrMy, toMM(point.my())); AddAttribute(domElement, AttrMy, toMM(point->my()));
AddAttribute(domElement, AttrTypeLine, typeLine); AddAttribute(domElement, AttrTypeLine, typeLine);
AddAttribute(domElement, AttrLength, formula); AddAttribute(domElement, AttrLength, formula);
@ -217,13 +217,13 @@ void VToolShoulderPoint::AddToFile()
void VToolShoulderPoint::RefreshDataInFile() void VToolShoulderPoint::RefreshDataInFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute(AttrName, point.name()); domElement.setAttribute(AttrName, point->name());
domElement.setAttribute(AttrName, toMM(point.mx())); domElement.setAttribute(AttrName, toMM(point->mx()));
domElement.setAttribute(AttrName, toMM(point.my())); domElement.setAttribute(AttrName, toMM(point->my()));
domElement.setAttribute(AttrTypeLine, typeLine); domElement.setAttribute(AttrTypeLine, typeLine);
domElement.setAttribute(AttrLength, formula); domElement.setAttribute(AttrLength, formula);
domElement.setAttribute(AttrP1Line, basePointId); domElement.setAttribute(AttrP1Line, basePointId);

32
src/tools/drawTools/vtoolsinglepoint.cpp
View file

@ -50,37 +50,37 @@ VToolSinglePoint::VToolSinglePoint (VDomDocument *doc, VContainer *data, qint64
void VToolSinglePoint::setDialog() void VToolSinglePoint::setDialog()
{ {
Q_ASSERT(dialogSinglePoint.isNull() == false); Q_ASSERT(dialogSinglePoint.isNull() == false);
VPointF p = VAbstractTool::data.GetPoint(id); const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogSinglePoint->setData(p.name(), p.toQPointF()); dialogSinglePoint->setData(p->name(), p->toQPointF());
} }
void VToolSinglePoint::AddToFile() void VToolSinglePoint::AddToFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->createElement(TagName); QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id); AddAttribute(domElement, AttrId, id);
AddAttribute(domElement, AttrType, ToolType); AddAttribute(domElement, AttrType, ToolType);
AddAttribute(domElement, AttrName, point.name()); AddAttribute(domElement, AttrName, point->name());
AddAttribute(domElement, AttrX, toMM(point.x())); AddAttribute(domElement, AttrX, toMM(point->x()));
AddAttribute(domElement, AttrY, toMM(point.y())); AddAttribute(domElement, AttrY, toMM(point->y()));
AddAttribute(domElement, AttrMx, toMM(point.mx())); AddAttribute(domElement, AttrMx, toMM(point->mx()));
AddAttribute(domElement, AttrMy, toMM(point.my())); AddAttribute(domElement, AttrMy, toMM(point->my()));
AddToCalculation(domElement); AddToCalculation(domElement);
} }
void VToolSinglePoint::RefreshDataInFile() void VToolSinglePoint::RefreshDataInFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute(AttrName, point.name()); domElement.setAttribute(AttrName, point->name());
domElement.setAttribute(AttrX, QString().setNum(toMM(point.x()))); domElement.setAttribute(AttrX, QString().setNum(toMM(point->x())));
domElement.setAttribute(AttrY, QString().setNum(toMM(point.y()))); domElement.setAttribute(AttrY, QString().setNum(toMM(point->y())));
domElement.setAttribute(AttrMx, QString().setNum(toMM(point.mx()))); domElement.setAttribute(AttrMx, QString().setNum(toMM(point->mx())));
domElement.setAttribute(AttrMy, QString().setNum(toMM(point.my()))); domElement.setAttribute(AttrMy, QString().setNum(toMM(point->my())));
} }
} }
@ -130,7 +130,7 @@ void VToolSinglePoint::contextMenuEvent ( QGraphicsSceneContextMenuEvent * event
void VToolSinglePoint::FullUpdateFromFile() void VToolSinglePoint::FullUpdateFromFile()
{ {
RefreshPointGeometry(VAbstractTool::data.GetPoint(id)); RefreshPointGeometry(*VAbstractTool::data.GeometricObject<const VPointF *>(id));
} }
void VToolSinglePoint::FullUpdateFromGui(int result) void VToolSinglePoint::FullUpdateFromGui(int result)
@ -169,5 +169,5 @@ void VToolSinglePoint::ChangedActivDraw(const QString &newName)
void VToolSinglePoint::SetFactor(qreal factor) void VToolSinglePoint::SetFactor(qreal factor)
{ {
VDrawTool::SetFactor(factor); VDrawTool::SetFactor(factor);
RefreshPointGeometry(VAbstractTool::data.GetPoint(id)); RefreshPointGeometry(*VAbstractTool::data.GeometricObject<const VPointF *>(id));
} }

124
src/tools/drawTools/vtoolspline.cpp
View file

@ -39,25 +39,25 @@ VToolSpline::VToolSpline(VDomDocument *doc, VContainer *data, qint64 id, const T
{ {
ignoreFullUpdate = true; ignoreFullUpdate = true;
VSpline spl = data->GetSpline(id); const VSpline *spl = data->GeometricObject<const VSpline *>(id);
QPainterPath path; QPainterPath path;
path.addPath(spl.GetPath()); path.addPath(spl->GetPath());
path.setFillRule( Qt::WindingFill ); path.setFillRule( Qt::WindingFill );
this->setPath(path); this->setPath(path);
this->setPen(QPen(Qt::black, widthHairLine/factor)); this->setPen(QPen(Qt::black, widthHairLine/factor));
this->setFlag(QGraphicsItem::ItemIsSelectable, true); this->setFlag(QGraphicsItem::ItemIsSelectable, true);
this->setAcceptHoverEvents(true); this->setAcceptHoverEvents(true);
VControlPointSpline *controlPoint1 = new VControlPointSpline(1, SplinePoint::FirstPoint, spl.GetP2(), VControlPointSpline *controlPoint1 = new VControlPointSpline(1, SplinePoint::FirstPoint, spl->GetP2(),
spl.GetPointP1().toQPointF(), this); spl->GetP1().toQPointF(), this);
connect(controlPoint1, &VControlPointSpline::ControlPointChangePosition, this, connect(controlPoint1, &VControlPointSpline::ControlPointChangePosition, this,
&VToolSpline::ControlPointChangePosition); &VToolSpline::ControlPointChangePosition);
connect(this, &VToolSpline::RefreshLine, controlPoint1, &VControlPointSpline::RefreshLine); connect(this, &VToolSpline::RefreshLine, controlPoint1, &VControlPointSpline::RefreshLine);
connect(this, &VToolSpline::setEnabledPoint, controlPoint1, &VControlPointSpline::setEnabledPoint); connect(this, &VToolSpline::setEnabledPoint, controlPoint1, &VControlPointSpline::setEnabledPoint);
controlPoints.append(controlPoint1); controlPoints.append(controlPoint1);
VControlPointSpline *controlPoint2 = new VControlPointSpline(1, SplinePoint::LastPoint, spl.GetP3(), VControlPointSpline *controlPoint2 = new VControlPointSpline(1, SplinePoint::LastPoint, spl->GetP3(),
spl.GetPointP4().toQPointF(), this); spl->GetP4().toQPointF(), this);
connect(controlPoint2, &VControlPointSpline::ControlPointChangePosition, this, connect(controlPoint2, &VControlPointSpline::ControlPointChangePosition, this,
&VToolSpline::ControlPointChangePosition); &VToolSpline::ControlPointChangePosition);
connect(this, &VToolSpline::RefreshLine, controlPoint2, &VControlPointSpline::RefreshLine); connect(this, &VToolSpline::RefreshLine, controlPoint2, &VControlPointSpline::RefreshLine);
@ -77,14 +77,14 @@ VToolSpline::VToolSpline(VDomDocument *doc, VContainer *data, qint64 id, const T
void VToolSpline::setDialog() void VToolSpline::setDialog()
{ {
Q_ASSERT(dialogSpline.isNull() == false); Q_ASSERT(dialogSpline.isNull() == false);
VSpline spl = VAbstractTool::data.GetSpline(id); const VSpline *spl = VAbstractTool::data.GeometricObject<const VSpline *>(id);
dialogSpline->setP1(spl.GetP1()); dialogSpline->setP1(spl->GetP1().id());
dialogSpline->setP4(spl.GetP4()); dialogSpline->setP4(spl->GetP4().id());
dialogSpline->setAngle1(spl.GetAngle1()); dialogSpline->setAngle1(spl->GetAngle1());
dialogSpline->setAngle2(spl.GetAngle2()); dialogSpline->setAngle2(spl->GetAngle2());
dialogSpline->setKAsm1(spl.GetKasm1()); dialogSpline->setKAsm1(spl->GetKasm1());
dialogSpline->setKAsm2(spl.GetKasm2()); dialogSpline->setKAsm2(spl->GetKasm2());
dialogSpline->setKCurve(spl.GetKcurve()); dialogSpline->setKCurve(spl->GetKcurve());
} }
void VToolSpline::Create(QSharedPointer<DialogSpline> &dialog, VMainGraphicsScene *scene, VDomDocument *doc, void VToolSpline::Create(QSharedPointer<DialogSpline> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
@ -106,17 +106,20 @@ void VToolSpline::Create(const qint64 _id, const qint64 &p1, const qint64 &p4, c
VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data,
const Document::Documents &parse, const Tool::Sources &typeCreation) const Document::Documents &parse, const Tool::Sources &typeCreation)
{ {
VSpline spline = VSpline(data->DataPoints(), p1, p4, angle1, angle2, kAsm1, kAsm2, kCurve); VPointF point1 = *data->GeometricObject<const VPointF *>(p1);
VPointF point4 = *data->GeometricObject<const VPointF *>(p4);
VSpline *spline = new VSpline(point1, point4, angle1, angle2, kAsm1, kAsm2, kCurve);
Q_ASSERT(spline != 0);
qint64 id = _id; qint64 id = _id;
if (typeCreation == Tool::FromGui) if (typeCreation == Tool::FromGui)
{ {
id = data->AddSpline(spline); id = data->AddGObject(spline);
data->AddLengthSpline(spline.name(), toMM(spline.GetLength())); data->AddLengthSpline(spline->name(), toMM(spline->GetLength()));
} }
else else
{ {
data->UpdateSpline(id, spline); data->UpdateGObject(id, spline);
data->AddLengthSpline(spline.name(), toMM(spline.GetLength())); data->AddLengthSpline(spline->name(), toMM(spline->GetLength()));
if (parse != Document::FullParse) if (parse != Document::FullParse)
{ {
doc->UpdateToolData(id, data); doc->UpdateToolData(id, data);
@ -145,8 +148,9 @@ void VToolSpline::FullUpdateFromGui(int result)
{ {
if (result == QDialog::Accepted) if (result == QDialog::Accepted)
{ {
VSpline spl = VSpline (VAbstractTool::data.DataPoints(), dialogSpline->getP1(), VPointF point1 = *VAbstractTool::data.GeometricObject<const VPointF *>(dialogSpline->getP1());
dialogSpline->getP4(), dialogSpline->getAngle1(), dialogSpline->getAngle2(), VPointF point4 = *VAbstractTool::data.GeometricObject<const VPointF *>(dialogSpline->getP4());
VSpline spl = VSpline (point1, point4, dialogSpline->getAngle1(), dialogSpline->getAngle2(),
dialogSpline->getKAsm1(), dialogSpline->getKAsm2(), dialogSpline->getKCurve()); dialogSpline->getKAsm1(), dialogSpline->getKAsm2(), dialogSpline->getKCurve());
disconnect(controlPoints[0], &VControlPointSpline::ControlPointChangePosition, this, disconnect(controlPoints[0], &VControlPointSpline::ControlPointChangePosition, this,
@ -160,18 +164,17 @@ void VToolSpline::FullUpdateFromGui(int result)
connect(controlPoints[1], &VControlPointSpline::ControlPointChangePosition, this, connect(controlPoints[1], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSpline::ControlPointChangePosition); &VToolSpline::ControlPointChangePosition);
spl = VSpline (VAbstractTool::data.DataPoints(), dialogSpline->getP1(), controlPoints[0]->pos(), spl = VSpline (point1, controlPoints[0]->pos(), controlPoints[1]->pos(), point4, dialogSpline->getKCurve());
controlPoints[1]->pos(), dialogSpline->getP4(), dialogSpline->getKCurve());
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute(AttrPoint1, QString().setNum(spl.GetP1())); domElement.setAttribute(AttrPoint1, spl.GetP1().id());
domElement.setAttribute(AttrPoint4, QString().setNum(spl.GetP4())); domElement.setAttribute(AttrPoint4, spl.GetP4().id());
domElement.setAttribute(AttrAngle1, QString().setNum(spl.GetAngle1())); domElement.setAttribute(AttrAngle1, spl.GetAngle1());
domElement.setAttribute(AttrAngle2, QString().setNum(spl.GetAngle2())); domElement.setAttribute(AttrAngle2, spl.GetAngle2());
domElement.setAttribute(AttrKAsm1, QString().setNum(spl.GetKasm1())); domElement.setAttribute(AttrKAsm1, spl.GetKasm1());
domElement.setAttribute(AttrKAsm2, QString().setNum(spl.GetKasm2())); domElement.setAttribute(AttrKAsm2, spl.GetKasm2());
domElement.setAttribute(AttrKCurve, QString().setNum(spl.GetKcurve())); domElement.setAttribute(AttrKCurve, spl.GetKcurve());
emit FullUpdateTree(); emit FullUpdateTree();
} }
} }
@ -182,14 +185,15 @@ void VToolSpline::ControlPointChangePosition(const qint32 &indexSpline, const Sp
const QPointF &pos) const QPointF &pos)
{ {
Q_UNUSED(indexSpline); Q_UNUSED(indexSpline);
VSpline spl = VAbstractTool::data.GetSpline(id); const VSpline *spline = VAbstractTool::data.GeometricObject<const VSpline *>(id);
VSpline spl;
if (position == SplinePoint::FirstPoint) if (position == SplinePoint::FirstPoint)
{ {
spl.ModifiSpl (spl.GetP1(), pos, spl.GetP3(), spl.GetP4(), spl.GetKcurve()); spl = VSpline(spline->GetP1(), pos, spline->GetP3(), spline->GetP4(), spline->GetKcurve());
} }
else else
{ {
spl.ModifiSpl (spl.GetP1(), spl.GetP2(), pos, spl.GetP4(), spl.GetKcurve()); spl = VSpline(spline->GetP1(), spline->GetP2(), pos, spline->GetP4(), spline->GetKcurve());
} }
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
@ -210,35 +214,35 @@ void VToolSpline::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
void VToolSpline::AddToFile() void VToolSpline::AddToFile()
{ {
VSpline spl = VAbstractTool::data.GetSpline(id); const VSpline *spl = VAbstractTool::data.GeometricObject<const VSpline *>(id);
QDomElement domElement = doc->createElement(TagName); QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id); AddAttribute(domElement, AttrId, id);
AddAttribute(domElement, AttrType, ToolType); AddAttribute(domElement, AttrType, ToolType);
AddAttribute(domElement, AttrPoint1, spl.GetP1()); AddAttribute(domElement, AttrPoint1, spl->GetP1().id());
AddAttribute(domElement, AttrPoint4, spl.GetP4()); AddAttribute(domElement, AttrPoint4, spl->GetP4().id());
AddAttribute(domElement, AttrAngle1, spl.GetAngle1()); AddAttribute(domElement, AttrAngle1, spl->GetAngle1());
AddAttribute(domElement, AttrAngle2, spl.GetAngle2()); AddAttribute(domElement, AttrAngle2, spl->GetAngle2());
AddAttribute(domElement, AttrKAsm1, spl.GetKasm1()); AddAttribute(domElement, AttrKAsm1, spl->GetKasm1());
AddAttribute(domElement, AttrKAsm2, spl.GetKasm2()); AddAttribute(domElement, AttrKAsm2, spl->GetKasm2());
AddAttribute(domElement, AttrKCurve, spl.GetKcurve()); AddAttribute(domElement, AttrKCurve, spl->GetKcurve());
AddToCalculation(domElement); AddToCalculation(domElement);
} }
void VToolSpline::RefreshDataInFile() void VToolSpline::RefreshDataInFile()
{ {
VSpline spl = VAbstractTool::data.GetSpline(id); const VSpline *spl = VAbstractTool::data.GeometricObject<const VSpline *>(id);
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute(AttrPoint1, QString().setNum(spl.GetP1())); domElement.setAttribute(AttrPoint1, spl->GetP1().id());
domElement.setAttribute(AttrPoint4, QString().setNum(spl.GetP4())); domElement.setAttribute(AttrPoint4, spl->GetP4().id());
domElement.setAttribute(AttrAngle1, QString().setNum(spl.GetAngle1())); domElement.setAttribute(AttrAngle1, spl->GetAngle1());
domElement.setAttribute(AttrAngle2, QString().setNum(spl.GetAngle2())); domElement.setAttribute(AttrAngle2, spl->GetAngle2());
domElement.setAttribute(AttrKAsm1, QString().setNum(spl.GetKasm1())); domElement.setAttribute(AttrKAsm1, spl->GetKasm1());
domElement.setAttribute(AttrKAsm2, QString().setNum(spl.GetKasm2())); domElement.setAttribute(AttrKAsm2, spl->GetKasm2());
domElement.setAttribute(AttrKCurve, QString().setNum(spl.GetKcurve())); domElement.setAttribute(AttrKCurve, spl->GetKcurve());
} }
} }
@ -265,32 +269,32 @@ void VToolSpline::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
void VToolSpline::RemoveReferens() void VToolSpline::RemoveReferens()
{ {
VSpline spl = VAbstractTool::data.GetSpline(id); const VSpline *spl = VAbstractTool::data.GeometricObject<const VSpline *>(id);
doc->DecrementReferens(spl.GetP1()); doc->DecrementReferens(spl->GetP1().id());
doc->DecrementReferens(spl.GetP4()); doc->DecrementReferens(spl->GetP4().id());
} }
void VToolSpline::RefreshGeometry() void VToolSpline::RefreshGeometry()
{ {
this->setPen(QPen(currentColor, widthHairLine/factor)); this->setPen(QPen(currentColor, widthHairLine/factor));
VSpline spl = VAbstractTool::data.GetSpline(id); const VSpline *spl = VAbstractTool::data.GeometricObject<const VSpline *>(id);
QPainterPath path; QPainterPath path;
path.addPath(spl.GetPath()); path.addPath(spl->GetPath());
path.setFillRule( Qt::WindingFill ); path.setFillRule( Qt::WindingFill );
this->setPath(path); this->setPath(path);
QPointF splinePoint = VAbstractTool::data.GetPoint(spl.GetP1()).toQPointF(); QPointF splinePoint = VAbstractTool::data.GeometricObject<const VPointF *>(spl->GetP1().id())->toQPointF();
QPointF controlPoint = spl.GetP2(); QPointF controlPoint = spl->GetP2();
emit RefreshLine(1, SplinePoint::FirstPoint, controlPoint, splinePoint); emit RefreshLine(1, SplinePoint::FirstPoint, controlPoint, splinePoint);
splinePoint = VAbstractTool::data.GetPoint(spl.GetP4()).toQPointF(); splinePoint = VAbstractTool::data.GeometricObject<const VPointF *>(spl->GetP4().id())->toQPointF();
controlPoint = spl.GetP3(); controlPoint = spl->GetP3();
emit RefreshLine(1, SplinePoint::LastPoint, controlPoint, splinePoint); emit RefreshLine(1, SplinePoint::LastPoint, controlPoint, splinePoint);
disconnect(controlPoints[0], &VControlPointSpline::ControlPointChangePosition, this, disconnect(controlPoints[0], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSpline::ControlPointChangePosition); &VToolSpline::ControlPointChangePosition);
disconnect(controlPoints[1], &VControlPointSpline::ControlPointChangePosition, this, disconnect(controlPoints[1], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSpline::ControlPointChangePosition); &VToolSpline::ControlPointChangePosition);
controlPoints[0]->setPos(spl.GetP2()); controlPoints[0]->setPos(spl->GetP2());
controlPoints[1]->setPos(spl.GetP3()); controlPoints[1]->setPos(spl->GetP3());
connect(controlPoints[0], &VControlPointSpline::ControlPointChangePosition, this, connect(controlPoints[0], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSpline::ControlPointChangePosition); &VToolSpline::ControlPointChangePosition);
connect(controlPoints[1], &VControlPointSpline::ControlPointChangePosition, this, connect(controlPoints[1], &VControlPointSpline::ControlPointChangePosition, this,

80
src/tools/drawTools/vtoolsplinepath.cpp
View file

@ -37,28 +37,27 @@ VToolSplinePath::VToolSplinePath(VDomDocument *doc, VContainer *data, qint64 id,
controlPoints(QVector<VControlPointSpline *>()) controlPoints(QVector<VControlPointSpline *>())
{ {
ignoreFullUpdate = true; ignoreFullUpdate = true;
VSplinePath splPath = data->GetSplinePath(id); const VSplinePath *splPath = data->GeometricObject<const VSplinePath *>(id);
QPainterPath path; QPainterPath path;
path.addPath(splPath.GetPath()); path.addPath(splPath->GetPath());
path.setFillRule( Qt::WindingFill ); path.setFillRule( Qt::WindingFill );
this->setPath(path); this->setPath(path);
this->setPen(QPen(Qt::black, widthHairLine/factor)); this->setPen(QPen(Qt::black, widthHairLine/factor));
this->setFlag(QGraphicsItem::ItemIsSelectable, true); this->setFlag(QGraphicsItem::ItemIsSelectable, true);
this->setAcceptHoverEvents(true); this->setAcceptHoverEvents(true);
for (qint32 i = 1; i<=splPath.Count(); ++i) for (qint32 i = 1; i<=splPath->Count(); ++i)
{ {
VSpline spl = splPath.GetSpline(i); VSpline spl = splPath->GetSpline(i);
VControlPointSpline *controlPoint = new VControlPointSpline(i, SplinePoint::FirstPoint, spl.GetP2(), VControlPointSpline *controlPoint = new VControlPointSpline(i, SplinePoint::FirstPoint, spl.GetP2(),
spl.GetPointP1().toQPointF(), this); spl.GetP1().toQPointF(), this);
connect(controlPoint, &VControlPointSpline::ControlPointChangePosition, this, connect(controlPoint, &VControlPointSpline::ControlPointChangePosition, this,
&VToolSplinePath::ControlPointChangePosition); &VToolSplinePath::ControlPointChangePosition);
connect(this, &VToolSplinePath::RefreshLine, controlPoint, &VControlPointSpline::RefreshLine); connect(this, &VToolSplinePath::RefreshLine, controlPoint, &VControlPointSpline::RefreshLine);
connect(this, &VToolSplinePath::setEnabledPoint, controlPoint, &VControlPointSpline::setEnabledPoint); connect(this, &VToolSplinePath::setEnabledPoint, controlPoint, &VControlPointSpline::setEnabledPoint);
controlPoints.append(controlPoint); controlPoints.append(controlPoint);
controlPoint = new VControlPointSpline(i, SplinePoint::LastPoint, spl.GetP3(), controlPoint = new VControlPointSpline(i, SplinePoint::LastPoint, spl.GetP3(), spl.GetP4().toQPointF(), this);
spl.GetPointP4().toQPointF(), this);
connect(controlPoint, &VControlPointSpline::ControlPointChangePosition, this, connect(controlPoint, &VControlPointSpline::ControlPointChangePosition, this,
&VToolSplinePath::ControlPointChangePosition); &VToolSplinePath::ControlPointChangePosition);
connect(this, &VToolSplinePath::RefreshLine, controlPoint, &VControlPointSpline::RefreshLine); connect(this, &VToolSplinePath::RefreshLine, controlPoint, &VControlPointSpline::RefreshLine);
@ -78,35 +77,36 @@ VToolSplinePath::VToolSplinePath(VDomDocument *doc, VContainer *data, qint64 id,
void VToolSplinePath::setDialog() void VToolSplinePath::setDialog()
{ {
Q_ASSERT(dialogSplinePath.isNull() == false); Q_ASSERT(dialogSplinePath.isNull() == false);
VSplinePath splPath = VAbstractTool::data.GetSplinePath(id); const VSplinePath *splPath = VAbstractTool::data.GeometricObject<const VSplinePath *>(id);
dialogSplinePath->SetPath(splPath); dialogSplinePath->SetPath(*splPath);
} }
void VToolSplinePath::Create(QSharedPointer<DialogSplinePath> &dialog, VMainGraphicsScene *scene, void VToolSplinePath::Create(QSharedPointer<DialogSplinePath> &dialog, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data) VDomDocument *doc, VContainer *data)
{ {
VSplinePath path = dialog->GetPath(); VSplinePath *path = new VSplinePath(dialog->GetPath());
for (qint32 i = 0; i < path.CountPoint(); ++i) Q_ASSERT(path);
for (qint32 i = 0; i < path->CountPoint(); ++i)
{ {
doc->IncrementReferens(path[i].P()); doc->IncrementReferens((*path)[i].P().id());
} }
Create(0, path, scene, doc, data, Document::FullParse, Tool::FromGui); Create(0, path, scene, doc, data, Document::FullParse, Tool::FromGui);
} }
void VToolSplinePath::Create(const qint64 _id, const VSplinePath &path, VMainGraphicsScene *scene, void VToolSplinePath::Create(const qint64 _id, VSplinePath *path, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data, const Document::Documents &parse, VDomDocument *doc, VContainer *data, const Document::Documents &parse,
const Tool::Sources &typeCreation) const Tool::Sources &typeCreation)
{ {
qint64 id = _id; qint64 id = _id;
if (typeCreation == Tool::FromGui) if (typeCreation == Tool::FromGui)
{ {
id = data->AddSplinePath(path); id = data->AddGObject(path);
data->AddLengthSpline(path.name(), toMM(path.GetLength())); data->AddLengthSpline(path->name(), toMM(path->GetLength()));
} }
else else
{ {
data->UpdateSplinePath(id, path); data->UpdateGObject(id, path);
data->AddLengthSpline(path.name(), toMM(path.GetLength())); data->AddLengthSpline(path->name(), toMM(path->GetLength()));
if (parse != Document::FullParse) if (parse != Document::FullParse)
{ {
doc->UpdateToolData(id, data); doc->UpdateToolData(id, data);
@ -149,8 +149,8 @@ void VToolSplinePath::FullUpdateFromGui(int result)
connect(controlPoints[j-1], &VControlPointSpline::ControlPointChangePosition, this, connect(controlPoints[j-1], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSplinePath::ControlPointChangePosition); &VToolSplinePath::ControlPointChangePosition);
spl = VSpline (VAbstractTool::data.DataPoints(), spl.GetP1(), controlPoints[j-2]->pos(), spl = VSpline (spl.GetP1(), controlPoints[j-2]->pos(), controlPoints[j-1]->pos(), spl.GetP4(),
controlPoints[j-1]->pos(), spl.GetP4(), splPath.getKCurve()); splPath.getKCurve());
CorectControlPoints(spl, splPath, i); CorectControlPoints(spl, splPath, i);
CorectControlPoints(spl, splPath, i); CorectControlPoints(spl, splPath, i);
@ -170,15 +170,15 @@ void VToolSplinePath::FullUpdateFromGui(int result)
void VToolSplinePath::ControlPointChangePosition(const qint32 &indexSpline, const SplinePoint::Position &position, void VToolSplinePath::ControlPointChangePosition(const qint32 &indexSpline, const SplinePoint::Position &position,
const QPointF &pos) const QPointF &pos)
{ {
VSplinePath splPath = VAbstractTool::data.GetSplinePath(id); VSplinePath splPath = *VAbstractTool::data.GeometricObject<const VSplinePath *>(id);
VSpline spl = splPath.GetSpline(indexSpline); VSpline spl;
if (position == SplinePoint::FirstPoint) if (position == SplinePoint::FirstPoint)
{ {
spl.ModifiSpl (spl.GetP1(), pos, spl.GetP3(), spl.GetP4(), spl.GetKcurve()); spl = VSpline(spl.GetP1(), pos, spl.GetP3(), spl.GetP4(), spl.GetKcurve());
} }
else else
{ {
spl.ModifiSpl (spl.GetP1(), spl.GetP2(), pos, spl.GetP4(), spl.GetKcurve()); spl = VSpline(spl.GetP1(), spl.GetP2(), pos, spl.GetP4(), spl.GetKcurve());
} }
CorectControlPoints(spl, splPath, indexSpline); CorectControlPoints(spl, splPath, indexSpline);
@ -214,10 +214,10 @@ void VToolSplinePath::UpdatePathPoint(QDomNode& node, VSplinePath &path)
if (domElement.isNull() == false) if (domElement.isNull() == false)
{ {
VSplinePoint p = path[i]; VSplinePoint p = path[i];
domElement.setAttribute(AttrPSpline, QString().setNum(p.P())); domElement.setAttribute(AttrPSpline, p.P().id());
domElement.setAttribute(AttrKAsm1, QString().setNum(p.KAsm1())); domElement.setAttribute(AttrKAsm1, p.KAsm1());
domElement.setAttribute(AttrKAsm2, QString().setNum(p.KAsm2())); domElement.setAttribute(AttrKAsm2, p.KAsm2());
domElement.setAttribute(AttrAngle, QString().setNum(p.Angle2())); domElement.setAttribute(AttrAngle, p.Angle2());
} }
} }
} }
@ -260,7 +260,7 @@ void VToolSplinePath::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
void VToolSplinePath::AddToFile() void VToolSplinePath::AddToFile()
{ {
VSplinePath splPath = VAbstractTool::data.GetSplinePath(id); VSplinePath splPath = *VAbstractTool::data.GeometricObject<const VSplinePath *>(id);
QDomElement domElement = doc->createElement(TagName); QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id); AddAttribute(domElement, AttrId, id);
@ -277,7 +277,7 @@ void VToolSplinePath::AddToFile()
void VToolSplinePath::RefreshDataInFile() void VToolSplinePath::RefreshDataInFile()
{ {
VSplinePath splPath = VAbstractTool::data.GetSplinePath(id); VSplinePath splPath = *VAbstractTool::data.GeometricObject<const VSplinePath *>(id);
for (qint32 i = 1; i<=splPath.Count(); ++i) for (qint32 i = 1; i<=splPath.Count(); ++i)
{ {
VSpline spl = splPath.GetSpline(i); VSpline spl = splPath.GetSpline(i);
@ -293,8 +293,8 @@ void VToolSplinePath::RefreshDataInFile()
connect(controlPoints[j-1], &VControlPointSpline::ControlPointChangePosition, this, connect(controlPoints[j-1], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSplinePath::ControlPointChangePosition); &VToolSplinePath::ControlPointChangePosition);
spl = VSpline (VAbstractTool::data.DataPoints(), spl.GetP1(), controlPoints[j-2]->pos(), spl = VSpline (spl.GetP1(), controlPoints[j-2]->pos(), controlPoints[j-1]->pos(), spl.GetP4(),
controlPoints[j-1]->pos(), spl.GetP4(), splPath.getKCurve()); splPath.getKCurve());
CorectControlPoints(spl, splPath, i); CorectControlPoints(spl, splPath, i);
CorectControlPoints(spl, splPath, i); CorectControlPoints(spl, splPath, i);
@ -312,7 +312,7 @@ void VToolSplinePath::AddPathPoint(QDomElement &domElement, const VSplinePoint &
{ {
QDomElement pathPoint = doc->createElement(AttrPathPoint); QDomElement pathPoint = doc->createElement(AttrPathPoint);
AddAttribute(pathPoint, AttrPSpline, splPoint.P()); AddAttribute(pathPoint, AttrPSpline, splPoint.P().id());
AddAttribute(pathPoint, AttrKAsm1, splPoint.KAsm1()); AddAttribute(pathPoint, AttrKAsm1, splPoint.KAsm1());
AddAttribute(pathPoint, AttrKAsm2, splPoint.KAsm2()); AddAttribute(pathPoint, AttrKAsm2, splPoint.KAsm2());
AddAttribute(pathPoint, AttrAngle, splPoint.Angle2()); AddAttribute(pathPoint, AttrAngle, splPoint.Angle2());
@ -343,28 +343,28 @@ void VToolSplinePath::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
void VToolSplinePath::RemoveReferens() void VToolSplinePath::RemoveReferens()
{ {
VSplinePath splPath = VAbstractTool::data.GetSplinePath(id); VSplinePath splPath = *VAbstractTool::data.GeometricObject<const VSplinePath *>(id);
for (qint32 i = 0; i < splPath.Count(); ++i) for (qint32 i = 0; i < splPath.Count(); ++i)
{ {
doc->DecrementReferens(splPath[i].P()); doc->DecrementReferens(splPath[i].P().id());
} }
} }
void VToolSplinePath::RefreshGeometry() void VToolSplinePath::RefreshGeometry()
{ {
this->setPen(QPen(currentColor, widthHairLine/factor)); this->setPen(QPen(currentColor, widthHairLine/factor));
VSplinePath splPath = VAbstractTool::data.GetSplinePath(id); const VSplinePath *splPath = VAbstractTool::data.GeometricObject<const VSplinePath *>(id);
QPainterPath path; QPainterPath path;
path.addPath(splPath.GetPath()); path.addPath(splPath->GetPath());
path.setFillRule( Qt::WindingFill ); path.setFillRule( Qt::WindingFill );
this->setPath(path); this->setPath(path);
for (qint32 i = 1; i<=splPath.Count(); ++i) for (qint32 i = 1; i<=splPath->Count(); ++i)
{ {
VSpline spl = splPath.GetSpline(i); VSpline spl = splPath->GetSpline(i);
QPointF splinePoint = spl.GetPointP1().toQPointF(); QPointF splinePoint = spl.GetP1().toQPointF();
QPointF controlPoint = spl.GetP2(); QPointF controlPoint = spl.GetP2();
emit RefreshLine(i, SplinePoint::FirstPoint, controlPoint, splinePoint); emit RefreshLine(i, SplinePoint::FirstPoint, controlPoint, splinePoint);
splinePoint = spl.GetPointP4().toQPointF(); splinePoint = spl.GetP4().toQPointF();
controlPoint = spl.GetP3(); controlPoint = spl.GetP3();
emit RefreshLine(i, SplinePoint::LastPoint, controlPoint, splinePoint); emit RefreshLine(i, SplinePoint::LastPoint, controlPoint, splinePoint);

2
src/tools/drawTools/vtoolsplinepath.h
View file

@ -74,7 +74,7 @@ public:
* @param parse * @param parse
* @param typeCreation * @param typeCreation
*/ */
static void Create(const qint64 _id, const VSplinePath &path, VMainGraphicsScene *scene, static void Create(const qint64 _id, VSplinePath *path, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data, const Document::Documents &parse, VDomDocument *doc, VContainer *data, const Document::Documents &parse,
const Tool::Sources &typeCreation); const Tool::Sources &typeCreation);
/** /**

46
src/tools/drawTools/vtooltriangle.cpp
View file

@ -50,12 +50,12 @@ VToolTriangle::VToolTriangle(VDomDocument *doc, VContainer *data, const qint64 &
void VToolTriangle::setDialog() void VToolTriangle::setDialog()
{ {
Q_ASSERT(dialogTriangle.isNull() == false); Q_ASSERT(dialogTriangle.isNull() == false);
VPointF p = VAbstractTool::data.GetPoint(id); const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogTriangle->setAxisP1Id(axisP1Id, id); dialogTriangle->setAxisP1Id(axisP1Id, id);
dialogTriangle->setAxisP2Id(axisP2Id, id); dialogTriangle->setAxisP2Id(axisP2Id, id);
dialogTriangle->setFirstPointId(firstPointId, id); dialogTriangle->setFirstPointId(firstPointId, id);
dialogTriangle->setSecondPointId(secondPointId, id); dialogTriangle->setSecondPointId(secondPointId, id);
dialogTriangle->setPointName(p.name()); dialogTriangle->setPointName(p->name());
} }
void VToolTriangle::Create(QSharedPointer<DialogTriangle> &dialog, VMainGraphicsScene *scene, void VToolTriangle::Create(QSharedPointer<DialogTriangle> &dialog, VMainGraphicsScene *scene,
@ -75,21 +75,21 @@ void VToolTriangle::Create(const qint64 _id, const QString &pointName, const qin
const qreal &mx, const qreal &my, VMainGraphicsScene *scene, VDomDocument *doc, const qreal &mx, const qreal &my, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data, const Document::Documents &parse, const Tool::Sources &typeCreation) VContainer *data, const Document::Documents &parse, const Tool::Sources &typeCreation)
{ {
VPointF axisP1 = data->GetPoint(axisP1Id); const VPointF *axisP1 = data->GeometricObject<const VPointF *>(axisP1Id);
VPointF axisP2 = data->GetPoint(axisP2Id); const VPointF *axisP2 = data->GeometricObject<const VPointF *>(axisP2Id);
VPointF firstPoint = data->GetPoint(firstPointId); const VPointF *firstPoint = data->GeometricObject<const VPointF *>(firstPointId);
VPointF secondPoint = data->GetPoint(secondPointId); const VPointF *secondPoint = data->GeometricObject<const VPointF *>(secondPointId);
QPointF point = FindPoint(axisP1.toQPointF(), axisP2.toQPointF(), firstPoint.toQPointF(), QPointF point = FindPoint(axisP1->toQPointF(), axisP2->toQPointF(), firstPoint->toQPointF(),
secondPoint.toQPointF()); secondPoint->toQPointF());
qint64 id = _id; qint64 id = _id;
if (typeCreation == Tool::FromGui) if (typeCreation == Tool::FromGui)
{ {
id = data->AddPoint(VPointF(point.x(), point.y(), pointName, mx, my)); id = data->AddGObject(new VPointF(point.x(), point.y(), pointName, mx, my));
} }
else else
{ {
data->UpdatePoint(id, VPointF(point.x(), point.y(), pointName, mx, my)); data->UpdateGObject(id, new VPointF(point.x(), point.y(), pointName, mx, my));
if (parse != Document::FullParse) if (parse != Document::FullParse)
{ {
doc->UpdateToolData(id, data); doc->UpdateToolData(id, data);
@ -163,7 +163,7 @@ void VToolTriangle::FullUpdateFromFile()
firstPointId = domElement.attribute(AttrFirstPoint, "").toLongLong(); firstPointId = domElement.attribute(AttrFirstPoint, "").toLongLong();
secondPointId = domElement.attribute(AttrSecondPoint, "").toLongLong(); secondPointId = domElement.attribute(AttrSecondPoint, "").toLongLong();
} }
VToolPoint::RefreshPointGeometry(VDrawTool::data.GetPoint(id)); VToolPoint::RefreshPointGeometry(*VDrawTool::data.GeometricObject<const VPointF *>(id));
} }
void VToolTriangle::FullUpdateFromGui(int result) void VToolTriangle::FullUpdateFromGui(int result)
@ -200,14 +200,14 @@ void VToolTriangle::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
void VToolTriangle::AddToFile() void VToolTriangle::AddToFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->createElement(TagName); QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id); AddAttribute(domElement, AttrId, id);
AddAttribute(domElement, AttrType, ToolType); AddAttribute(domElement, AttrType, ToolType);
AddAttribute(domElement, AttrName, point.name()); AddAttribute(domElement, AttrName, point->name());
AddAttribute(domElement, AttrMx, toMM(point.mx())); AddAttribute(domElement, AttrMx, toMM(point->mx()));
AddAttribute(domElement, AttrMy, toMM(point.my())); AddAttribute(domElement, AttrMy, toMM(point->my()));
AddAttribute(domElement, AttrAxisP1, axisP1Id); AddAttribute(domElement, AttrAxisP1, axisP1Id);
AddAttribute(domElement, AttrAxisP2, axisP2Id); AddAttribute(domElement, AttrAxisP2, axisP2Id);
@ -219,16 +219,16 @@ void VToolTriangle::AddToFile()
void VToolTriangle::RefreshDataInFile() void VToolTriangle::RefreshDataInFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute(AttrName, point.name()); domElement.setAttribute(AttrName, point->name());
domElement.setAttribute(AttrMx, toMM(point.mx())); domElement.setAttribute(AttrMx, toMM(point->mx()));
domElement.setAttribute(AttrMy, toMM(point.my())); domElement.setAttribute(AttrMy, toMM(point->my()));
domElement.setAttribute(AttrAxisP1, QString().setNum(axisP1Id)); domElement.setAttribute(AttrAxisP1, axisP1Id);
domElement.setAttribute(AttrAxisP2, QString().setNum(axisP2Id)); domElement.setAttribute(AttrAxisP2, axisP2Id);
domElement.setAttribute(AttrFirstPoint, QString().setNum(firstPointId)); domElement.setAttribute(AttrFirstPoint, firstPointId);
domElement.setAttribute(AttrSecondPoint, QString().setNum(secondPointId)); domElement.setAttribute(AttrSecondPoint, secondPointId);
} }
} }

4
src/tools/nodeDetails/vnodearc.cpp
View file

@ -114,9 +114,9 @@ void VNodeArc::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
void VNodeArc::RefreshGeometry() void VNodeArc::RefreshGeometry()
{ {
VArc arc = VAbstractTool::data.GetArc(id); const VArc *arc = VAbstractTool::data.GeometricObject<const VArc *>(id);
QPainterPath path; QPainterPath path;
path.addPath(arc.GetPath()); path.addPath(arc->GetPath());
path.setFillRule( Qt::WindingFill ); path.setFillRule( Qt::WindingFill );
this->setPath(path); this->setPath(path);
} }

28
src/tools/nodeDetails/vnodepoint.cpp
View file

@ -46,7 +46,7 @@ VNodePoint::VNodePoint(VDomDocument *doc, VContainer *data, qint64 id, qint64 id
this->setBrush(QBrush(Qt::NoBrush)); this->setBrush(QBrush(Qt::NoBrush));
this->setFlag(QGraphicsItem::ItemIsSelectable, true); this->setFlag(QGraphicsItem::ItemIsSelectable, true);
this->setAcceptHoverEvents(true); this->setAcceptHoverEvents(true);
RefreshPointGeometry(VAbstractTool::data.GetPoint(id)); RefreshPointGeometry(*VAbstractTool::data.GeometricObject<const VPointF *>(id));
if (typeCreation == Tool::FromGui) if (typeCreation == Tool::FromGui)
{ {
AddToFile(); AddToFile();
@ -75,32 +75,32 @@ void VNodePoint::Create(VDomDocument *doc, VContainer *data, qint64 id, qint64 i
void VNodePoint::FullUpdateFromFile() void VNodePoint::FullUpdateFromFile()
{ {
RefreshPointGeometry(VAbstractTool::data.GetPoint(id)); RefreshPointGeometry(*VAbstractTool::data.GeometricObject<const VPointF *>(id));
} }
void VNodePoint::AddToFile() void VNodePoint::AddToFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->createElement(TagName); QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id); AddAttribute(domElement, AttrId, id);
AddAttribute(domElement, AttrType, ToolType); AddAttribute(domElement, AttrType, ToolType);
AddAttribute(domElement, AttrIdObject, idNode); AddAttribute(domElement, AttrIdObject, idNode);
AddAttribute(domElement, AttrMx, toMM(point.mx())); AddAttribute(domElement, AttrMx, toMM(point->mx()));
AddAttribute(domElement, AttrMy, toMM(point.my())); AddAttribute(domElement, AttrMy, toMM(point->my()));
AddToModeling(domElement); AddToModeling(domElement);
} }
void VNodePoint::RefreshDataInFile() void VNodePoint::RefreshDataInFile()
{ {
VPointF point = VAbstractTool::data.GetPoint(id); const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
domElement.setAttribute(AttrIdObject, QString().setNum(idNode)); domElement.setAttribute(AttrIdObject, idNode);
domElement.setAttribute(AttrMx, QString().setNum(toMM(point.mx()))); domElement.setAttribute(AttrMx, toMM(point->mx()));
domElement.setAttribute(AttrMy, QString().setNum(toMM(point.my()))); domElement.setAttribute(AttrMy, toMM(point->my()));
} }
} }
@ -128,13 +128,13 @@ void VNodePoint::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
void VNodePoint::NameChangePosition(const QPointF &pos) void VNodePoint::NameChangePosition(const QPointF &pos)
{ {
VPointF point = VAbstractTool::data.GetPoint(id); VPointF *point = new VPointF(*VAbstractTool::data.GeometricObject<const VPointF *>(id));
QPointF p = pos - this->pos(); QPointF p = pos - this->pos();
point.setMx(p.x()); point->setMx(p.x());
point.setMy(p.y()); point->setMy(p.y());
RefreshLine(); RefreshLine();
UpdateNamePosition(point.mx(), point.my()); UpdateNamePosition(point->mx(), point->my());
VAbstractTool::data.UpdatePoint(id, point); VAbstractTool::data.UpdateGObject(id, point);
} }
void VNodePoint::UpdateNamePosition(qreal mx, qreal my) void VNodePoint::UpdateNamePosition(qreal mx, qreal my)

4
src/tools/nodeDetails/vnodespline.cpp
View file

@ -115,9 +115,9 @@ void VNodeSpline::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
void VNodeSpline::RefreshGeometry() void VNodeSpline::RefreshGeometry()
{ {
VSpline spl = VAbstractTool::data.GetSpline(id); const VSpline *spl = VAbstractTool::data.GeometricObject<const VSpline *>(id);
QPainterPath path; QPainterPath path;
path.addPath(spl.GetPath()); path.addPath(spl->GetPath());
path.setFillRule( Qt::WindingFill ); path.setFillRule( Qt::WindingFill );
this->setPath(path); this->setPath(path);
} }

10
src/tools/nodeDetails/vnodesplinepath.cpp
View file

@ -58,11 +58,11 @@ void VNodeSplinePath::Create(VDomDocument *doc, VContainer *data, qint64 id, qin
VNodeSplinePath *splPath = new VNodeSplinePath(doc, data, id, idSpline, typeCreation); VNodeSplinePath *splPath = new VNodeSplinePath(doc, data, id, idSpline, typeCreation);
Q_ASSERT(splPath != 0); Q_ASSERT(splPath != 0);
doc->AddTool(id, splPath); doc->AddTool(id, splPath);
VSplinePath path = data->GetSplinePath(id); const VSplinePath *path = data->GeometricObject<const VSplinePath *>(id);
const QVector<VSplinePoint> *points = path.GetPoint(); const QVector<VSplinePoint> *points = path->GetPoint();
for (qint32 i = 0; i<points->size(); ++i) for (qint32 i = 0; i<points->size(); ++i)
{ {
doc->IncrementReferens(points->at(i).P()); doc->IncrementReferens(points->at(i).P().id());
} }
} }
else else
@ -119,9 +119,9 @@ void VNodeSplinePath::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
void VNodeSplinePath::RefreshGeometry() void VNodeSplinePath::RefreshGeometry()
{ {
VSplinePath splPath = VAbstractTool::data.GetSplinePath(id); const VSplinePath *splPath = VAbstractTool::data.GeometricObject<const VSplinePath *>(id);
QPainterPath path; QPainterPath path;
path.addPath(splPath.GetPath()); path.addPath(splPath->GetPath());
path.setFillRule( Qt::WindingFill ); path.setFillRule( Qt::WindingFill );
this->setPath(path); this->setPath(path);
} }

6
src/tools/tools.pri
View file

@ -29,7 +29,8 @@ HEADERS += \
src/tools/nodeDetails/vabstractnode.h \ src/tools/nodeDetails/vabstractnode.h \
src/tools/nodeDetails/nodedetails.h \ src/tools/nodeDetails/nodedetails.h \
src/tools/drawTools/vtoolcutspline.h \ src/tools/drawTools/vtoolcutspline.h \
src/tools/drawTools/vtoolcutsplinepath.h src/tools/drawTools/vtoolcutsplinepath.h \
src/tools/vtooluniondetails.h
SOURCES += \ SOURCES += \
src/tools/vtooldetail.cpp \ src/tools/vtooldetail.cpp \
@ -59,4 +60,5 @@ SOURCES += \
src/tools/nodeDetails/vnodearc.cpp \ src/tools/nodeDetails/vnodearc.cpp \
src/tools/nodeDetails/vabstractnode.cpp \ src/tools/nodeDetails/vabstractnode.cpp \
src/tools/drawTools/vtoolcutspline.cpp \ src/tools/drawTools/vtoolcutspline.cpp \
src/tools/drawTools/vtoolcutsplinepath.cpp src/tools/drawTools/vtoolcutsplinepath.cpp \
src/tools/vtooluniondetails.cpp

132
src/tools/vtooldetail.cpp
View file

@ -44,7 +44,7 @@ VToolDetail::VToolDetail(VDomDocument *doc, VContainer *data, const qint64 &id,
:VAbstractTool(doc, data, id), QGraphicsPathItem(parent), dialogDetail(QSharedPointer<DialogDetail>()), :VAbstractTool(doc, data, id), QGraphicsPathItem(parent), dialogDetail(QSharedPointer<DialogDetail>()),
sceneDetails(scene) sceneDetails(scene)
{ {
VDetail detail = data->GetDetail(id); VDetail detail = VDetail(*data->GetDetail(id));
for (ptrdiff_t i = 0; i< detail.CountNode(); ++i) for (ptrdiff_t i = 0; i< detail.CountNode(); ++i)
{ {
switch (detail[i].getTypeTool()) switch (detail[i].getTypeTool())
@ -72,7 +72,7 @@ VToolDetail::VToolDetail(VDomDocument *doc, VContainer *data, const qint64 &id,
RefreshGeometry(); RefreshGeometry();
this->setPos(detail.getMx(), detail.getMy()); this->setPos(detail.getMx(), detail.getMy());
this->setFlag(QGraphicsItem::ItemSendsGeometryChanges, true); this->setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
if (typeCreation == Tool::FromGui) if (typeCreation == Tool::FromGui || typeCreation == Tool::FromTool)
{ {
AddToFile(); AddToFile();
} }
@ -81,15 +81,16 @@ VToolDetail::VToolDetail(VDomDocument *doc, VContainer *data, const qint64 &id,
void VToolDetail::setDialog() void VToolDetail::setDialog()
{ {
Q_ASSERT(dialogDetail.isNull() == false); Q_ASSERT(dialogDetail.isNull() == false);
VDetail detail = VAbstractTool::data.GetDetail(id); const VDetail *detail = VAbstractTool::data.GeometricObject<const VDetail *>(id);
dialogDetail->setDetails(detail); dialogDetail->setDetails(*detail);
} }
void VToolDetail::Create(QSharedPointer<DialogDetail> &dialog, VMainGraphicsScene *scene, VDomDocument *doc, void VToolDetail::Create(QSharedPointer<DialogDetail> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data) VContainer *data)
{ {
VDetail detail = dialog->getDetails(); VDetail detail = dialog->getDetails();
VDetail det; VDetail *det = new VDetail();
Q_ASSERT(det != 0);
for (ptrdiff_t i = 0; i< detail.CountNode(); ++i) for (ptrdiff_t i = 0; i< detail.CountNode(); ++i)
{ {
qint64 id = 0; qint64 id = 0;
@ -97,29 +98,33 @@ void VToolDetail::Create(QSharedPointer<DialogDetail> &dialog, VMainGraphicsScen
{ {
case (Tool::NodePoint): case (Tool::NodePoint):
{ {
VPointF point = data->GetPoint(detail[i].getId()); VPointF *point = new VPointF(*data->GeometricObject<const VPointF *>(detail[i].getId()));
id = data->AddPoint(point); Q_ASSERT(point != 0);
id = data->AddGObject(point);
VNodePoint::Create(doc, data, id, detail[i].getId(), Document::FullParse, Tool::FromGui); VNodePoint::Create(doc, data, id, detail[i].getId(), Document::FullParse, Tool::FromGui);
} }
break; break;
case (Tool::NodeArc): case (Tool::NodeArc):
{ {
VArc arc = data->GetArc(detail[i].getId()); VArc *arc = new VArc(*data->GeometricObject<const VArc *>(detail[i].getId()));
id = data->AddArc(arc); Q_ASSERT(arc != 0);
id = data->AddGObject(arc);
VNodeArc::Create(doc, data, id, detail[i].getId(), Document::FullParse, Tool::FromGui); VNodeArc::Create(doc, data, id, detail[i].getId(), Document::FullParse, Tool::FromGui);
} }
break; break;
case (Tool::NodeSpline): case (Tool::NodeSpline):
{ {
VSpline spline = data->GetSpline(detail[i].getId()); VSpline *spline = new VSpline(*data->GeometricObject<const VSpline *>(detail[i].getId()));
id = data->AddSpline(spline); Q_ASSERT(spline != 0);
id = data->AddGObject(spline);
VNodeSpline::Create(doc, data, id, detail[i].getId(), Document::FullParse, Tool::FromGui); VNodeSpline::Create(doc, data, id, detail[i].getId(), Document::FullParse, Tool::FromGui);
} }
break; break;
case (Tool::NodeSplinePath): case (Tool::NodeSplinePath):
{ {
VSplinePath splinePath = data->GetSplinePath(detail[i].getId()); VSplinePath *splinePath = new VSplinePath(*data->GeometricObject<const VSplinePath *>(detail[i].getId()));
id = data->AddSplinePath(splinePath); Q_ASSERT(splinePath != 0);
id = data->AddGObject(splinePath);
VNodeSplinePath::Create(doc, data, id, detail[i].getId(), Document::FullParse, Tool::FromGui); VNodeSplinePath::Create(doc, data, id, detail[i].getId(), Document::FullParse, Tool::FromGui);
} }
break; break;
@ -128,17 +133,17 @@ void VToolDetail::Create(QSharedPointer<DialogDetail> &dialog, VMainGraphicsScen
break; break;
} }
VNodeDetail node(id, detail[i].getTypeTool(), NodeDetail::Contour); VNodeDetail node(id, detail[i].getTypeTool(), NodeDetail::Contour);
det.append(node); det->append(node);
} }
det.setName(detail.getName()); det->setName(detail.getName());
Create(0, det, scene, doc, data, Document::FullParse, Tool::FromGui); Create(0, det, scene, doc, data, Document::FullParse, Tool::FromGui);
} }
void VToolDetail::Create(const qint64 _id, VDetail &newDetail, VMainGraphicsScene *scene, VDomDocument *doc, void VToolDetail::Create(const qint64 _id, VDetail *newDetail, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data, const Document::Documents &parse, const Tool::Sources &typeCreation) VContainer *data, const Document::Documents &parse, const Tool::Sources &typeCreation)
{ {
qint64 id = _id; qint64 id = _id;
if (typeCreation == Tool::FromGui) if (typeCreation == Tool::FromGui || typeCreation == Tool::FromTool)
{ {
id = data->AddDetail(newDetail); id = data->AddDetail(newDetail);
} }
@ -161,6 +166,34 @@ void VToolDetail::Create(const qint64 _id, VDetail &newDetail, VMainGraphicsScen
} }
} }
void VToolDetail::Remove()
{
//remove form xml file
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
QDomNode element = domElement.parentNode();
if (element.isNull() == false)
{
//deincrement referens
RemoveReferens();
element.removeChild(domElement);
//update xml file
emit FullUpdateTree();
//remove form scene
emit RemoveTool(this);
}
else
{
qWarning()<<"parentNode isNull"<<Q_FUNC_INFO;
}
}
else
{
qWarning()<<"Can't get element by id = "<<id<<Q_FUNC_INFO;
}
}
void VToolDetail::FullUpdateFromFile() void VToolDetail::FullUpdateFromFile()
{ {
RefreshGeometry(); RefreshGeometry();
@ -191,20 +224,20 @@ void VToolDetail::FullUpdateFromGui(int result)
void VToolDetail::AddToFile() void VToolDetail::AddToFile()
{ {
VDetail detail = VAbstractTool::data.GetDetail(id); const VDetail *detail = VAbstractTool::data.GetDetail(id);
QDomElement domElement = doc->createElement(TagName); QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id); AddAttribute(domElement, AttrId, id);
AddAttribute(domElement, AttrName, detail.getName()); AddAttribute(domElement, AttrName, detail->getName());
AddAttribute(domElement, AttrMx, toMM(detail.getMx())); AddAttribute(domElement, AttrMx, toMM(detail->getMx()));
AddAttribute(domElement, AttrMy, toMM(detail.getMy())); AddAttribute(domElement, AttrMy, toMM(detail->getMy()));
AddAttribute(domElement, AttrSupplement, detail.getSupplement()); AddAttribute(domElement, AttrSupplement, detail->getSupplement());
AddAttribute(domElement, AttrClosed, detail.getClosed()); AddAttribute(domElement, AttrClosed, detail->getClosed());
AddAttribute(domElement, AttrWidth, detail.getWidth()); AddAttribute(domElement, AttrWidth, detail->getWidth());
for (ptrdiff_t i = 0; i < detail.CountNode(); ++i) for (ptrdiff_t i = 0; i < detail->CountNode(); ++i)
{ {
AddNode(domElement, detail[i]); AddNode(domElement, detail->at(i));
} }
QDomElement element; QDomElement element;
@ -220,15 +253,15 @@ void VToolDetail::RefreshDataInFile()
QDomElement domElement = doc->elementById(QString().setNum(id)); QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement()) if (domElement.isElement())
{ {
VDetail det = VAbstractTool::data.GetDetail(id); const VDetail *det = VAbstractTool::data.GetDetail(id);
domElement.setAttribute(AttrName, det.getName()); domElement.setAttribute(AttrName, det->getName());
domElement.setAttribute(AttrSupplement, QString().setNum(det.getSupplement())); domElement.setAttribute(AttrSupplement, QString().setNum(det->getSupplement()));
domElement.setAttribute(AttrClosed, QString().setNum(det.getClosed())); domElement.setAttribute(AttrClosed, QString().setNum(det->getClosed()));
domElement.setAttribute(AttrWidth, QString().setNum(det.getWidth())); domElement.setAttribute(AttrWidth, QString().setNum(det->getWidth()));
RemoveAllChild(domElement); RemoveAllChild(domElement);
for (ptrdiff_t i = 0; i < det.CountNode(); ++i) for (ptrdiff_t i = 0; i < det->CountNode(); ++i)
{ {
AddNode(domElement, det[i]); AddNode(domElement, det->at(i));
} }
} }
} }
@ -286,43 +319,20 @@ void VToolDetail::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
} }
if (selectedAction == actionRemove) if (selectedAction == actionRemove)
{ {
//remove form xml file Remove();
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
QDomNode element = domElement.parentNode();
if (element.isNull() == false)
{
//deincrement referens
RemoveReferens();
element.removeChild(domElement);
//update xml file
emit FullUpdateTree();
//remove form scene
emit RemoveTool(this);
}
else
{
qWarning()<<"parentNode isNull"<<Q_FUNC_INFO;
}
}
else
{
qWarning()<<"Can't get element by id = "<<id<<Q_FUNC_INFO;
}
} }
} }
void VToolDetail::RemoveReferens() void VToolDetail::RemoveReferens()
{ {
VDetail detail = VAbstractTool::data.GetDetail(id); const VDetail *detail = VAbstractTool::data.GetDetail(id);
for (ptrdiff_t i = 0; i< detail.CountNode(); ++i) for (ptrdiff_t i = 0; i< detail->CountNode(); ++i)
{ {
doc->DecrementReferens(detail[i].getId()); doc->DecrementReferens(detail->at(i).getId());
} }
} }
void VToolDetail::AddNode(QDomElement &domElement, VNodeDetail &node) void VToolDetail::AddNode(QDomElement &domElement, const VNodeDetail &node)
{ {
QDomElement nod = doc->createElement(TagNode); QDomElement nod = doc->createElement(TagNode);

9
src/tools/vtooldetail.h
View file

@ -75,7 +75,7 @@ public:
* @param parse * @param parse
* @param typeCreation * @param typeCreation
*/ */
static void Create(const qint64 _id, VDetail &newDetail, VMainGraphicsScene *scene, static void Create(const qint64 _id, VDetail *newDetail, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data, const Document::Documents &parse, VDomDocument *doc, VContainer *data, const Document::Documents &parse,
const Tool::Sources &typeCreation); const Tool::Sources &typeCreation);
template <typename T> template <typename T>
@ -90,8 +90,8 @@ public:
tool->setParentItem(this); tool->setParentItem(this);
connect(tool, &T::ChoosedTool, sceneDetails, &VMainGraphicsScene::ChoosedItem); connect(tool, &T::ChoosedTool, sceneDetails, &VMainGraphicsScene::ChoosedItem);
VNodeDetail node(id, typeTool, Draw::Modeling, NodeDetail::Modeling); VNodeDetail node(id, typeTool, Draw::Modeling, NodeDetail::Modeling);
VDetail det = VAbstractTool::data.GetDetail(this->id); VDetail *det = VAbstractTool::data.GetDetail(this->id);
det.append(node); det->append(node);
VAbstractTool::data.UpdateDetail(this->id, det); VAbstractTool::data.UpdateDetail(this->id, det);
QDomElement domElement = doc->elementById(QString().setNum(this->id)); QDomElement domElement = doc->elementById(QString().setNum(this->id));
if (domElement.isElement()) if (domElement.isElement())
@ -135,6 +135,7 @@ public:
* @brief NodeTypeModeling * @brief NodeTypeModeling
*/ */
static const QString NodeTypeModeling; static const QString NodeTypeModeling;
void Remove();
public slots: public slots:
/** /**
* @brief FullUpdateFromFile * @brief FullUpdateFromFile
@ -200,7 +201,7 @@ private:
* @param domElement * @param domElement
* @param node * @param node
*/ */
void AddNode(QDomElement &domElement, VNodeDetail &node); void AddNode(QDomElement &domElement, const VNodeDetail &node);
template <typename Tool> template <typename Tool>
/** /**
* @brief InitTool * @brief InitTool

721
src/tools/vtooluniondetails.cpp Normal file
View file

@ -0,0 +1,721 @@
/************************************************************************
**
** @file vtooluniondetails.cpp
** @author Roman Telezhinsky <dismine@gmail.com>
** @date 26 12, 2013
**
** @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) 2013 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 "vtooluniondetails.h"
#include "nodeDetails/nodedetails.h"
#include "vtooldetail.h"
const QString VToolUnionDetails::TagName = QStringLiteral("tools");
const QString VToolUnionDetails::ToolType = QStringLiteral("unionDetails");
const QString VToolUnionDetails::TagDetail = QStringLiteral("det");
const QString VToolUnionDetails::TagNode = QStringLiteral("node");
const QString VToolUnionDetails::AttrD1P1 = QStringLiteral("d1P1");
const QString VToolUnionDetails::AttrD1P2 = QStringLiteral("d1P2");
const QString VToolUnionDetails::AttrD2P1 = QStringLiteral("d2P1");
const QString VToolUnionDetails::AttrD2P2 = QStringLiteral("d2P2");
const QString VToolUnionDetails::AttrIdObject = QStringLiteral("idObject");
const QString VToolUnionDetails::AttrNodeType = QStringLiteral("nodeType");
const QString VToolUnionDetails::NodeTypeContour = QStringLiteral("Contour");
const QString VToolUnionDetails::NodeTypeModeling = QStringLiteral("Modeling");
VToolUnionDetails::VToolUnionDetails(VDomDocument *doc, VContainer *data, const qint64 &id, const VDetail &d1,
const VDetail &d2, const qint64 &d1P1, const qint64 &d1P2, const qint64 &d2P1,
const qint64 &d2P2, const Tool::Sources &typeCreation)
:VAbstractTool(doc, data, id), d1(d1), d2(d2), d1P1(d1P1), d1P2(d1P2), d2P1(d2P1), d2P2(d2P2)
{
CorectPoints(this->d1, this->d1P1, this->d1P2);
CorectPoints(this->d2, this->d2P1, this->d2P2);
if (typeCreation == Tool::FromGui)
{
AddToFile();
}
else
{
RefreshDataInFile();
}
}
void VToolUnionDetails::CorectPoints(const VDetail &detail, qint64 &p1, qint64 &p2)
{
if(p1 == p2)
{
qWarning()<<"Union points equal.";
return;
}
bool p1flag = false;
bool p2flag = false;
for (ptrdiff_t i = 0; i< detail.CountNode(); ++i)
{
if(detail.at(i).getTypeTool() == Tool::NodePoint)
{
if(p1 == detail.at(i).getId())
{
p1flag = true;
}
if(p2 == detail.at(i).getId())
{
p2flag = true;
}
if(p1flag == true && p2flag == false)
{
return;
}
if(p2flag == true && p1flag == false)
{
qint64 p = p1;
p1 = p2;
p2 = p;
return;
}
}
}
}
void VToolUnionDetails::AddToNewDetail(VContainer *data, VDetail *newDetail, const VDetail &det, const ptrdiff_t &a,
const ptrdiff_t &b, const qreal &dx, const qreal &dy, const qint64 &pRotate,
const qreal &angle) const
{
for (ptrdiff_t i = a; i <= b; ++i)
{
qint64 id = 0;
switch (det.at(i).getTypeTool())
{
case (Tool::NodePoint):
{
if( qFuzzyCompare(dx+1, 1) && qFuzzyCompare(dy+1, 1) && (pRotate == 0))
{
id = det.at(i).getId();
}
else
{
VPointF *point = new VPointF(*data->GeometricObject<const VPointF *>(det.at(i).getId()));
Q_ASSERT(point != 0);
BiasRotatePoint(point, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(),
angle);
id = data->AddGObject(point);
VNodePoint::Create(doc, data, id, det.at(i).getId(), Document::FullParse, Tool::FromGui );
}
}
break;
case (Tool::NodeArc):
{
if(qFuzzyCompare(dx+1, 1) && qFuzzyCompare(dy+1, 1) && pRotate == 0)
{
id = det.at(i).getId();
}
else
{
const VArc *arc = data->GeometricObject<const VArc *>(det.at(i).getId());
VPointF p1 = VPointF(arc->GetP1().x(), arc->GetP1().y(), "A", 0, 0);
BiasRotatePoint(&p1, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
VPointF p2 = VPointF(arc->GetP2().x(), arc->GetP2().y(), "A", 0, 0);
BiasRotatePoint(&p2, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
VPointF *center = new VPointF(arc->GetCenter());
Q_ASSERT(center != 0);
BiasRotatePoint(center, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(),
angle);
QLineF l1(center->toQPointF(), p1.toQPointF());
QLineF l2(center->toQPointF(), p2.toQPointF());
qint64 idCenter = data->AddGObject(center);
Q_UNUSED(idCenter);
VArc *arc1 = new VArc(*center, arc->GetRadius(), arc->GetFormulaRadius(),
l1.angle(), QString().setNum(l1.angle()), l2.angle(),
QString().setNum(l2.angle()));
Q_ASSERT(arc1 != 0);
id = data->AddGObject(arc1);
VNodeArc::Create(doc, data, id, det.at(i).getId(), Document::FullParse, Tool::FromGui);
}
}
break;
case (Tool::NodeSpline):
{
if(qFuzzyCompare(dx+1, 1) && qFuzzyCompare(dy+1, 1) && pRotate == 0)
{
id = det.at(i).getId();
}
else
{
const VSpline *spline = data->GeometricObject<const VSpline *>(det.at(i).getId());
VPointF *p1 = new VPointF(spline->GetP1());
Q_ASSERT(p1 != 0);
BiasRotatePoint(p1, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
qint64 idP1 = data->AddGObject(p1);
VPointF p2 = VPointF(spline->GetP2().x(), spline->GetP2().y(), "A", 0, 0);
BiasRotatePoint(&p2, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
VPointF p3 = VPointF(spline->GetP3().x(), spline->GetP3().y(), "A", 0, 0);
BiasRotatePoint(&p3, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
VPointF *p4 = new VPointF(spline->GetP4());
Q_ASSERT(p4 != 0);
BiasRotatePoint(p4, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
qint64 idP4 = data->AddGObject(p4);
VSpline *spl = new VSpline(*p1, p2.toQPointF(), p3.toQPointF(), *p4, spline->GetKcurve());
id = data->AddGObject(spl);
VNodeSpline::Create(doc, data, id, det.at(i).getId(), Document::FullParse, Tool::FromGui);
}
}
break;
case (Tool::NodeSplinePath):
{
if(qFuzzyCompare(dx+1, 1) && qFuzzyCompare(dy+1, 1) && pRotate == 0)
{
id = det.at(i).getId();
}
else
{
VSplinePath *path = new VSplinePath();
Q_ASSERT(path != 0);
const VSplinePath *splinePath = data->GeometricObject<const VSplinePath *>(det.at(i).getId());
for (qint32 i = 1; i <= splinePath->Count(); ++i)
{
VSpline spline(splinePath->at(i-1).P(), splinePath->at(i).P(),
splinePath->at(i-1).Angle2(), splinePath->at(i).Angle1(), splinePath->at(i-1).KAsm2(),
splinePath->at(i).KAsm1(), splinePath->getKCurve());
VPointF *p1 = new VPointF(spline.GetP1());
Q_ASSERT(p1 != 0);
BiasRotatePoint(p1, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
qint64 idP1 = data->AddGObject(p1);
VPointF p2 = VPointF(spline.GetP2());
BiasRotatePoint(&p2, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
VPointF p3 = VPointF(spline.GetP3());
BiasRotatePoint(&p3, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
VPointF *p4 = new VPointF(spline.GetP4());
Q_ASSERT(p4 != 0);
BiasRotatePoint(p4, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
qint64 idP4 = data->AddGObject(p4);
VSpline spl = VSpline(*p1, p2.toQPointF(), p3.toQPointF(), *p4, spline.GetKcurve());
if(i==1)
{
path->append(VSplinePoint(*p1, splinePath->at(i-1).KAsm1(), spl.GetAngle1(),
splinePath->at(i-1).KAsm1()));
}
path->append(VSplinePoint(*p4, splinePath->at(i).KAsm1(), spl.GetAngle1(),
splinePath->at(i).KAsm1()));
}
id = data->AddGObject(path);
VNodeSplinePath::Create(doc, data, id, det.at(i).getId(), Document::FullParse, Tool::FromGui);
}
}
break;
default:
qWarning()<<"May be wrong tool type!!! Ignoring."<<Q_FUNC_INFO;
break;
}
newDetail->append(VNodeDetail(id, det.at(i).getTypeTool(), NodeDetail::Contour));
}
}
void VToolUnionDetails::UpdatePoints(const qint64 &idDetail, VContainer *data, const VDetail &det, const ptrdiff_t &a,
const ptrdiff_t &b, const qreal &dx, const qreal &dy, const qint64 &pRotate,
const qreal &angle) const
{
qint64 idCount = 0;
for (ptrdiff_t i = a; i <= b; ++i)
{
switch (det.at(i).getTypeTool())
{
case (Tool::NodePoint):
{
if(qFuzzyCompare(dx+1, 1) && qFuzzyCompare(dy+1, 1) && pRotate == 0)
{
++idCount;
}
else
{
VPointF *point = new VPointF(*data->GeometricObject<const VPointF *>(det.at(i).getId()));
Q_ASSERT(point != 0);
BiasRotatePoint(point, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
++idCount;
data->UpdateGObject(idDetail+idCount, point);
}
}
break;
case (Tool::NodeArc):
{
if(qFuzzyCompare(dx+1, 1) && qFuzzyCompare(dy+1, 1) && pRotate == 0)
{
++idCount;
}
else
{
const VArc *arc = data->GeometricObject<const VArc *>(det.at(i).getId());
VPointF p1 = VPointF(arc->GetP1());
BiasRotatePoint(&p1, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
VPointF p2 = VPointF(arc->GetP2());
BiasRotatePoint(&p2, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
VPointF *center = new VPointF(arc->GetCenter());
Q_ASSERT(center != 0);
BiasRotatePoint(center, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
QLineF l1(center->toQPointF(), p1.toQPointF());
QLineF l2(center->toQPointF(), p2.toQPointF());
qint64 idCenter = data->AddGObject(center);
VArc *arc1 = new VArc(*center, arc->GetRadius(), arc->GetFormulaRadius(), l1.angle(),
QString().setNum(l1.angle()), l2.angle(), QString().setNum(l2.angle()));
Q_ASSERT(arc1);
++idCount;
data->UpdateGObject(idDetail+idCount, arc1);
}
}
break;
case (Tool::NodeSpline):
{
if(qFuzzyCompare(dx+1, 1) && qFuzzyCompare(dy+1, 1) && pRotate == 0)
{
++idCount;
}
else
{
const VSpline *spline = data->GeometricObject<const VSpline *>(det.at(i).getId());
VPointF *p1 = new VPointF(spline->GetP1());
Q_ASSERT(p1 != 0);
BiasRotatePoint(p1, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
qint64 idP1 = data->AddGObject(p1);
VPointF p2 = VPointF(spline->GetP2());
BiasRotatePoint(&p2, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
VPointF p3 = VPointF(spline->GetP3());
BiasRotatePoint(&p3, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
VPointF *p4 = new VPointF(spline->GetP4());
Q_ASSERT(p4 != 0);
BiasRotatePoint(p4, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
qint64 idP4 = data->AddGObject(p4);
VSpline *spl = new VSpline(*p1, p2.toQPointF(), p3.toQPointF(), *p4, spline->GetKcurve());
Q_ASSERT(spl != 0);
++idCount;
data->UpdateGObject(idDetail+idCount, spl);
}
}
break;
case (Tool::NodeSplinePath):
{
if(qFuzzyCompare(dx+1, 1) && qFuzzyCompare(dy+1, 1) && pRotate == 0)
{
++idCount;
}
else
{
VSplinePath *path = new VSplinePath();
Q_ASSERT(path != 0);
const VSplinePath *splinePath = data->GeometricObject<const VSplinePath *>(det.at(i).getId());
for (qint32 i = 1; i <= splinePath->Count(); ++i)
{
VSpline spline(splinePath->at(i-1).P(), splinePath->at(i).P(),
splinePath->at(i-1).Angle2(), splinePath->at(i).Angle1(), splinePath->at(i-1).KAsm2(),
splinePath->at(i).KAsm1(), splinePath->getKCurve());
VPointF *p1 = new VPointF(spline.GetP1());
Q_ASSERT(p1 != 0);
BiasRotatePoint(p1, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
qint64 idP1 = data->AddGObject(p1);
VPointF p2 = VPointF(spline.GetP2());
BiasRotatePoint(&p2, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
VPointF p3 = VPointF(spline.GetP3());
BiasRotatePoint(&p3, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
VPointF *p4 = new VPointF(spline.GetP4());
Q_ASSERT(p4 != 0);
BiasRotatePoint(p4, dx, dy, data->GeometricObject<const VPointF *>(pRotate)->toQPointF(), angle);
qint64 idP4 = data->AddGObject(p4);
VSpline spl = VSpline(*p1, p2.toQPointF(), p3.toQPointF(), *p4, spline.GetKcurve());
if(i==1)
{
path->append(VSplinePoint(*p1, splinePath->at(i-1).KAsm1(), spl.GetAngle1(),
splinePath->at(i-1).KAsm1()));
}
path->append(VSplinePoint(*p4, splinePath->at(i).KAsm1(), spl.GetAngle1(),
splinePath->at(i).KAsm1()));
}
++idCount;
data->UpdateGObject(idDetail+idCount, path);
}
}
break;
default:
qWarning()<<"May be wrong tool type!!! Ignoring."<<Q_FUNC_INFO;
break;
}
}
}
void VToolUnionDetails::BiasRotatePoint(VPointF *point, const qreal &dx, const qreal &dy, const QPointF &pRotate,
const qreal angle) const
{
point->setX(point->x()+dx);
point->setY(point->y()+dy);
QLineF l(pRotate, point->toQPointF());
l.setAngle(angle);
point->setX(l.p2().x());
point->setY(l.p2().y());
}
void VToolUnionDetails::Create(QSharedPointer<DialogUnionDetails> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data)
{
VDetail d1 = VDetail(*data->GetDetail(dialog->getD1()));
VDetail d2 = VDetail(*data->GetDetail(dialog->getD2()));
qint64 d1P1 = dialog->getD1P1();
qint64 d1P2 = dialog->getD1P2();
qint64 d2P1 = dialog->getD2P1();
qint64 d2P2 = dialog->getD2P2();
Create(0, d1, d2, dialog->getD1(), dialog->getD2(), d1P1, d1P2, d2P1, d2P2, scene, doc, data, Document::FullParse,
Tool::FromGui);
}
void VToolUnionDetails::Create(const qint64 _id, const VDetail &d1, const VDetail &d2, const qint64 &d1id,
const qint64 &d2id, const qint64 &d1P1, const qint64 &d1P2, const qint64 &d2P1,
const qint64 &d2P2, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data,
const Document::Documents &parse, const Tool::Sources &typeCreation)
{
VToolUnionDetails *unionDetails = 0;
qint64 id = _id;
if (typeCreation == Tool::FromGui)
{
id = data->getNextId();
}
else
{
if (parse != Document::FullParse)
{
doc->UpdateToolData(id, data);
}
}
if (parse == Document::FullParse)
{
unionDetails = new VToolUnionDetails(doc, data, id, d1, d2, d1P1, d1P2, d2P1, d2P2, typeCreation);
QHash<qint64, VDataTool*>* tools = doc->getTools();
tools->insert(id, unionDetails);
for (ptrdiff_t i = 0; i < d1.CountNode(); ++i)
{
doc->IncrementReferens(d1.at(i).getId());
}
for (ptrdiff_t i = 0; i < d2.CountNode(); ++i)
{
doc->IncrementReferens(d2.at(i).getId());
}
}
if(typeCreation == Tool::FromGui)
{
//Update corected points
qint64 d1P1 = unionDetails->getD1P1();
qint64 d1P2 = unionDetails->getD1P2();
qint64 d2P1 = unionDetails->getD2P1();
qint64 d2P2 = unionDetails->getD2P2();
VDetail *newDetail = new VDetail();
Q_ASSERT(newDetail != 0);
unionDetails->AddToNewDetail(data, newDetail, d1, d1.indexOfNode(d1P1), d1.indexOfNode(d1P2));
const VNodeDetail det1p2 = d1.at(d1.indexOfNode(d1P2));
const VPointF *point2 = data->GeometricObject<const VPointF *>(det1p2.getId());
const VNodeDetail det2p1 = d2.at(d2.indexOfNode(d2P1));
const VPointF *point1 = data->GeometricObject<const VPointF *>(det2p1.getId());
qreal dx = point2->x() - point1->x();
qreal dy = point2->y() - point1->y();
const VNodeDetail det1p1 = d1.at(d1.indexOfNode(d1P1));
const VPointF *point3 = data->GeometricObject<const VPointF *>(det1p1.getId());
const VNodeDetail det2p2 = d1.at(d1.indexOfNode(d2P2));
const VPointF *point4 = data->GeometricObject<const VPointF *>(det2p2.getId());
QLineF l1(point3->toQPointF(), point2->toQPointF());
QLineF l2(point4->toQPointF(), point1->toQPointF());
qreal angle = l2.angle() + l2.angleTo(l1);
unionDetails->AddToNewDetail(data, newDetail, d2, d2.indexOfNode(d2P1)+1, d2.indexOfNode(d2P2)-1, dx, dy,
d1P2, angle);
newDetail->setName("Detail");
VToolDetail::Create(0, newDetail, scene, doc, data, parse, Tool::FromTool);
QHash<qint64, VDataTool*>* tools = doc->getTools();
VToolDetail *toolDet = qobject_cast<VToolDetail*>(tools->value(d1id));
toolDet->Remove();
toolDet = qobject_cast<VToolDetail*>(tools->value(d2id));
toolDet->Remove();
}
else
{
unionDetails = qobject_cast<VToolUnionDetails *>(doc->getTool(id));
unionDetails->UpdatePoints(id, data, d1, d1.indexOfNode(d1P1), d1.indexOfNode(d1P2));
VNodeDetail det1p2 = d1.at(d1.indexOfNode(d1P2));
const VPointF *point2 = data->GeometricObject<const VPointF *>(det1p2.getId());
VNodeDetail det2p1 = d2.at(d2.indexOfNode(d2P1));
const VPointF *point1 = data->GeometricObject<const VPointF *>(det2p1.getId());
qreal dx = point2->x() - point1->x();
qreal dy = point2->y() - point1->y();
const VNodeDetail det1p1 = d1.at(d1.indexOfNode(d1P1));
const VPointF *point3 = data->GeometricObject<const VPointF *>(det1p1.getId());
const VNodeDetail det2p2 = d1.at(d1.indexOfNode(d2P2));
const VPointF *point4 = data->GeometricObject<const VPointF *>(det2p2.getId());
QLineF l1(point3->toQPointF(), point2->toQPointF());
QLineF l2(point4->toQPointF(), point1->toQPointF());
qreal angle = l2.angle() + l2.angleTo(l1);
unionDetails->UpdatePoints(id, data, d2, d2.indexOfNode(d2P1)+1, d2.indexOfNode(d2P2)-1, dx, dy,
d1P2, angle);
}
}
QVector<VDetail> VToolUnionDetails::GetDetailFromFile(VDomDocument *doc, const QDomElement &domElement)
{
QVector<VDetail> vector;
QDomNodeList detailList = domElement.childNodes();
qint32 num = detailList.size();
for (qint32 i = 0; i < num; ++i)
{
QDomElement element = detailList.at(i).toElement();
if (element.isNull() == false)
{
if (element.tagName() == VToolUnionDetails::TagDetail)
{
QDomNodeList nodeList = domElement.childNodes();
qint32 num = nodeList.size();
for (qint32 j = 0; j < num; ++j)
{
QDomElement element = nodeList.at(j).toElement();
if (element.isNull() == false)
{
if (element.tagName() == VToolUnionDetails::TagNode)
{
qint64 id = doc->GetParametrLongLong(element, VToolDetail::AttrIdObject, "0");
qreal mx = toPixel(doc->GetParametrDouble(element, VAbstractTool::AttrMx, "0.0"));
qreal my = toPixel(doc->GetParametrDouble(element, VAbstractTool::AttrMy, "0.0"));
Tool::Tools tool;
NodeDetail::NodeDetails nodeType = NodeDetail::Contour;
QString t = doc->GetParametrString(element, "type", "NodePoint");
if (t == "NodePoint")
{
tool = Tool::NodePoint;
}
else if (t == "NodeArc")
{
tool = Tool::NodeArc;
}
else if (t == "NodeSpline")
{
tool = Tool::NodeSpline;
}
else if (t == "NodeSplinePath")
{
tool = Tool::NodeSplinePath;
}
vector[i].append(VNodeDetail(id, tool, nodeType, mx, my));
}
}
}
}
}
}
return vector;
}
void VToolUnionDetails::AddToFile()
{
QDomElement domElement = doc->createElement(TagName);
AddAttribute(domElement, AttrId, id);
AddAttribute(domElement, AttrType, ToolType);
AddAttribute(domElement, AttrD1P1, d1P1);
AddAttribute(domElement, AttrD1P2, d1P2);
AddAttribute(domElement, AttrD2P1, d2P1);
AddAttribute(domElement, AttrD2P2, d2P2);
AddDetail(domElement, d1);
AddDetail(domElement, d2);
AddToModeling(domElement);
}
void VToolUnionDetails::RefreshDataInFile()
{
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
domElement.setAttribute(AttrD1P1, d1P1);
domElement.setAttribute(AttrD1P2, d1P2);
domElement.setAttribute(AttrD2P1, d2P1);
domElement.setAttribute(AttrD2P2, d2P2);
QDomNode domNode = domElement.firstChild();
domNode = UpdateDetail(domNode, d1);
UpdateDetail(domNode, d2);
}
}
void VToolUnionDetails::AddDetail(QDomElement &domElement, VDetail &d)
{
QDomElement det = doc->createElement(TagDetail);
for (ptrdiff_t i = 0; i < d.CountNode(); ++i)
{
AddNode(det, d[i]);
}
domElement.appendChild(det);
}
void VToolUnionDetails::AddNode(QDomElement &domElement, VNodeDetail &node)
{
QDomElement nod = doc->createElement(TagNode);
AddAttribute(nod, AttrIdObject, node.getId());
AddAttribute(nod, AttrMx, toMM(node.getMx()));
AddAttribute(nod, AttrMy, toMM(node.getMy()));
if (node.getTypeNode() == NodeDetail::Contour)
{
AddAttribute(nod, AttrNodeType, NodeTypeContour);
}
else
{
AddAttribute(nod, AttrNodeType, NodeTypeModeling);
}
switch (node.getTypeTool())
{
case (Tool::NodeArc):
AddAttribute(nod, AttrType, QStringLiteral("NodeArc"));
break;
case (Tool::NodePoint):
AddAttribute(nod, AttrType, QStringLiteral("NodePoint"));
break;
case (Tool::NodeSpline):
AddAttribute(nod, AttrType, QStringLiteral("NodeSpline"));
break;
case (Tool::NodeSplinePath):
AddAttribute(nod, AttrType, QStringLiteral("NodeSplinePath"));
break;
default:
qWarning()<<"May be wrong tool type!!! Ignoring."<<Q_FUNC_INFO;
break;
}
domElement.appendChild(nod);
}
QDomNode VToolUnionDetails::UpdateDetail(QDomNode &domNode, VDetail &d)
{
//QDomNode domNode = domElement.firstChild();
while (domNode.isNull() == false)
{
if (domNode.isElement())
{
QDomElement domElement = domNode.toElement();
if (domElement.isNull() == false)
{
if (domElement.tagName() == VToolUnionDetails::TagDetail)
{
for (ptrdiff_t i = 0; i < d.CountNode(); ++i)
{
UpdateNode(domElement, d[i]);
}
}
}
}
}
return domNode.nextSibling();
}
void VToolUnionDetails::UpdateNode(QDomNode &domNode, VNodeDetail &node)
{
while (domNode.isNull() == false)
{
if (domNode.isElement())
{
QDomElement domElement = domNode.toElement();
if (domElement.isNull() == false)
{
if (domElement.tagName() == VToolUnionDetails::TagNode)
{
domElement.setAttribute( AttrIdObject, node.getId());
domElement.setAttribute(AttrMx, toMM(node.getMx()));
domElement.setAttribute(AttrMy, toMM(node.getMy()));
if (node.getTypeNode() == NodeDetail::Contour)
{
domElement.setAttribute(AttrNodeType, NodeTypeContour);
}
else
{
domElement.setAttribute(AttrNodeType, NodeTypeModeling);
}
switch (node.getTypeTool())
{
case (Tool::NodeArc):
domElement.setAttribute(AttrType, QStringLiteral("NodeArc"));
break;
case (Tool::NodePoint):
domElement.setAttribute(AttrType, QStringLiteral("NodePoint"));
break;
case (Tool::NodeSpline):
domElement.setAttribute(AttrType, QStringLiteral("NodeSpline"));
break;
case (Tool::NodeSplinePath):
domElement.setAttribute(AttrType, QStringLiteral("NodeSplinePath"));
break;
default:
qWarning()<<"May be wrong tool type!!! Ignoring."<<Q_FUNC_INFO;
break;
}
}
}
}
domNode = domNode.nextSibling();
}
}
void VToolUnionDetails::AddToModeling(const QDomElement &domElement)
{
QDomElement modelingElement;
bool ok = doc->GetActivModelingElement(modelingElement);
if (ok)
{
modelingElement.appendChild(domElement);
}
else
{
qCritical()<<tr("Can't find tag Modeling")<< Q_FUNC_INFO;
}
emit toolhaveChange();
}

125
src/tools/vtooluniondetails.h Normal file
View file

@ -0,0 +1,125 @@
/************************************************************************
**
** @file vtooluniondetails.h
** @author Roman Telezhinsky <dismine@gmail.com>
** @date 26 12, 2013
**
** @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) 2013 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 VTOOLUNIONDETAILS_H
#define VTOOLUNIONDETAILS_H
#include "vabstracttool.h"
#include "../dialogs/dialoguniondetails.h"
class VToolUnionDetails : public VAbstractTool
{
Q_OBJECT
public:
VToolUnionDetails(VDomDocument *doc, VContainer *data, const qint64 &id, const VDetail &d1, const VDetail &d2,
const qint64 &d1P1, const qint64 &d1P2, const qint64 &d2P1, const qint64 &d2P2,
const Tool::Sources &typeCreation);
virtual void setDialog() {}
/**
* @brief Create
* @param dialog
* @param doc dom document container
* @param data
*/
static void Create(QSharedPointer<DialogUnionDetails> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data);
/**
* @brief Create
* @param _id
* @param newDetail
* @param scene
* @param doc dom document container
* @param data
* @param parse
* @param typeCreation
*/
static void Create(const qint64 _id, const VDetail &d1, const VDetail &d2, const qint64 &d1id, const qint64 &d2id,
const qint64 &d1P1, const qint64 &d1P2, const qint64 &d2P1, const qint64 &d2P2,
VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data,
const Document::Documents &parse, const Tool::Sources &typeCreation);
static QVector<VDetail> GetDetailFromFile(VDomDocument *doc, const QDomElement &domElement);
/**
* @brief TagName
*/
static const QString TagName;
static const QString ToolType;
static const QString TagDetail;
static const QString TagNode;
static const QString AttrD1P1;
static const QString AttrD1P2;
static const QString AttrD2P1;
static const QString AttrD2P2;
static const QString AttrIdObject;
static const QString AttrNodeType;
static const QString NodeTypeContour;
static const QString NodeTypeModeling;
inline qint64 getD1P1() const{return d1P1;}
inline qint64 getD1P2() const{return d1P2;}
inline qint64 getD2P1() const{return d2P1;}
inline qint64 getD2P2() const{return d2P2;}
void AddToNewDetail(VContainer *data, VDetail *newDetail, const VDetail &det, const ptrdiff_t &a,
const ptrdiff_t &b, const qreal &dx = 0, const qreal &dy = 0, const qint64 &pRotate = 0,
const qreal &angle = 0) const;
void UpdatePoints(const qint64 &idDetail, VContainer *data, const VDetail &det, const ptrdiff_t &a,
const ptrdiff_t &b, const qreal &dx = 0, const qreal &dy = 0, const qint64 &pRotate = 0,
const qreal &angle = 0) const;
void BiasRotatePoint(VPointF *point, const qreal &dx, const qreal &dy, const QPointF &pRotate,
const qreal angle)const;
public slots:
/**
* @brief FullUpdateFromFile
*/
virtual void FullUpdateFromFile (){}
protected:
/**
* @brief AddToFile
*/
virtual void AddToFile();
/**
* @brief RefreshDataInFile refresh attributes in file. If attributes don't exist create them.
*/
virtual void RefreshDataInFile();
private:
Q_DISABLE_COPY(VToolUnionDetails)
VDetail d1;
VDetail d2;
qint64 d1P1;
qint64 d1P2;
qint64 d2P1;
qint64 d2P2;
void AddDetail(QDomElement &domElement, VDetail &d);
void AddNode(QDomElement &domElement, VNodeDetail &node);
QDomNode UpdateDetail(QDomNode &domNode, VDetail &d);
void UpdateNode(QDomNode &domNode, VNodeDetail &node);
void AddToModeling(const QDomElement &domElement);
void CorectPoints(const VDetail &detail, qint64 &p1, qint64 &p2);
};
#endif // VTOOLUNIONDETAILS_H

125
src/xml/vdomdocument.cpp
View file

@ -34,6 +34,7 @@
#include "../exception/vexceptionobjecterror.h" #include "../exception/vexceptionobjecterror.h"
#include "../exception/vexceptionbadid.h" #include "../exception/vexceptionbadid.h"
#include "../tools/vtooldetail.h" #include "../tools/vtooldetail.h"
#include "../tools/vtooluniondetails.h"
#include "../tools/drawTools/drawtools.h" #include "../tools/drawTools/drawtools.h"
#include "../tools/nodeDetails/nodedetails.h" #include "../tools/nodeDetails/nodedetails.h"
@ -371,6 +372,20 @@ void VDomDocument::Parse(const Document::Documents &parse, VMainGraphicsScene *s
} }
} }
VDataTool *VDomDocument::getTool(const qint64 &id)
{
if (tools.contains(id))
{
return tools.value(id);
}
else
{
QString error = QString(tr("Can't find tool id = %1 in table.")).arg(id);
throw VException(error);
}
return 0;
}
void VDomDocument::ParseIncrementsElement(const QDomNode &node) void VDomDocument::ParseIncrementsElement(const QDomNode &node)
{ {
QDomNode domNode = node.firstChild(); QDomNode domNode = node.firstChild();
@ -390,8 +405,7 @@ void VDomDocument::ParseIncrementsElement(const QDomNode &node)
qreal kgrowth = GetParametrDouble(domElement, "kgrowth", "0"); qreal kgrowth = GetParametrDouble(domElement, "kgrowth", "0");
QString desc = GetParametrString(domElement, "description", "Description"); QString desc = GetParametrString(domElement, "description", "Description");
data->UpdateId(id); data->UpdateId(id);
data->AddIncrementTableRow(name, data->AddIncrementTableRow(name, new VIncrementTableRow(id, base, ksize, kgrowth, desc));
VIncrementTableRow(id, base, ksize, kgrowth, desc));
} }
} }
} }
@ -551,6 +565,11 @@ void VDomDocument::ParseDrawMode(VMainGraphicsScene *sceneDraw, VMainGraphicsSce
ParseArcElement(scene, domElement, parse, domElement.attribute("type", "")); ParseArcElement(scene, domElement, parse, domElement.attribute("type", ""));
continue; continue;
} }
if (domElement.tagName() == "tools")
{
ParseToolsElement(scene, domElement, parse, domElement.attribute("type", ""));
continue;
}
} }
} }
} }
@ -562,15 +581,16 @@ void VDomDocument::ParseDetailElement(VMainGraphicsScene *sceneDetail, const QDo
Q_ASSERT_X(domElement.isNull() == false, Q_FUNC_INFO, "domElement is null"); Q_ASSERT_X(domElement.isNull() == false, Q_FUNC_INFO, "domElement is null");
try try
{ {
VDetail detail; VDetail *detail = new VDetail();
Q_ASSERT(detail != 0);
VDetail oldDetail; VDetail oldDetail;
qint64 id = GetParametrId(domElement); qint64 id = GetParametrId(domElement);
detail.setName(GetParametrString(domElement, VAbstractTool::AttrName, "")); detail->setName(GetParametrString(domElement, VAbstractTool::AttrName, ""));
detail.setMx(toPixel(GetParametrDouble(domElement, VAbstractTool::AttrMx, "0.0"))); detail->setMx(toPixel(GetParametrDouble(domElement, VAbstractTool::AttrMx, "0.0")));
detail.setMy(toPixel(GetParametrDouble(domElement, VAbstractTool::AttrMy, "0.0"))); detail->setMy(toPixel(GetParametrDouble(domElement, VAbstractTool::AttrMy, "0.0")));
detail.setSupplement(GetParametrLongLong(domElement, VToolDetail::AttrSupplement, "1")); detail->setSupplement(GetParametrLongLong(domElement, VToolDetail::AttrSupplement, "1"));
detail.setWidth(GetParametrDouble(domElement, VToolDetail::AttrWidth, "10.0")); detail->setWidth(GetParametrDouble(domElement, VToolDetail::AttrWidth, "10.0"));
detail.setClosed(GetParametrLongLong(domElement, VToolDetail::AttrClosed, "1")); detail->setClosed(GetParametrLongLong(domElement, VToolDetail::AttrClosed, "1"));
QDomNodeList nodeList = domElement.childNodes(); QDomNodeList nodeList = domElement.childNodes();
qint32 num = nodeList.size(); qint32 num = nodeList.size();
@ -590,28 +610,28 @@ void VDomDocument::ParseDetailElement(VMainGraphicsScene *sceneDetail, const QDo
if (t == "NodePoint") if (t == "NodePoint")
{ {
tool = Tool::NodePoint; tool = Tool::NodePoint;
VPointF point = data->GetPoint(id); // const VPointF *point = data->GeometricObject<const VPointF *>(id);
oldDetail.append(VNodeDetail(point.getIdObject(), tool, NodeDetail::Contour)); // oldDetail.append(VNodeDetail(point.getIdObject(), tool, NodeDetail::Contour));
} }
else if (t == "NodeArc") else if (t == "NodeArc")
{ {
tool = Tool::NodeArc; tool = Tool::NodeArc;
VArc arc = data->GetArc(id); // VArc arc = data->GetArc(id);
oldDetail.append(VNodeDetail(arc.getIdObject(), tool, NodeDetail::Contour)); // oldDetail.append(VNodeDetail(arc.getIdObject(), tool, NodeDetail::Contour));
} }
else if (t == "NodeSpline") else if (t == "NodeSpline")
{ {
tool = Tool::NodeSpline; tool = Tool::NodeSpline;
VSpline spl = data->GetSpline(id); // VSpline spl = data->GetSpline(id);
oldDetail.append(VNodeDetail(spl.getIdObject(), tool, NodeDetail::Contour)); // oldDetail.append(VNodeDetail(spl.getIdObject(), tool, NodeDetail::Contour));
} }
else if (t == "NodeSplinePath") else if (t == "NodeSplinePath")
{ {
tool = Tool::NodeSplinePath; tool = Tool::NodeSplinePath;
VSplinePath splPath = data->GetSplinePath(id); // VSplinePath splPath = data->GetSplinePath(id);
oldDetail.append(VNodeDetail(splPath.getIdObject(), tool, NodeDetail::Contour)); // oldDetail.append(VNodeDetail(splPath.getIdObject(), tool, NodeDetail::Contour));
} }
detail.append(VNodeDetail(id, tool, nodeType, mx, my)); detail->append(VNodeDetail(id, tool, nodeType, mx, my));
} }
} }
} }
@ -665,7 +685,7 @@ void VDomDocument::ParsePointElement(VMainGraphicsScene *scene, const QDomElemen
qreal mx = toPixel(GetParametrDouble(domElement, VAbstractTool::AttrMx, "10.0")); qreal mx = toPixel(GetParametrDouble(domElement, VAbstractTool::AttrMx, "10.0"));
qreal my = toPixel(GetParametrDouble(domElement, VAbstractTool::AttrMy, "15.0")); qreal my = toPixel(GetParametrDouble(domElement, VAbstractTool::AttrMy, "15.0"));
data->UpdatePoint(id, VPointF(x, y, name, mx, my)); data->UpdateGObject(id, new VPointF(x, y, name, mx, my));
VDrawTool::AddRecord(id, Tool::SinglePointTool, this); VDrawTool::AddRecord(id, Tool::SinglePointTool, this);
if (parse != Document::FullParse) if (parse != Document::FullParse)
{ {
@ -866,10 +886,11 @@ void VDomDocument::ParsePointElement(VMainGraphicsScene *scene, const QDomElemen
{ {
qint64 id = GetParametrId(domElement); qint64 id = GetParametrId(domElement);
qint64 idObject = GetParametrLongLong(domElement, VAbstractNode::AttrIdObject, "0"); qint64 idObject = GetParametrLongLong(domElement, VAbstractNode::AttrIdObject, "0");
VPointF point = data->GetPoint(idObject ); const VPointF *point = data->GeometricObject<const VPointF *>(idObject );
qreal mx = toPixel(GetParametrDouble(domElement, VAbstractTool::AttrMx, "10.0")); qreal mx = toPixel(GetParametrDouble(domElement, VAbstractTool::AttrMx, "10.0"));
qreal my = toPixel(GetParametrDouble(domElement, VAbstractTool::AttrMy, "15.0")); qreal my = toPixel(GetParametrDouble(domElement, VAbstractTool::AttrMy, "15.0"));
data->UpdatePoint(id, VPointF(point.x(), point.y(), point.name(), mx, my, idObject )); data->UpdateGObject(id, new VPointF(point->x(), point->y(), point->name(), mx, my, idObject,
Draw::Modeling));
VNodePoint::Create(this, data, id, idObject, parse, Tool::FromFile); VNodePoint::Create(this, data, id, idObject, parse, Tool::FromFile);
return; return;
} }
@ -1052,7 +1073,8 @@ void VDomDocument::ParseSplineElement(VMainGraphicsScene *scene, const QDomEleme
{ {
qint64 id = GetParametrId(domElement); qint64 id = GetParametrId(domElement);
qreal kCurve = GetParametrDouble(domElement, VAbstractTool::AttrKCurve, "1.0"); qreal kCurve = GetParametrDouble(domElement, VAbstractTool::AttrKCurve, "1.0");
VSplinePath path(data->DataPoints(), kCurve); VSplinePath *path = new VSplinePath(kCurve);
Q_ASSERT(path != 0);
QDomNodeList nodeList = domElement.childNodes(); QDomNodeList nodeList = domElement.childNodes();
qint32 num = nodeList.size(); qint32 num = nodeList.size();
@ -1067,8 +1089,10 @@ void VDomDocument::ParseSplineElement(VMainGraphicsScene *scene, const QDomEleme
qreal angle = GetParametrDouble(element, VAbstractTool::AttrAngle, "0"); qreal angle = GetParametrDouble(element, VAbstractTool::AttrAngle, "0");
qreal kAsm2 = GetParametrDouble(element, VAbstractTool::AttrKAsm2, "1.0"); qreal kAsm2 = GetParametrDouble(element, VAbstractTool::AttrKAsm2, "1.0");
qint64 pSpline = GetParametrLongLong(element, VAbstractTool::AttrPSpline, "0"); qint64 pSpline = GetParametrLongLong(element, VAbstractTool::AttrPSpline, "0");
VSplinePoint splPoint(pSpline, kAsm1, angle, kAsm2); VPointF p = *data->GeometricObject<const VPointF *>(pSpline);
path.append(splPoint);
VSplinePoint splPoint(p, kAsm1, angle, kAsm2);
path->append(splPoint);
if (parse == Document::FullParse) if (parse == Document::FullParse)
{ {
IncrementReferens(pSpline); IncrementReferens(pSpline);
@ -1093,9 +1117,10 @@ void VDomDocument::ParseSplineElement(VMainGraphicsScene *scene, const QDomEleme
{ {
qint64 id = GetParametrId(domElement); qint64 id = GetParametrId(domElement);
qint64 idObject = GetParametrLongLong(domElement, VAbstractNode::AttrIdObject, "0"); qint64 idObject = GetParametrLongLong(domElement, VAbstractNode::AttrIdObject, "0");
VSpline spl = data->GetSpline(idObject); VSpline *spl = new VSpline(*data->GeometricObject<const VSpline *>(idObject));
spl.setIdObject(idObject); Q_ASSERT(spl != 0);
data->UpdateSpline(id, spl); spl->setIdObject(idObject);
data->UpdateGObject(id, spl);
VNodeSpline::Create(this, data, id, idObject, parse, Tool::FromFile); VNodeSpline::Create(this, data, id, idObject, parse, Tool::FromFile);
return; return;
} }
@ -1112,9 +1137,10 @@ void VDomDocument::ParseSplineElement(VMainGraphicsScene *scene, const QDomEleme
{ {
qint64 id = GetParametrId(domElement); qint64 id = GetParametrId(domElement);
qint64 idObject = GetParametrLongLong(domElement, VAbstractNode::AttrIdObject, "0"); qint64 idObject = GetParametrLongLong(domElement, VAbstractNode::AttrIdObject, "0");
VSplinePath path = data->GetSplinePath(idObject); VSplinePath *path = new VSplinePath(*data->GeometricObject<const VSplinePath *>(idObject));
path.setIdObject(idObject); Q_ASSERT(path != 0);
data->UpdateSplinePath(id, path); path->setIdObject(idObject);
data->UpdateGObject(id, path);
VNodeSplinePath::Create(this, data, id, idObject, parse, Tool::FromFile); VNodeSplinePath::Create(this, data, id, idObject, parse, Tool::FromFile);
return; return;
} }
@ -1160,9 +1186,10 @@ void VDomDocument::ParseArcElement(VMainGraphicsScene *scene, const QDomElement
{ {
qint64 id = GetParametrId(domElement); qint64 id = GetParametrId(domElement);
qint64 idObject = GetParametrLongLong(domElement, VAbstractNode::AttrIdObject, "0"); qint64 idObject = GetParametrLongLong(domElement, VAbstractNode::AttrIdObject, "0");
VArc arc = data->GetArc(idObject); VArc *arc = new VArc(*data->GeometricObject<const VArc *>(idObject));
arc.setIdObject(idObject); Q_ASSERT(arc != 0);
data->UpdateArc(id, arc); arc->setIdObject(idObject);
data->UpdateGObject(id, arc);
VNodeArc::Create(this, data, id, idObject, parse, Tool::FromFile); VNodeArc::Create(this, data, id, idObject, parse, Tool::FromFile);
return; return;
} }
@ -1175,6 +1202,38 @@ void VDomDocument::ParseArcElement(VMainGraphicsScene *scene, const QDomElement
} }
} }
void VDomDocument::ParseToolsElement(VMainGraphicsScene *scene, const QDomElement &domElement,
const Document::Documents &parse, const QString &type)
{
Q_ASSERT(scene != 0);
Q_ASSERT_X(domElement.isNull() == false, Q_FUNC_INFO, "domElement is null");
Q_ASSERT_X(type.isEmpty() == false, Q_FUNC_INFO, "type of spline is empty");
if (type == VToolUnionDetails::ToolType)
{
try
{
qint64 id = GetParametrId(domElement);
qint64 d1P1 = GetParametrLongLong(domElement, VToolUnionDetails::AttrD1P1, "0");
qint64 d1P2 = GetParametrLongLong(domElement, VToolUnionDetails::AttrD1P2, "0");
qint64 d2P1 = GetParametrLongLong(domElement, VToolUnionDetails::AttrD2P1, "0");
qint64 d2P2 = GetParametrLongLong(domElement, VToolUnionDetails::AttrD2P2, "0");
QVector<VDetail> vector = VToolUnionDetails::GetDetailFromFile(this, domElement);
VToolUnionDetails::Create(id, vector[0], vector[1], 0, 0, d1P1, d1P2, d2P1, d2P2, scene, this, data, parse,
Tool::FromFile);
return;
}
catch (const VExceptionBadId &e)
{
VExceptionObjectError excep(tr("Error creating or updating union details"), domElement);
excep.AddMoreInformation(e.ErrorMessage());
throw excep;
}
}
}
void VDomDocument::FullUpdateTree() void VDomDocument::FullUpdateTree()
{ {
VMainGraphicsScene *scene = new VMainGraphicsScene(); VMainGraphicsScene *scene = new VMainGraphicsScene();

3
src/xml/vdomdocument.h
View file

@ -155,6 +155,7 @@ public:
* @return * @return
*/ */
inline QHash<qint64, VDataTool*>* getTools() {return &tools;} inline QHash<qint64, VDataTool*>* getTools() {return &tools;}
VDataTool* getTool(const qint64 &id);
/** /**
* @brief getHistory * @brief getHistory
* @return * @return
@ -403,6 +404,8 @@ private:
*/ */
void ParseArcElement(VMainGraphicsScene *scene, const QDomElement& domElement, void ParseArcElement(VMainGraphicsScene *scene, const QDomElement& domElement,
const Document::Documents &parse, const QString& type); const Document::Documents &parse, const QString& type);
void ParseToolsElement(VMainGraphicsScene *scene, const QDomElement& domElement,
const Document::Documents &parse, const QString& type);
/** /**
* @brief ParseIncrementsElement * @brief ParseIncrementsElement
* @param node * @param node