valentina/src/container/vcontainer.cpp

411 lines
11 KiB
C++
Raw Normal View History

/************************************************************************
**
** @file vcontainer.cpp
** @author Roman Telezhinsky <dismine@gmail.com>
** @date November 15, 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/>.
**
*************************************************************************/
2013-07-13 12:51:31 +02:00
#include "vcontainer.h"
2013-07-17 13:38:11 +02:00
#include <QDebug>
#include <QtAlgorithms>
quint32 VContainer::_id = 0;
2013-08-15 22:39:00 +02:00
VContainer::VContainer()
:_size(50), sizeName("Сг"), _height(176), heightName("P"), gObjects(QHash<quint32, VGObject *>()),
measurements(QHash<QString, VMeasurement>()), incrementTable(QHash<QString, VIncrementTableRow>()),
lengthLines(QHash<QString, qreal>()), lineAngles(QHash<QString, qreal>()), lengthSplines(QHash<QString, qreal>()),
lengthArcs(QHash<QString, qreal>()), details(QHash<quint32, VDetail>())
{
2013-07-13 12:51:31 +02:00
}
VContainer &VContainer::operator =(const VContainer &data)
{
2013-08-15 22:39:00 +02:00
setData(data);
return *this;
}
VContainer::VContainer(const VContainer &data)
:_size(50), sizeName("Сг"), _height(176), heightName("P"), gObjects(QHash<quint32, VGObject *>()),
measurements(QHash<QString, VMeasurement>()), incrementTable(QHash<QString, VIncrementTableRow>()),
lengthLines(QHash<QString, qreal>()), lineAngles(QHash<QString, qreal>()), lengthSplines(QHash<QString, qreal>()),
lengthArcs(QHash<QString, qreal>()), details(QHash<quint32, VDetail>())
{
2013-08-29 12:31:50 +02:00
setData(data);
}
VContainer::~VContainer()
{
qDeleteAll(gObjects);
gObjects.clear();
}
void VContainer::setData(const VContainer &data)
{
_size = data.size();
sizeName = data.SizeName();
_height = data.height();
heightName = data.HeightName();
qDeleteAll(gObjects);
gObjects.clear();
const QHash<quint32, VGObject*> *obj = data.DataGObjects();
Q_CHECK_PTR(obj);
QHashIterator<quint32, VGObject*> i(*obj);
while (i.hasNext())
{
i.next();
switch (i.value()->getType())
{
case (GObject::Arc):
{
CopyGObject<VArc>(data, i.key());
break;
}
case (GObject::Point):
{
CopyGObject<VPointF>(data, i.key());
break;
}
case (GObject::Spline):
{
CopyGObject<VSpline>(data, i.key());
break;
}
case (GObject::SplinePath):
{
CopyGObject<VSplinePath>(data, i.key());
break;
}
default:
qWarning()<<"Don't know how copy this type.";
}
}
measurements = *data.DataMeasurements();
2013-08-15 22:39:00 +02:00
incrementTable = *data.DataIncrementTable();
lengthLines = *data.DataLengthLines();
lineAngles = *data.DataLineAngles();
2013-08-15 22:39:00 +02:00
lengthSplines = *data.DataLengthSplines();
lengthArcs = *data.DataLengthArcs();
2013-08-28 10:55:11 +02:00
details = *data.DataDetails();
2013-08-15 22:39:00 +02:00
}
const VGObject *VContainer::GetGObject(quint32 id)const
{
return GetObject(gObjects, id);
}
template <typename key, typename val>
const val VContainer::GetObject(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);
2013-07-13 12:51:31 +02:00
}
}
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 VMeasurement VContainer::GetMeasurement(const QString &name) const
{
Q_ASSERT(name.isEmpty()==false);
return GetVariable(measurements, name);
2013-07-17 13:38:11 +02:00
}
const VIncrementTableRow VContainer::GetIncrementTableRow(const QString& name) const
{
Q_ASSERT(name.isEmpty()==false);
return GetVariable(incrementTable, name);
2013-07-17 13:38:11 +02:00
}
qreal VContainer::GetLine(const QString &name) const
{
Q_ASSERT(name.isEmpty()==false);
return GetVariable(lengthLines, name);
}
qreal VContainer::GetLengthArc(const QString &name) const
{
Q_ASSERT(name.isEmpty()==false);
return GetVariable(lengthArcs, name);
}
qreal VContainer::GetLengthSpline(const QString &name) const
{
Q_ASSERT(name.isEmpty()==false);
return GetVariable(lengthSplines, name);
}
qreal VContainer::GetLineAngle(const QString &name) const
{
Q_ASSERT(name.isEmpty()==false);
return GetVariable(lineAngles, name);
}
const VDetail VContainer::GetDetail(quint32 id) const
{
return GetVariable(details, id);
}
quint32 VContainer::AddGObject(VGObject *obj)
{
return AddObject(gObjects, obj);
2013-07-17 13:38:11 +02:00
}
quint32 VContainer::AddDetail(VDetail detail)
{
quint32 id = getNextId();
details[id] = detail;
return id;
}
void VContainer::AddIncrementTableRow(const QString &name, VIncrementTableRow row)
{
incrementTable[name] = row;
2013-07-13 12:51:31 +02:00
}
quint32 VContainer::getNextId()
{
2013-09-12 16:18:31 +02:00
_id++;
2013-07-13 12:51:31 +02:00
return _id;
}
void VContainer::UpdateId(quint32 newId)
{
if (newId > _id)
{
2013-09-12 16:18:31 +02:00
_id = newId;
}
}
template <typename val>
void VContainer::UpdateObject(QHash<quint32, val> &obj, const quint32 &id, val point)
{
Q_ASSERT_X(id > 0, Q_FUNC_INFO, "id <= 0");
Q_CHECK_PTR(point);
point->setId(id);
if (gObjects.contains(id))
{
delete gObjects.value(id);
gObjects.remove(id);
}
obj[id] = point;
UpdateId(id);
}
void VContainer::AddLengthSpline(const QString &name, const qreal &value)
{
Q_ASSERT(name.isEmpty() == false);
lengthSplines[name] = value;
}
void VContainer::AddLengthArc(const quint32 &id)
{
const VArc * arc = GeometricObject<const VArc *>(id);
lengthArcs[arc->name()] = fromPixel(arc->GetLength());
}
void VContainer::AddLineAngle(const QString &name, const qreal &value)
{
Q_ASSERT(name.isEmpty() == false);
2013-08-21 10:03:53 +02:00
lineAngles[name] = value;
}
qreal VContainer::GetValueStandardTableRow(const QString& name) const
{
const VMeasurement m = GetMeasurement(name);
if (patternType == Pattern::Individual)
{
return m.GetValue();
}
else
{
return m.GetValue(size(), height());
}
2013-07-17 13:38:11 +02:00
}
qreal VContainer::GetValueIncrementTableRow(const QString& name) const
{
const VIncrementTableRow row = GetIncrementTableRow(name);
const qreal k_size = ( size() - 50.0 ) / 2.0;
const qreal k_growth = ( height() - 176.0 ) / 6.0;
const qreal value = row.getBase() + k_size * row.getKsize() + k_growth * row.getKgrowth();
2013-07-17 13:38:11 +02:00
return value;
}
void VContainer::Clear()
{
2013-07-13 12:51:31 +02:00
_id = 0;
measurements.clear();
2013-07-17 13:38:11 +02:00
incrementTable.clear();
2013-07-25 14:00:51 +02:00
lengthLines.clear();
2013-08-05 10:37:56 +02:00
lengthArcs.clear();
2013-08-21 10:03:53 +02:00
lineAngles.clear();
2013-08-28 10:55:11 +02:00
details.clear();
lengthSplines.clear();
ClearGObjects();
2013-07-17 13:38:11 +02:00
}
void VContainer::ClearGObjects()
{
if (gObjects.size()>0)
{
qDeleteAll(gObjects);
}
gObjects.clear();
2013-08-15 22:39:00 +02:00
}
void VContainer::ClearCalculationGObjects()
{
if (gObjects.size()>0)
{
QHashIterator<quint32, VGObject*> i(gObjects);
while (i.hasNext())
{
i.next();
2014-03-11 12:43:24 +01:00
if (i.value()->getMode() == Valentina::Calculation)
{
delete i.value();
gObjects.remove(i.key());
}
}
}
}
qreal VContainer::FindVar(const QString &name, bool *ok)const
{
if (sizeName == name)
{
2013-07-17 13:38:11 +02:00
*ok = true;
return _size;
}
if (heightName == name)
{
*ok = true;
return _height;
2013-07-17 13:38:11 +02:00
}
if (measurements.contains(name))
{
2013-07-17 13:38:11 +02:00
*ok = true;
return GetValueStandardTableRow(name);
2013-07-17 13:38:11 +02:00
}
if (incrementTable.contains(name))
{
2013-07-17 13:38:11 +02:00
*ok = true;
2013-07-25 14:00:51 +02:00
return GetValueIncrementTableRow(name);
}
if (lengthLines.contains(name))
{
2013-07-25 14:00:51 +02:00
*ok = true;
return lengthLines.value(name);
2013-07-17 13:38:11 +02:00
}
if (lengthArcs.contains(name))
{
2013-08-06 09:56:09 +02:00
*ok = true;
return lengthArcs.value(name);
}
if (lineAngles.contains(name))
{
2013-08-06 09:56:09 +02:00
*ok = true;
2013-08-21 10:03:53 +02:00
return lineAngles.value(name);
2013-08-06 09:56:09 +02:00
}
if (lengthSplines.contains(name))
{
*ok = true;
return lengthSplines.value(name);
}
2013-07-17 13:38:11 +02:00
*ok = false;
return 0;
}
void VContainer::AddLine(const quint32 &firstPointId, const quint32 &secondPointId)
{
QString nameLine = GetNameLine(firstPointId, secondPointId);
const VPointF *first = GeometricObject<const VPointF *>(firstPointId);
const VPointF *second = GeometricObject<const VPointF *>(secondPointId);
AddLengthLine(nameLine, fromPixel(QLineF(first->toQPointF(), second->toQPointF()).length()));
nameLine = GetNameLineAngle(firstPointId, secondPointId);
AddLineAngle(nameLine, QLineF(first->toQPointF(), second->toQPointF()).angle());
2013-07-30 15:09:34 +02:00
}
2013-10-27 11:22:44 +01:00
template <typename key, typename val>
quint32 VContainer::AddObject(QHash<key, val> &obj, val value)
{
Q_CHECK_PTR(value);
quint32 id = getNextId();
value->setId(id);
2013-10-27 11:22:44 +01:00
obj[id] = value;
return id;
}
QString VContainer::GetNameLine(const quint32 &firstPoint, const quint32 &secondPoint) const
{
const VPointF *first = GeometricObject<const VPointF *>(firstPoint);
const VPointF *second = GeometricObject<const VPointF *>(secondPoint);
return QString("Line_%1_%2").arg(first->name(), second->name());
2013-07-30 15:09:34 +02:00
}
QString VContainer::GetNameLineAngle(const quint32 &firstPoint, const quint32 &secondPoint) const
{
const VPointF *first = GeometricObject<const VPointF *>(firstPoint);
const VPointF *second = GeometricObject<const VPointF *>(secondPoint);
return QString("AngleLine_%1_%2").arg(first->name(), second->name());
2013-08-05 10:37:56 +02:00
}
void VContainer::UpdateGObject(quint32 id, VGObject* obj)
{
UpdateObject(gObjects, id, obj);
2013-10-27 11:22:44 +01:00
}
void VContainer::UpdateDetail(quint32 id, const VDetail &detail)
{
Q_ASSERT_X(id > 0, Q_FUNC_INFO, "id <= 0");
details[id] = detail;
UpdateId(id);
2013-10-27 11:22:44 +01:00
}
void VContainer::AddLengthLine(const QString &name, const qreal &value)
{
Q_ASSERT(name.isEmpty() == false);
2013-08-06 09:56:09 +02:00
lengthLines[name] = value;
2013-07-17 13:38:11 +02:00
}