From 40436a5c5744459dbc5eb2a2a6c1e01346f37890 Mon Sep 17 00:00:00 2001 From: Roman Telezhynskyi Date: Fri, 4 Mar 2016 18:08:29 +0200 Subject: [PATCH] Successfull build, bugs was not fixed. --HG-- branch : feature --- .../core/vtooloptionspropertybrowser.cpp | 17 - src/app/valentina/xml/vpattern.cpp | 130 ++- src/app/valentina/xml/vpattern.h | 4 + src/libs/ifc/schema/pattern/v0.2.7.xsd | 4 + src/libs/ifc/xml/vdomdocument.cpp | 26 +- src/libs/ifc/xml/vdomdocument.h | 3 +- src/libs/vgeometry/vsplinepath.cpp | 217 ++++- src/libs/vgeometry/vsplinepath.h | 156 +--- src/libs/vgeometry/vsplinepath_p.h | 13 +- src/libs/vgeometry/vsplinepoint.cpp | 177 +++- src/libs/vgeometry/vsplinepoint.h | 59 +- src/libs/vgeometry/vsplinepoint_p.h | 120 ++- .../vtools/dialogs/tools/dialogsplinepath.cpp | 660 ++++++++++--- .../vtools/dialogs/tools/dialogsplinepath.h | 89 +- .../vtools/dialogs/tools/dialogsplinepath.ui | 864 +++++++++++++++--- .../drawTools/toolcurve/vabstractspline.cpp | 61 ++ .../drawTools/toolcurve/vabstractspline.h | 3 + .../tools/drawTools/toolcurve/vtoolspline.cpp | 61 +- .../drawTools/toolcurve/vtoolsplinepath.cpp | 207 +++-- .../drawTools/toolcurve/vtoolsplinepath.h | 11 +- .../toolcut/vtoolcutsplinepath.cpp | 38 +- src/libs/vtools/tools/vtooldetail.cpp | 2 +- src/libs/vtools/tools/vtooluniondetails.cpp | 51 +- .../vtools/undocommands/movesplinepath.cpp | 3 +- .../vtools/undocommands/savedetailoptions.cpp | 4 +- .../visualization/vistoolcutsplinepath.cpp | 43 +- .../visualization/vistoolsplinepath.cpp | 22 +- src/test/ValentinaTest/tst_vdetail.cpp | 16 +- 28 files changed, 2296 insertions(+), 765 deletions(-) diff --git a/src/app/valentina/core/vtooloptionspropertybrowser.cpp b/src/app/valentina/core/vtooloptionspropertybrowser.cpp index 9329e657f..5e148e876 100644 --- a/src/app/valentina/core/vtooloptionspropertybrowser.cpp +++ b/src/app/valentina/core/vtooloptionspropertybrowser.cpp @@ -1361,13 +1361,6 @@ void VToolOptionsPropertyBrowser::ChangeDataToolSplinePath(VProperty *property) case 0: // AttrName Q_UNREACHABLE();//The attribute is read only break; - case 25: // AttrKCurve - { - VSplinePath splPath = i->getSplinePath(); - splPath.SetKCurve(value.toDouble()); - i->setSplinePath(splPath); - break; - } case 27: // AttrTypeColor i->SetLineColor(value.toString()); break; @@ -1777,15 +1770,6 @@ void VToolOptionsPropertyBrowser::ShowOptionsToolSplinePath(QGraphicsItem *item) formView->setTitle(tr("Tool for path curve")); AddPropertyObjectName(i, tr("Name"), true); - - VDoubleProperty* itemFactor = new VDoubleProperty(tr("Curve factor")); - VSplinePath splPath = i->getSplinePath(); - itemFactor->setSetting("Min", 0.1); - itemFactor->setSetting("Max", 1000); - itemFactor->setSetting("Step", 0.01); - itemFactor->setSetting("Precision", 3); - itemFactor->setValue(splPath.GetKCurve()); - AddProperty(itemFactor, AttrKCurve); AddPropertyLineColor(i, tr("Color"), VAbstractTool::ColorsList(), AttrColor); } @@ -2212,7 +2196,6 @@ void VToolOptionsPropertyBrowser::UpdateOptionsToolSplinePath() auto i = qgraphicsitem_cast(currentItem); idToProperty[AttrName]->setValue(i->name()); - idToProperty[AttrKCurve]->setValue(i->getSplinePath().GetKCurve()); idToProperty[AttrColor]->setValue(VLineColorProperty::IndexOfColor(VAbstractTool::ColorsList(), i->GetLineColor())); } diff --git a/src/app/valentina/xml/vpattern.cpp b/src/app/valentina/xml/vpattern.cpp index e197d5a8f..10eb79d79 100644 --- a/src/app/valentina/xml/vpattern.cpp +++ b/src/app/valentina/xml/vpattern.cpp @@ -1939,7 +1939,7 @@ void VPattern::ParseToolSpline(VMainGraphicsScene *scene, QDomElement &domElemen } //--------------------------------------------------------------------------------------------------------------------- -void VPattern::ParseToolSplinePath(VMainGraphicsScene *scene, const QDomElement &domElement, const Document &parse) +void VPattern::ParseOldToolSplinePath(VMainGraphicsScene *scene, const QDomElement &domElement, const Document &parse) { SCASSERT(scene != nullptr); Q_ASSERT_X(not domElement.isNull(), Q_FUNC_INFO, "domElement is null"); @@ -1953,11 +1953,7 @@ void VPattern::ParseToolSplinePath(VMainGraphicsScene *scene, const QDomElement const QString color = GetParametrString(domElement, AttrColor, ColorBlack); const quint32 duplicate = GetParametrUInt(domElement, AttrDuplicate, "0"); - auto path = new VSplinePath(kCurve); - if (duplicate > 0) - { - path->SetDuplicate(duplicate); - } + QVector points; const QDomNodeList nodeList = domElement.childNodes(); const qint32 num = nodeList.size(); @@ -1977,8 +1973,8 @@ void VPattern::ParseToolSplinePath(VMainGraphicsScene *scene, const QDomElement QLineF line(0, 0, 100, 0); line.setAngle(angle+180); - VSplinePoint splPoint(p, kAsm1, line.angle(), kAsm2, angle); - path->append(splPoint); + VFSplinePoint splPoint(p, kAsm1, line.angle(), kAsm2, angle); + points.append(splPoint); if (parse == Document::FullParse) { IncrementReferens(p.getIdTool()); @@ -1987,6 +1983,12 @@ void VPattern::ParseToolSplinePath(VMainGraphicsScene *scene, const QDomElement } } + auto path = new VSplinePath(points, kCurve); + if (duplicate > 0) + { + path->SetDuplicate(duplicate); + } + VToolSplinePath::Create(id, path, color, scene, this, data, parse, Source::FromFile); } catch (const VExceptionBadId &e) @@ -1997,6 +1999,95 @@ void VPattern::ParseToolSplinePath(VMainGraphicsScene *scene, const QDomElement } } +//--------------------------------------------------------------------------------------------------------------------- +void VPattern::ParseToolSplinePath(VMainGraphicsScene *scene, const QDomElement &domElement, const Document &parse) +{ + SCASSERT(scene != nullptr); + Q_ASSERT_X(not domElement.isNull(), Q_FUNC_INFO, "domElement is null"); + + try + { + quint32 id = 0; + + ToolsCommonAttributes(domElement, id); + const QString color = GetParametrString(domElement, AttrColor, ColorBlack); + const quint32 duplicate = GetParametrUInt(domElement, AttrDuplicate, "0"); + + auto path = new VSplinePath(); + if (duplicate > 0) + { + path->SetDuplicate(duplicate); + } + + QVector points; + QVector angle1, a1; + QVector angle2, a2; + QVector length1, l1; + QVector length2, l2; + + const QDomNodeList nodeList = domElement.childNodes(); + const qint32 num = nodeList.size(); + for (qint32 i = 0; i < num; ++i) + { + const QDomElement element = nodeList.at(i).toElement(); + if (not element.isNull() && element.tagName() == AttrPathPoint) + { + angle1.append(GetParametrString(element, AttrAngle1, "0")); + angle2.append(GetParametrString(element, AttrAngle2, "0")); + length1.append(GetParametrString(element, AttrLength1, "0")); + length2.append(GetParametrString(element, AttrLength2, "0")); + const quint32 pSpline = GetParametrUInt(element, AttrPSpline, NULL_ID_STR); + points.append(pSpline); + + if (parse == Document::FullParse) + { + IncrementReferens(data->GeometricObject(pSpline)->getIdTool()); + } + } + } + + //need for saving fixed formula; + a1 = angle1; + a2 = angle2; + l1 = length1; + l2 = length2; + + VToolSplinePath::Create(id, points, a1, a2, l1, l2, color, scene, this, data, parse, Source::FromFile); + //Rewrite attribute formula. Need for situation when we have wrong formula. + int count = 0; + for (qint32 i = 0; i < num; ++i) + { + QDomElement element = nodeList.at(i).toElement(); + if (not element.isNull() && element.tagName() == AttrPathPoint) + { + if (a1.at(count) != angle1.at(count) || a2.at(count) != angle2.at(count) || + l1.at(count) != length1.at(count) || l2.at(count) != length2.at(count)) + { + SetAttribute(element, AttrAngle1, a1.at(count)); + SetAttribute(element, AttrAngle2, a2.at(count)); + SetAttribute(element, AttrLength1, l1.at(count)); + SetAttribute(element, AttrLength2, l2.at(count)); + modified = true; + haveLiteChange(); + } + ++count; + } + } + } + catch (const VExceptionBadId &e) + { + VExceptionObjectError excep(tr("Error creating or updating curve path"), domElement); + excep.AddMoreInformation(e.ErrorMessage()); + throw excep; + } + catch (qmu::QmuParserError &e) + { + VExceptionObjectError excep(tr("Error creating or updating interactive spline path"), domElement); + excep.AddMoreInformation(QString("Message: " + e.GetMsg() + "\n"+ "Expression: " + e.GetExpr())); + throw excep; + } +} + //--------------------------------------------------------------------------------------------------------------------- void VPattern::ParseNodeSpline(const QDomElement &domElement, const Document &parse) { @@ -2281,30 +2372,35 @@ void VPattern::ParseSplineElement(VMainGraphicsScene *scene, QDomElement &domEle 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"); - QStringList splines = QStringList() << VToolSpline::OldToolType /*0*/ - << VToolSpline::ToolType /*1*/ - << VToolSplinePath::ToolType /*2*/ - << VNodeSpline::ToolType /*3*/ - << VNodeSplinePath::ToolType; /*4*/ + QStringList splines = QStringList() << VToolSpline::OldToolType /*0*/ + << VToolSpline::ToolType /*1*/ + << VToolSplinePath::OldToolType /*2*/ + << VToolSplinePath::ToolType /*3*/ + << VNodeSpline::ToolType /*4*/ + << VNodeSplinePath::ToolType; /*5*/ switch (splines.indexOf(type)) { case 0: //VToolSpline::OldToolType - qCDebug(vXML, "VToolSpline."); + qCDebug(vXML, "VOldToolSpline."); ParseOldToolSpline(scene, domElement, parse);// TODO. Delete if minimal supported version is 0.2.7 break; case 1: //VToolSpline::ToolType qCDebug(vXML, "VToolSpline."); ParseToolSpline(scene, domElement, parse); break; - case 2: //VToolSplinePath::ToolType + case 2: //VToolSplinePath::OldToolType + qCDebug(vXML, "VOldToolSplinePath."); + ParseOldToolSplinePath(scene, domElement, parse);// TODO. Delete if minimal supported version is 0.2.7 + break; + case 3: //VToolSplinePath::ToolType qCDebug(vXML, "VToolSplinePath."); ParseToolSplinePath(scene, domElement, parse); break; - case 3: //VNodeSpline::ToolType + case 4: //VNodeSpline::ToolType qCDebug(vXML, "VNodeSpline."); ParseNodeSpline(domElement, parse); break; - case 4: //VNodeSplinePath::ToolType + case 5: //VNodeSplinePath::ToolType qCDebug(vXML, "VNodeSplinePath."); ParseNodeSplinePath(domElement, parse); break; diff --git a/src/app/valentina/xml/vpattern.h b/src/app/valentina/xml/vpattern.h index c6ba1b231..8e78a4722 100644 --- a/src/app/valentina/xml/vpattern.h +++ b/src/app/valentina/xml/vpattern.h @@ -171,6 +171,10 @@ private: void ParseOldToolSpline(VMainGraphicsScene *scene, const QDomElement &domElement, const Document &parse); void ParseToolSpline(VMainGraphicsScene *scene, QDomElement &domElement, const Document &parse); + + // TODO. Delete if minimal supported version is 0.2.7 + void ParseOldToolSplinePath(VMainGraphicsScene *scene, const QDomElement &domElement, const Document &parse); + void ParseToolSplinePath(VMainGraphicsScene *scene, const QDomElement &domElement, const Document &parse); void ParseNodeSpline(const QDomElement &domElement, const Document &parse); void ParseNodeSplinePath(const QDomElement &domElement, const Document &parse); diff --git a/src/libs/ifc/schema/pattern/v0.2.7.xsd b/src/libs/ifc/schema/pattern/v0.2.7.xsd index 0221f3b68..3db42ee88 100644 --- a/src/libs/ifc/schema/pattern/v0.2.7.xsd +++ b/src/libs/ifc/schema/pattern/v0.2.7.xsd @@ -180,6 +180,10 @@ + + + + diff --git a/src/libs/ifc/xml/vdomdocument.cpp b/src/libs/ifc/xml/vdomdocument.cpp index 6963b7853..59215996b 100644 --- a/src/libs/ifc/xml/vdomdocument.cpp +++ b/src/libs/ifc/xml/vdomdocument.cpp @@ -145,28 +145,6 @@ QDomElement VDomDocument::elementById(quint32 id) return elementById(QString().setNum(id)); } -//--------------------------------------------------------------------------------------------------------------------- -/** - * @brief Removes all children of a given element tag. RENAME: removeAllChildren - * @param element tag - */ -void VDomDocument::removeAllChilds(QDomElement &element) -{ - QDomNode domNode = element.firstChild(); - while (domNode.isNull() == false) - { - if (domNode.isElement()) - { - QDomElement domElement = domNode.toElement(); - if (domElement.isNull() == false) - { - element.removeChild(domElement); - } - } - domNode = element.firstChild(); - } -} - //--------------------------------------------------------------------------------------------------------------------- /** * @brief Find element by id. @@ -740,10 +718,10 @@ bool VDomDocument::setTagText(const QString &tag, const QString &text) //--------------------------------------------------------------------------------------------------------------------- /** - * @brief RemoveAllChild remove all child from file. + * @brief RemoveAllChildren remove all children from file. * @param domElement tag in xml tree. */ -void VDomDocument::RemoveAllChild(QDomElement &domElement) +void VDomDocument::RemoveAllChildren(QDomElement &domElement) { if ( domElement.hasChildNodes() ) { diff --git a/src/libs/ifc/xml/vdomdocument.h b/src/libs/ifc/xml/vdomdocument.h index faa1d1f45..538bdabcd 100644 --- a/src/libs/ifc/xml/vdomdocument.h +++ b/src/libs/ifc/xml/vdomdocument.h @@ -80,7 +80,6 @@ public: virtual ~VDomDocument(); QDomElement elementById(const QString& id); QDomElement elementById(quint32 id); - void removeAllChilds(QDomElement &element); template void SetAttribute(QDomElement &domElement, const QString &name, const T &value) const; @@ -106,7 +105,7 @@ public: QString Major() const; QString Minor() const; QString Patch() const; - static void RemoveAllChild(QDomElement &domElement); + static void RemoveAllChildren(QDomElement &domElement); QDomNode ParentNodeById(const quint32 &nodeId); QDomElement CloneNodeById(const quint32 &nodeId); diff --git a/src/libs/vgeometry/vsplinepath.cpp b/src/libs/vgeometry/vsplinepath.cpp index bde1dc103..4ee10ca55 100644 --- a/src/libs/vgeometry/vsplinepath.cpp +++ b/src/libs/vgeometry/vsplinepath.cpp @@ -37,13 +37,73 @@ #endif //--------------------------------------------------------------------------------------------------------------------- -VSplinePath::VSplinePath(qreal kCurve, quint32 idObject, Draw mode) - : VAbstractCurve(GOType::SplinePath, idObject, mode), d(new VSplinePathData(kCurve)) +/** + * @brief VSplinePath constructor. + * @param idObject parent id. + * @param mode mode creation spline path. + */ +VSplinePath::VSplinePath(quint32 idObject, Draw mode) + : VAbstractCurve(GOType::SplinePath, idObject, mode), + d(new VSplinePathData()) {} //--------------------------------------------------------------------------------------------------------------------- +VSplinePath::VSplinePath(const QVector &points, qreal kCurve, quint32 idObject, Draw mode) + : VAbstractCurve(GOType::SplinePath, idObject, mode), + d(new VSplinePathData()) +{ + if (points.size() < 3) + { + return; + } + + QVector newPoints; + for (int i=0; i < points.size(); ++i) + { + newPoints.append(VSplinePoint()); + } + + for (qint32 i = 1; i <= points.size()-1; ++i) + { + const VFSplinePoint &p1 = points.at(i-1); + const VFSplinePoint &p2 = points.at(i); + VSpline spl(p1.P(), p2.P(), p1.Angle2(), p2.Angle1(), p1.KAsm2(), p2.KAsm1(), kCurve); + + newPoints[i-1].SetP(p1.P()); + newPoints[i-1].SetAngle2(p1.Angle2(), spl.GetStartAngleFormula()); + newPoints[i-1].SetLength2(spl.GetC1Length(), spl.GetC1LengthFormula()); + + newPoints[i].SetP(p2.P()); + newPoints[i].SetAngle2(p2.Angle1(), spl.GetEndAngleFormula()); + newPoints[i].SetLength1(spl.GetC2Length(), spl.GetC2LengthFormula()); + } + + d->path = newPoints; + CreateName(); +} + +//--------------------------------------------------------------------------------------------------------------------- +VSplinePath::VSplinePath(const QVector &points, quint32 idObject, Draw mode) + : VAbstractCurve(GOType::SplinePath, idObject, mode), + d(new VSplinePathData()) +{ + if (points.isEmpty()) + { + return; + } + + d->path = points; + CreateName(); +} + +//--------------------------------------------------------------------------------------------------------------------- +/** + * @brief VSplinePath copy constructor. + * @param splPath spline path. + */ VSplinePath::VSplinePath(const VSplinePath &splPath) - : VAbstractCurve(splPath), d(splPath.d) + : VAbstractCurve(splPath), + d(splPath.d) {} //--------------------------------------------------------------------------------------------------------------------- @@ -51,6 +111,10 @@ VSplinePath::~VSplinePath() {} //--------------------------------------------------------------------------------------------------------------------- +/** + * @brief append add point in the end of list points. + * @param point new point. + */ void VSplinePath::append(const VSplinePoint &point) { if (d->path.size() > 0 && d->path.last().P().toQPointF() == point.P().toQPointF()) //-V807 @@ -63,6 +127,10 @@ void VSplinePath::append(const VSplinePoint &point) } //--------------------------------------------------------------------------------------------------------------------- +/** + * @brief Count return count point. + * @return count. + */ qint32 VSplinePath::Count() const { if (d->path.size() == 0) @@ -76,6 +144,11 @@ qint32 VSplinePath::Count() const } //--------------------------------------------------------------------------------------------------------------------- +/** + * @brief GetSpline return spline by index. + * @param index index spline in spline path. + * @return spline + */ VSpline VSplinePath::GetSpline(qint32 index) const { if (Count()<1) @@ -88,11 +161,16 @@ VSpline VSplinePath::GetSpline(qint32 index) const } const VSplinePoint &p1 = d->path.at(index-1); const VSplinePoint &p2 = d->path.at(index); - VSpline spl(p1.P(), p2.P(), p1.Angle2(), p2.Angle1(), p1.KAsm2(), p2.KAsm1(), d->kCurve); + VSpline spl(p1.P(), p2.P(), p1.Angle2(), p1.Angle2Formula(), p2.Angle1(), p2.Angle1Formula(), p1.Length2(), + p1.Length2Formula(), p2.Length1(), p2.Length1Formula(), 1); return spl; } //--------------------------------------------------------------------------------------------------------------------- +/** + * @brief GetPath return QPainterPath which reprezent spline path. + * @return path. + */ QPainterPath VSplinePath::GetPath(PathDirection direction) const { QPainterPath painterPath; @@ -100,13 +178,18 @@ QPainterPath VSplinePath::GetPath(PathDirection direction) const { const VSplinePoint &p1 = d->path.at(i-1); const VSplinePoint &p2 = d->path.at(i); - VSpline spl(p1.P(), p2.P(), p1.Angle2(), p2.Angle1(), p1.KAsm2(), p2.KAsm1(), d->kCurve); + VSpline spl(p1.P(), p2.P(), p1.Angle2(), p1.Angle2Formula(), p2.Angle1(), p2.Angle1Formula(), p1.Length2(), + p1.Length2Formula(), p2.Length1(), p2.Length1Formula(), 1); painterPath.addPath(spl.GetPath(direction)); } return painterPath; } //--------------------------------------------------------------------------------------------------------------------- +/** + * @brief GetPathPoints return list of points what located on path. + * @return list. + */ QVector VSplinePath::GetPoints() const { QVector pathPoints; @@ -114,13 +197,18 @@ QVector VSplinePath::GetPoints() const { const VSplinePoint &p1 = d->path.at(i-1); const VSplinePoint &p2 = d->path.at(i); - VSpline spl(p1.P(), p2.P(), p1.Angle2(), p2.Angle1(), p1.KAsm2(), p2.KAsm1(), d->kCurve); + VSpline spl(p1.P(), p2.P(), p1.Angle2(), p1.Angle2Formula(), p2.Angle1(), p2.Angle1Formula(), p1.Length2(), + p1.Length2Formula(), p2.Length1(), p2.Length1Formula(), 1); pathPoints += spl.GetPoints(); } return pathPoints; } //--------------------------------------------------------------------------------------------------------------------- +/** + * @brief GetLength return length of spline path. + * @return length. + */ qreal VSplinePath::GetLength() const { qreal length = 0; @@ -128,14 +216,20 @@ qreal VSplinePath::GetLength() const { const VSplinePoint &p1 = d->path.at(i-1); const VSplinePoint &p2 = d->path.at(i); - VSpline spl(p1.P(), p2.P(), p1.Angle2(), p2.Angle1(), - p1.KAsm2(), p2.KAsm1(), d->kCurve); + VSpline spl(p1.P(), p2.P(), p1.Angle2(), p1.Angle2Formula(), p2.Angle1(), p2.Angle1Formula(), p1.Length2(), + p1.Length2Formula(), p2.Length1(), p2.Length1Formula(), 1); length += spl.GetLength(); } return length; } //--------------------------------------------------------------------------------------------------------------------- +/** + * @brief UpdatePoint update spline point in list. + * @param indexSpline spline index in list. + * @param pos position point in spline. + * @param point point. + */ void VSplinePath::UpdatePoint(qint32 indexSpline, const SplinePointPosition &pos, const VSplinePoint &point) { if (indexSpline < 1 || indexSpline > Count()) @@ -153,6 +247,12 @@ void VSplinePath::UpdatePoint(qint32 indexSpline, const SplinePointPosition &pos } //--------------------------------------------------------------------------------------------------------------------- +/** + * @brief GetSplinePoint return spline point from list. + * @param indexSpline spline index in list. + * @param pos position point in spline. + * @return spline point. + */ VSplinePoint VSplinePath::GetSplinePoint(qint32 indexSpline, SplinePointPosition pos) const { if (indexSpline < 1 || indexSpline > Count()) @@ -170,6 +270,11 @@ VSplinePoint VSplinePath::GetSplinePoint(qint32 indexSpline, SplinePointPosition } //--------------------------------------------------------------------------------------------------------------------- +/** + * @brief operator = assignment operator. + * @param path spline path. + * @return spline path. + */ VSplinePath &VSplinePath::operator =(const VSplinePath &path) { if ( &path == this ) @@ -182,18 +287,49 @@ VSplinePath &VSplinePath::operator =(const VSplinePath &path) } //--------------------------------------------------------------------------------------------------------------------- +/** + * @brief operator [] return spline point by index. + * @param indx index in list. + * @return spline point. + */ VSplinePoint & VSplinePath::operator[](int indx) { return d->path[indx]; } //--------------------------------------------------------------------------------------------------------------------- +/** + * @brief at return spline point by index. + * @param indx index in list. + * @return spline point. + */ const VSplinePoint &VSplinePath::at(int indx) const { return d->path[indx]; } //--------------------------------------------------------------------------------------------------------------------- +/** + * @brief CutSplinePath cut spline path into two. This method don't return two spline path. You must create spline + * paths by yourself. + * Example: + * QPointF spl1p2, spl1p3, spl2p2, spl2p3; + * qint32 p1 = 0, p2 = 0; + * QPointF point = splPath->CutSplinePath(length, p1, p2, spl1p2, spl1p3, spl2p2, spl2p3); + * + * VSplinePoint splP1 = splPath->at(p1); + * VSplinePoint splP2 = splPath->at(p2); + * VSpline spl1 = VSpline(splP1.P(), spl1p2, spl1p3, *p, splPath->GetKCurve()); + * VSpline spl2 = VSpline(*p, spl2p2, spl2p3, splP2.P(), splPath->GetKCurve()); + * @param length length first spline path. + * @param p1 index first spline point in list. + * @param p2 index second spline point in list. + * @param spl1p2 first control point first spline. + * @param spl1p3 second control point first spline. + * @param spl2p2 first control point second spline. + * @param spl2p3 second control point second spline. + * @return cutting point. + */ QPointF VSplinePath::CutSplinePath(qreal length, qint32 &p1, qint32 &p2, QPointF &spl1p2, QPointF &spl1p3, QPointF &spl2p2, QPointF &spl2p3) const { @@ -218,8 +354,9 @@ QPointF VSplinePath::CutSplinePath(qreal length, qint32 &p1, qint32 &p2, QPointF { const VSplinePoint &point1 = d->path.at(i-1); const VSplinePoint &point2 = d->path.at(i); - VSpline spl = VSpline(point1.P(), point2.P(), point1.Angle2(), point2.Angle1(), point1.KAsm2(), - point2.KAsm1(), d->kCurve); + VSpline spl = VSpline(point1.P(), point2.P(), point1.Angle2(), point1.Angle2Formula(), point2.Angle1(), + point2.Angle1Formula(), point1.Length2(), point1.Length2Formula(), point2.Length1(), + point2.Length1Formula(), 1); fullLength += spl.GetLength(); if (fullLength > length) { @@ -239,7 +376,8 @@ int VSplinePath::Segment(const QPointF &p) const { const VSplinePoint &p1 = d->path.at(i-1); const VSplinePoint &p2 = d->path.at(i); - VSpline spl = VSpline(p1.P(), p2.P(), p1.Angle2(), p2.Angle1(), p1.KAsm2(), p2.KAsm1(), d->kCurve); + VSpline spl = VSpline(p1.P(), p2.P(), p1.Angle2(), p1.Angle2Formula(), p2.Angle1(), p2.Angle1Formula(), + p1.Length2(), p1.Length2Formula(), p2.Length1(), p2.Length1Formula(), 1.0); const qreal t = spl.ParamT(p); @@ -304,41 +442,56 @@ void VSplinePath::CreateName() } //--------------------------------------------------------------------------------------------------------------------- +/** + * @brief CountPoint return count point. + * @return count. + */ qint32 VSplinePath::CountPoint() const { return d->path.size(); } //--------------------------------------------------------------------------------------------------------------------- +/** + * @brief GetSplinePath return list with spline points. + * @return list. + */ QVector VSplinePath::GetSplinePath() const { return d->path; } //--------------------------------------------------------------------------------------------------------------------- +QVector VSplinePath::GetFSplinePath() const +{ + QVector points; + points.reserve(d->path.size()); + + for (qint32 i = 1; i <= Count(); ++i) + { + const VSplinePoint &p1 = d->path.at(i-1); + const VSplinePoint &p2 = d->path.at(i); + VSpline spl(p1.P(), p2.P(), p1.Angle2(), p1.Angle2Formula(), p2.Angle1(), p2.Angle1Formula(), p1.Length2(), + p1.Length2Formula(), p2.Length1(), p2.Length1Formula(), 1); + + points[i-1].SetP(p1.P()); + points[i-1].SetAngle2(p1.Angle2()); + points[i-1].SetKAsm2(spl.GetKasm1()); + + points[i].SetP(p2.P()); + points[i].SetAngle1(p2.Angle1()); + points[i].SetKAsm1(spl.GetKasm2()); + } + + return points; +} + +//--------------------------------------------------------------------------------------------------------------------- +/** + * @brief Clear clear list of points. + */ void VSplinePath::Clear() { d->path.clear(); SetDuplicate(0); } - -//--------------------------------------------------------------------------------------------------------------------- -qreal VSplinePath::GetKCurve() const -{ - return d->kCurve; -} - -//--------------------------------------------------------------------------------------------------------------------- -void VSplinePath::SetKCurve(const qreal &value) -{ - if (value > 0) - { - d->kCurve = value; - } -} - -//--------------------------------------------------------------------------------------------------------------------- -const QVector *VSplinePath::GetPoint() const -{ - return &d->path; -} diff --git a/src/libs/vgeometry/vsplinepath.h b/src/libs/vgeometry/vsplinepath.h index 739f89623..d8d788367 100644 --- a/src/libs/vgeometry/vsplinepath.h +++ b/src/libs/vgeometry/vsplinepath.h @@ -45,139 +45,41 @@ class VSplinePath :public VAbstractCurve { Q_DECLARE_TR_FUNCTIONS(VSplinePath) public: - /** - * @brief VSplinePath constructor. - * @param kCurve coefficient of curvature spline path. - * @param idObject parent id. - * @param mode mode creation spline path. - */ - explicit VSplinePath(qreal kCurve = 1, quint32 idObject = 0, Draw mode = Draw::Calculation); - /** - * @brief VSplinePath copy constructor. - * @param splPath spline path. - */ + explicit VSplinePath(quint32 idObject = 0, Draw mode = Draw::Calculation); + VSplinePath(const QVector &points, qreal kCurve = 1, quint32 idObject = 0, + Draw mode = Draw::Calculation); + VSplinePath(const QVector &points, quint32 idObject = 0, Draw mode = Draw::Calculation); VSplinePath(const VSplinePath& splPath); virtual ~VSplinePath() Q_DECL_OVERRIDE; - /** - * @brief append add point in the end of list points. - * @param point new point. - */ - void append(const VSplinePoint &point); - /** - * @brief Count return count point. - * @return count. - */ - qint32 Count() const; - /** - * @brief CountPoint return count point. - * @return count. - */ - qint32 CountPoint() const; - /** - * @brief GetSpline return spline by index. - * @param index index spline in spline path. - * @return spline - */ - VSpline GetSpline(qint32 index) const; - /** - * @brief GetPath return QPainterPath which reprezent spline path. - * @return path. - */ - QPainterPath GetPath(PathDirection direction = PathDirection::Hide) const; - /** - * @brief GetPathPoints return list of points what located on path. - * @return list. - */ - QVector GetPoints() const; - /** - * @brief GetSplinePath return list with spline points. - * @return list. - */ - QVector GetSplinePath() const; - /** - * @brief GetLength return length of spline path. - * @return length. - */ - qreal GetLength() const; - /** - * @brief UpdatePoint update spline point in list. - * @param indexSpline spline index in list. - * @param pos position point in spline. - * @param point point. - */ - void UpdatePoint(qint32 indexSpline, const SplinePointPosition &pos, const VSplinePoint &point); - /** - * @brief GetSplinePoint return spline point from list. - * @param indexSpline spline index in list. - * @param pos position point in spline. - * @return spline point. - */ - VSplinePoint GetSplinePoint(qint32 indexSpline, SplinePointPosition pos) const; - /** - * @brief Clear clear list of points. - */ - void Clear(); - /** - * @brief GetKCurve return coefficient of curvature spline path. - * @return coefficient of curvature spline. - */ - qreal GetKCurve() const; - /** - * @brief SetKCurve set coefficient of curvature spline path. - * @param value coefficient of curvature spline path. - */ - void SetKCurve(const qreal &value); - /** - * @brief GetPoint pointer to list spline point. - * @return list. - */ - const QVector *GetPoint() const; - /** - * @brief operator = assignment operator. - * @param path spline path. - * @return spline path. - */ - VSplinePath &operator=(const VSplinePath &path); - /** - * @brief operator [] return spline point by index. - * @param indx index in list. - * @return spline point. - */ - VSplinePoint &operator[](int indx); - /** - * @brief at return spline point by index. - * @param indx index in list. - * @return spline point. - */ - const VSplinePoint &at(int indx) const; - /** - * @brief CutSplinePath cut spline path into two. This method don't return two spline path. You must create spline - * paths by yourself. - * Example: - * QPointF spl1p2, spl1p3, spl2p2, spl2p3; - * qint32 p1 = 0, p2 = 0; - * QPointF point = splPath->CutSplinePath(length, p1, p2, spl1p2, spl1p3, spl2p2, spl2p3); - * - * VSplinePoint splP1 = splPath->at(p1); - * VSplinePoint splP2 = splPath->at(p2); - * VSpline spl1 = VSpline(splP1.P(), spl1p2, spl1p3, *p, splPath->GetKCurve()); - * VSpline spl2 = VSpline(*p, spl2p2, spl2p3, splP2.P(), splPath->GetKCurve()); - * @param length length first spline path. - * @param p1 index first spline point in list. - * @param p2 index second spline point in list. - * @param spl1p2 first control point first spline. - * @param spl1p3 second control point first spline. - * @param spl2p2 first control point second spline. - * @param spl2p3 second control point second spline. - * @return cutting point. - */ - QPointF CutSplinePath(qreal length, qint32 &p1, qint32 &p2, QPointF &spl1p2, QPointF &spl1p3, QPointF &spl2p2, - QPointF &spl2p3) const; - int Segment(const QPointF &p) const; + VSplinePath &operator=(const VSplinePath &path); + VSplinePoint &operator[](int indx); + + void append(const VSplinePoint &point); + qint32 Count() const; + qint32 CountPoint() const; + void Clear(); + + VSpline GetSpline(qint32 index) const; + QPainterPath GetPath(PathDirection direction = PathDirection::Hide) const; + QVector GetPoints() const; + qreal GetLength() const; + + QVector GetSplinePath() const; + QVector GetFSplinePath() const; virtual qreal GetStartAngle () const Q_DECL_OVERRIDE; virtual qreal GetEndAngle () const Q_DECL_OVERRIDE; + + void UpdatePoint(qint32 indexSpline, const SplinePointPosition &pos, const VSplinePoint &point); + VSplinePoint GetSplinePoint(qint32 indexSpline, SplinePointPosition pos) const; + + const VSplinePoint &at(int indx) const; + + QPointF CutSplinePath(qreal length, qint32 &p1, qint32 &p2, QPointF &spl1p2, QPointF &spl1p3, QPointF &spl2p2, + QPointF &spl2p3) const; + + int Segment(const QPointF &p) const; protected: virtual void CreateName() Q_DECL_OVERRIDE; private: diff --git a/src/libs/vgeometry/vsplinepath_p.h b/src/libs/vgeometry/vsplinepath_p.h index 2c33ad8d4..817b4c87c 100644 --- a/src/libs/vgeometry/vsplinepath_p.h +++ b/src/libs/vgeometry/vsplinepath_p.h @@ -42,15 +42,12 @@ class VSplinePathData : public QSharedData public: VSplinePathData() - : path(QVector()), kCurve(1) - {} - - explicit VSplinePathData(qreal kCurve) - : path(QVector()), kCurve(kCurve) + : path(QVector()) {} VSplinePathData(const VSplinePathData &splPath) - : QSharedData(splPath), path(splPath.path), kCurve(splPath.kCurve) + : QSharedData(splPath), + path(splPath.path) {} virtual ~VSplinePathData(); @@ -59,10 +56,6 @@ public: * @brief path list spline point. */ QVector path; - /** - * @brief kCurve coefficient of curvature spline. - */ - qreal kCurve; private: VSplinePathData &operator=(const VSplinePathData &) Q_DECL_EQ_DELETE; diff --git a/src/libs/vgeometry/vsplinepoint.cpp b/src/libs/vgeometry/vsplinepoint.cpp index 3f89f2805..cce5b6e91 100644 --- a/src/libs/vgeometry/vsplinepoint.cpp +++ b/src/libs/vgeometry/vsplinepoint.cpp @@ -33,36 +33,36 @@ //--------------------------------------------------------------------------------------------------------------------- /** - * @brief VSplinePoint default constructor. + * @brief VFSplinePoint default constructor. */ -VSplinePoint::VSplinePoint() - :d(new VSplinePointData) +VFSplinePoint::VFSplinePoint() + :d(new VFSplinePointData) {} //--------------------------------------------------------------------------------------------------------------------- /** - * @brief VSplinePoint constructor. + * @brief VFSplinePoint constructor. * @param pSpline spline point. * @param kAsm1 coefficient of length first control line. * @param angle1 first angle control line. * @param kAsm2 coefficient of length second control line. * @param angle2 second angle control line. */ -VSplinePoint::VSplinePoint(VPointF pSpline, qreal kAsm1, qreal angle1, qreal kAsm2, qreal angle2) - :d(new VSplinePointData(pSpline, kAsm1, angle1, kAsm2, angle2)) +VFSplinePoint::VFSplinePoint(VPointF pSpline, qreal kAsm1, qreal angle1, qreal kAsm2, qreal angle2) + :d(new VFSplinePointData(pSpline, kAsm1, angle1, kAsm2, angle2)) {} //--------------------------------------------------------------------------------------------------------------------- /** - * @brief VSplinePoint copy constructor + * @brief VFSplinePoint copy constructor * @param point point */ -VSplinePoint::VSplinePoint(const VSplinePoint &point) +VFSplinePoint::VFSplinePoint(const VFSplinePoint &point) :d(point.d) {} //--------------------------------------------------------------------------------------------------------------------- -VSplinePoint &VSplinePoint::operator=(const VSplinePoint &point) +VFSplinePoint &VFSplinePoint::operator=(const VFSplinePoint &point) { if ( &point == this ) { @@ -73,7 +73,7 @@ VSplinePoint &VSplinePoint::operator=(const VSplinePoint &point) } //--------------------------------------------------------------------------------------------------------------------- -VSplinePoint::~VSplinePoint() +VFSplinePoint::~VFSplinePoint() {} //--------------------------------------------------------------------------------------------------------------------- @@ -81,7 +81,7 @@ VSplinePoint::~VSplinePoint() * @brief SetAngle1 set first angle of spline. * @param value angle. */ -void VSplinePoint::SetAngle1(const qreal &value) +void VFSplinePoint::SetAngle1(const qreal &value) { QLineF line(0, 0, 100, 0); line.setAngle(value); @@ -96,7 +96,7 @@ void VSplinePoint::SetAngle1(const qreal &value) * @brief SetAngle2 set second angle of spline. * @param value angle. */ -void VSplinePoint::SetAngle2(const qreal &value) +void VFSplinePoint::SetAngle2(const qreal &value) { QLineF line(0, 0, 100, 0); line.setAngle(value); @@ -111,7 +111,7 @@ void VSplinePoint::SetAngle2(const qreal &value) * @brief P return point. * @return point. */ -VPointF VSplinePoint::P() const +VPointF VFSplinePoint::P() const { return d->pSpline; } @@ -121,7 +121,7 @@ VPointF VSplinePoint::P() const * @brief SetP set point. * @param value point. */ -void VSplinePoint::SetP(const VPointF &value) +void VFSplinePoint::SetP(const VPointF &value) { d->pSpline = value; } @@ -131,7 +131,7 @@ void VSplinePoint::SetP(const VPointF &value) * @brief Angle1 return first angle of spline. * @return angle. */ -qreal VSplinePoint::Angle1() const +qreal VFSplinePoint::Angle1() const { return d->angle1; } @@ -141,7 +141,7 @@ qreal VSplinePoint::Angle1() const * @brief Angle2 return second angle of spline. * @return angle. */ -qreal VSplinePoint::Angle2() const +qreal VFSplinePoint::Angle2() const { return d->angle2; } @@ -151,7 +151,7 @@ qreal VSplinePoint::Angle2() const * @brief KAsm1 return coefficient of length first control line. * @return coefficient. */ -qreal VSplinePoint::KAsm1() const +qreal VFSplinePoint::KAsm1() const { return d->kAsm1; } @@ -161,7 +161,7 @@ qreal VSplinePoint::KAsm1() const * @brief SetKAsm1 set coefficient of length first control line. * @param value coefficient. */ -void VSplinePoint::SetKAsm1(const qreal &value) +void VFSplinePoint::SetKAsm1(const qreal &value) { d->kAsm1 = value; } @@ -171,7 +171,7 @@ void VSplinePoint::SetKAsm1(const qreal &value) * @brief KAsm2 return coefficient of length second control line. * @return coefficient. */ -qreal VSplinePoint::KAsm2() const +qreal VFSplinePoint::KAsm2() const { return d->kAsm2; } @@ -181,7 +181,144 @@ qreal VSplinePoint::KAsm2() const * @brief SetKAsm2 set coefficient of length second control line. * @param value coefficient. */ -void VSplinePoint::SetKAsm2(const qreal &value) +void VFSplinePoint::SetKAsm2(const qreal &value) { d->kAsm2 = value; } + +//------------------------------------------VSplinePoint--------------------------------------------------------------- +VSplinePoint::VSplinePoint() + : d(new VSplinePointData) +{ +} + +//--------------------------------------------------------------------------------------------------------------------- +VSplinePoint::VSplinePoint(VPointF pSpline, qreal angle1, const QString &angle1F, qreal angle2, const QString &angle2F, + qreal length1, const QString &length1F, qreal length2, const QString &length2F) + : d(new VSplinePointData(pSpline, angle1, angle1F, angle2, angle2F, length1, length1F, length2, length2F)) +{ +} + +//--------------------------------------------------------------------------------------------------------------------- +VSplinePoint::VSplinePoint(const VSplinePoint &point) + : d(point.d) +{ +} + +//--------------------------------------------------------------------------------------------------------------------- +VSplinePoint &VSplinePoint::operator=(const VSplinePoint &point) +{ + if ( &point == this ) + { + return *this; + } + d = point.d; + return *this; +} + +//--------------------------------------------------------------------------------------------------------------------- +VSplinePoint::~VSplinePoint() +{ +} + +//--------------------------------------------------------------------------------------------------------------------- +VPointF VSplinePoint::P() const +{ + return d->pSpline; +} + +//--------------------------------------------------------------------------------------------------------------------- +void VSplinePoint::SetP(const VPointF &value) +{ + d->pSpline = value; +} + +//--------------------------------------------------------------------------------------------------------------------- +qreal VSplinePoint::Angle1() const +{ + return d->angle1; +} + +//--------------------------------------------------------------------------------------------------------------------- +QString VSplinePoint::Angle1Formula() const +{ + return d->angle1F; +} + +//--------------------------------------------------------------------------------------------------------------------- +void VSplinePoint::SetAngle1(const qreal &value, const QString &angle1F) +{ + d->angle1F = angle1F; + + QLineF line(0, 0, 100, 0); + line.setAngle(value); + d->angle1 = line.angle(); + + line.setAngle(d->angle1+180); + d->angle2 = line.angle(); + d->angle2F = QString().number(d->angle2); +} + +//--------------------------------------------------------------------------------------------------------------------- +qreal VSplinePoint::Angle2() const +{ + return d->angle2; +} + +//--------------------------------------------------------------------------------------------------------------------- +QString VSplinePoint::Angle2Formula() const +{ + return d->angle2F; +} + +//--------------------------------------------------------------------------------------------------------------------- +void VSplinePoint::SetAngle2(const qreal &value, const QString &angle2F) +{ + d->angle2F = angle2F; + + QLineF line(0, 0, 100, 0); + line.setAngle(value); + d->angle2 = line.angle(); + + line.setAngle(d->angle2+180); + d->angle1 = line.angle(); + d->angle1F = QString().number(d->angle1); +} + +//--------------------------------------------------------------------------------------------------------------------- +qreal VSplinePoint::Length1() const +{ + return d->length1; +} + +//--------------------------------------------------------------------------------------------------------------------- +QString VSplinePoint::Length1Formula() const +{ + return d->length1F; +} + +//--------------------------------------------------------------------------------------------------------------------- +void VSplinePoint::SetLength1(const qreal &value, const QString &length1F) +{ + d->length1 = value; + d->length1F = length1F; +} + +//--------------------------------------------------------------------------------------------------------------------- +qreal VSplinePoint::Length2() const +{ + return d->length2; +} + +//--------------------------------------------------------------------------------------------------------------------- +QString VSplinePoint::Length2Formula() const +{ + return d->length2F; +} + +//--------------------------------------------------------------------------------------------------------------------- +void VSplinePoint::SetLength2(const qreal &value, const QString &length2F) +{ + d->length2 = value; + d->length2F = length2F; +} diff --git a/src/libs/vgeometry/vsplinepoint.h b/src/libs/vgeometry/vsplinepoint.h index c455978bf..75620f6ec 100644 --- a/src/libs/vgeometry/vsplinepoint.h +++ b/src/libs/vgeometry/vsplinepoint.h @@ -32,20 +32,20 @@ #include "vpointf.h" #include -class VSplinePointData; +class VFSplinePointData; /** - * @brief The VSplinePoint class keep information about point in spline path. Each point have two angles and two - * coefficient. Point represent at the same time first and last point of spline. + * @brief The VFSplinePoint class keep information about point in spline path. Each point have two angles and two + * coefficient. Point represent at the same time first and last point of a spline. */ -class VSplinePoint +class VFSplinePoint { public: - VSplinePoint(); - VSplinePoint(VPointF pSpline, qreal kAsm1, qreal angle1, qreal kAsm2, qreal angle2); - VSplinePoint(const VSplinePoint &point); - VSplinePoint &operator=(const VSplinePoint &point); - ~VSplinePoint(); + VFSplinePoint(); + VFSplinePoint(VPointF pSpline, qreal kAsm1, qreal angle1, qreal kAsm2, qreal angle2); + VFSplinePoint(const VFSplinePoint &point); + VFSplinePoint &operator=(const VFSplinePoint &point); + ~VFSplinePoint(); VPointF P() const; void SetP(const VPointF &value); @@ -57,6 +57,47 @@ public: void SetKAsm1(const qreal &value); qreal KAsm2() const; void SetKAsm2(const qreal &value); +protected: + QSharedDataPointer d; +}; + +Q_DECLARE_METATYPE(VFSplinePoint) +Q_DECLARE_TYPEINFO(VFSplinePoint, Q_MOVABLE_TYPE); + +class VSplinePointData; + +/** + * @brief The VSplinePoint class keep information about point in spline path. Each point have two angles and two + * lengths. Point represent at the same time first and last point of a spline. + */ +class VSplinePoint +{ +public: + VSplinePoint(); + VSplinePoint(VPointF pSpline, qreal angle1, const QString &angle1F, qreal angle2, const QString &angle2F, + qreal length1, const QString &length1F, qreal length2, const QString &length2F); + VSplinePoint(const VSplinePoint &point); + VSplinePoint &operator=(const VSplinePoint &point); + ~VSplinePoint(); + + VPointF P() const; + void SetP(const VPointF &value); + + qreal Angle1() const; + QString Angle1Formula() const; + void SetAngle1(const qreal &value, const QString &angle1F); + + qreal Angle2() const; + QString Angle2Formula() const; + void SetAngle2(const qreal &value, const QString &angle2F); + + qreal Length1() const; + QString Length1Formula() const; + void SetLength1(const qreal &value, const QString &length1F); + + qreal Length2() const; + QString Length2Formula() const; + void SetLength2(const qreal &value, const QString &length2F); protected: QSharedDataPointer d; }; diff --git a/src/libs/vgeometry/vsplinepoint_p.h b/src/libs/vgeometry/vsplinepoint_p.h index 83a64e15c..596296733 100644 --- a/src/libs/vgeometry/vsplinepoint_p.h +++ b/src/libs/vgeometry/vsplinepoint_p.h @@ -38,18 +38,26 @@ #pragma GCC diagnostic ignored "-Weffc++" #endif -class VSplinePointData : public QSharedData +class VFSplinePointData : public QSharedData { public: - VSplinePointData() - :pSpline(VPointF()), angle1(0), angle2(180), kAsm1(1), kAsm2(1) + VFSplinePointData() + : pSpline(VPointF()), + angle1(0), + angle2(180), + kAsm1(1), + kAsm2(1) {} - VSplinePointData(VPointF pSpline, qreal kAsm1, qreal angle1, qreal kAsm2, qreal angle2) - :pSpline(pSpline), angle1(angle1), angle2(angle2), kAsm1(kAsm1), kAsm2(kAsm2) + VFSplinePointData(VPointF pSpline, qreal kAsm1, qreal angle1, qreal kAsm2, qreal angle2) + : pSpline(pSpline), + angle1(angle1), + angle2(angle2), + kAsm1(kAsm1), + kAsm2(kAsm2) { - if (qFuzzyCompare(qAbs(angle1-angle2), 180) == false) + if (not qFuzzyCompare(qAbs(angle1-angle2), 180) || qFuzzyIsNull(qAbs(angle1-angle2))) { qWarning()<<"angle1 and angle2 are not equal."; this->angle1 = angle1; @@ -57,27 +65,109 @@ public: } } - VSplinePointData(const VSplinePointData &point) - :QSharedData(point), pSpline(point.pSpline), angle1(point.angle1), angle2(point.angle2), kAsm1(point.kAsm1), + VFSplinePointData(const VFSplinePointData &point) + : QSharedData(point), + pSpline(point.pSpline), + angle1(point.angle1), + angle2(point.angle2), + kAsm1(point.kAsm1), kAsm2(point.kAsm2) {} + virtual ~VFSplinePointData(); + + /** @brief pSpline point. */ + VPointF pSpline; + + /** @brief angle1 first angle spline. */ + qreal angle1; + + /** @brief angle2 second angle spline. */ + qreal angle2; + + /** @brief kAsm1 coefficient of length first control line. */ + qreal kAsm1; + + /** @brief kAsm2 coefficient of length second control line. */ + qreal kAsm2; + +private: + VFSplinePointData &operator=(const VFSplinePointData &) Q_DECL_EQ_DELETE; +}; + +VFSplinePointData::~VFSplinePointData() +{} + +//--------------------------------------VSplinePointData--------------------------------------------------------------- + +class VSplinePointData : public QSharedData +{ +public: + VSplinePointData() + : pSpline(), + angle1(0), + angle1F("0"), + angle2(180), + angle2F("180"), + length1(0), + length1F("0"), + length2(0), + length2F("0") + {} + + VSplinePointData(VPointF pSpline, qreal angle1, const QString &angle1F, qreal angle2, const QString &angle2F, + qreal length1, const QString &length1F, qreal length2, const QString &length2F) + : pSpline(pSpline), + angle1(angle1), + angle1F(angle1F), + angle2(angle2), + angle2F(angle2F), + length1(length1), + length1F(length1F), + length2(length2), + length2F(length2F) + { + if (not qFuzzyCompare(qAbs(angle1-angle2), 180) || qFuzzyIsNull(qAbs(angle1-angle2))) + { + qWarning()<<"angle1 and angle2 are not equal."; + this->angle2 = angle1 + 180; + this->angle2F = QString().number(angle2); + } + } + + VSplinePointData(const VSplinePointData &point) + : QSharedData(point), + pSpline(point.pSpline), + angle1(point.angle1), + angle1F(point.angle1F), + angle2(point.angle2), + angle2F(point.angle2F), + length1(point.length1), + length1F(point.length1F), + length2(point.length2), + length2F(point.length2F) + {} + virtual ~VSplinePointData(); /** @brief pSpline point. */ - VPointF pSpline; + VPointF pSpline; /** @brief angle1 first angle spline. */ - qreal angle1; + qreal angle1; + QString angle1F; /** @brief angle2 second angle spline. */ - qreal angle2; + qreal angle2; + QString angle2F; - /** @brief kAsm1 coefficient of length first control line. */ - qreal kAsm1; + /** @brief length1 length a first control line. */ + qreal length1; + QString length1F; - /** @brief kAsm2 coefficient of length second control line. */ - qreal kAsm2; + /** @brief length2 length a second control line. */ + qreal length2; + QString length2F; private: VSplinePointData &operator=(const VSplinePointData &) Q_DECL_EQ_DELETE; diff --git a/src/libs/vtools/dialogs/tools/dialogsplinepath.cpp b/src/libs/vtools/dialogs/tools/dialogsplinepath.cpp index 26f87d18a..b96271ff7 100644 --- a/src/libs/vtools/dialogs/tools/dialogsplinepath.cpp +++ b/src/libs/vtools/dialogs/tools/dialogsplinepath.cpp @@ -31,6 +31,9 @@ #include "../vgeometry/vsplinepoint.h" #include "../vpatterndb/vcontainer.h" #include "../../visualization/vistoolsplinepath.h" +#include "../support/dialogeditwrongformula.h" + +#include //--------------------------------------------------------------------------------------------------------------------- /** @@ -39,9 +42,42 @@ * @param parent parent widget */ DialogSplinePath::DialogSplinePath(const VContainer *data, const quint32 &toolId, QWidget *parent) - :DialogTool(data, toolId, parent), ui(new Ui::DialogSplinePath), path(VSplinePath()), newDuplicate(-1) + : DialogTool(data, toolId, parent), + ui(new Ui::DialogSplinePath), + path(), + newDuplicate(-1), + formulaBaseHeightAngle1(0), + formulaBaseHeightAngle2(0), + formulaBaseHeightLength1(0), + formulaBaseHeightLength2(0), + timerAngle1(new QTimer(this)), + timerAngle2(new QTimer(this)), + timerLength1(new QTimer(this)), + timerLength2(new QTimer(this)), + flagAngle1(), + flagAngle2(), + flagLength1(), + flagLength2() { ui->setupUi(this); + + plainTextEditFormula = ui->plainTextEditAngle1F; + + formulaBaseHeightAngle1 = ui->plainTextEditAngle1F->height(); + formulaBaseHeightAngle2 = ui->plainTextEditAngle2F->height(); + formulaBaseHeightLength1 = ui->plainTextEditLength1F->height(); + formulaBaseHeightLength2 = ui->plainTextEditLength2F->height(); + + ui->plainTextEditAngle1F->installEventFilter(this); + ui->plainTextEditAngle2F->installEventFilter(this); + ui->plainTextEditLength1F->installEventFilter(this); + ui->plainTextEditLength2F->installEventFilter(this); + + connect(timerAngle1, &QTimer::timeout, this, &DialogSplinePath::EvalAngle1); + connect(timerAngle2, &QTimer::timeout, this, &DialogSplinePath::EvalAngle2); + connect(timerLength1, &QTimer::timeout, this, &DialogSplinePath::EvalLength1); + connect(timerLength2, &QTimer::timeout, this, &DialogSplinePath::EvalLength2); + InitOkCancelApply(ui); bOk->setEnabled(false); @@ -51,14 +87,21 @@ DialogSplinePath::DialogSplinePath(const VContainer *data, const quint32 &toolId connect(ui->listWidget, &QListWidget::currentRowChanged, this, &DialogSplinePath::PointChanged); connect(ui->comboBoxPoint, static_cast(&QComboBox::currentIndexChanged), this, &DialogSplinePath::currentPointChanged); - connect(ui->doubleSpinBoxAngle1, static_cast(&QDoubleSpinBox::valueChanged), - this, &DialogSplinePath::Angle1Changed); - connect(ui->doubleSpinBoxAngle2, static_cast(&QDoubleSpinBox::valueChanged), - this, &DialogSplinePath::Angle2Changed); - connect(ui->doubleSpinBoxKasm1, static_cast(&QDoubleSpinBox::valueChanged), - this, &DialogSplinePath::KAsm1Changed); - connect(ui->doubleSpinBoxKasm2, static_cast(&QDoubleSpinBox::valueChanged), - this, &DialogSplinePath::KAsm2Changed); + + connect(ui->toolButtonExprAngle1, &QPushButton::clicked, this, &DialogSplinePath::FXAngle1); + connect(ui->toolButtonExprAngle2, &QPushButton::clicked, this, &DialogSplinePath::FXAngle2); + connect(ui->toolButtonExprLength1, &QPushButton::clicked, this, &DialogSplinePath::FXLength1); + connect(ui->toolButtonExprLength2, &QPushButton::clicked, this, &DialogSplinePath::FXLength2); + + connect(ui->plainTextEditAngle1F, &QPlainTextEdit::textChanged, this, &DialogSplinePath::Angle1Changed); + connect(ui->plainTextEditAngle2F, &QPlainTextEdit::textChanged, this, &DialogSplinePath::Angle2Changed); + connect(ui->plainTextEditLength1F, &QPlainTextEdit::textChanged, this, &DialogSplinePath::Length1Changed); + connect(ui->plainTextEditLength2F, &QPlainTextEdit::textChanged, this, &DialogSplinePath::Length2Changed); + + connect(ui->pushButtonGrowAngle1, &QPushButton::clicked, this, &DialogSplinePath::DeployAngle1TextEdit); + connect(ui->pushButtonGrowAngle2, &QPushButton::clicked, this, &DialogSplinePath::DeployAngle2TextEdit); + connect(ui->pushButtonGrowLength1, &QPushButton::clicked, this, &DialogSplinePath::DeployLength1TextEdit); + connect(ui->pushButtonGrowLength2, &QPushButton::clicked, this, &DialogSplinePath::DeployLength2TextEdit); vis = new VisToolSplinePath(data); auto path = qobject_cast(vis); @@ -84,16 +127,19 @@ DialogSplinePath::~DialogSplinePath() */ void DialogSplinePath::SetPath(const VSplinePath &value) { + flagAngle1.clear(); + flagAngle2.clear(); + flagLength1.clear(); + flagLength2.clear(); + this->path = value; ui->listWidget->blockSignals(true); ui->listWidget->clear(); for (qint32 i = 0; i < path.CountPoint(); ++i) { - const VSplinePoint &point = path.at(i); - NewItem(point.P().id(), point.KAsm1(), point.Angle1(), point.KAsm2(), point.Angle2()); + NewItem(path.at(i)); } ui->listWidget->setFocus(Qt::OtherFocusReason); - ui->doubleSpinBoxKcurve->setValue(path.GetKCurve()); ui->lineEditSplPathName->setText(path.name()); auto visPath = qobject_cast(vis); @@ -129,7 +175,10 @@ void DialogSplinePath::ChosenObject(quint32 id, const SceneObject &type) return; } - NewItem(id, 1, 0, 1, 180); + const auto point = data->GeometricObject(id); + VSplinePoint p; + p.SetP(*point); + NewItem(p); emit ToolTip(tr("Select point of curve path")); SavePath(); @@ -152,6 +201,9 @@ void DialogSplinePath::ChosenObject(quint32 id, const SceneObject &type) } //--------------------------------------------------------------------------------------------------------------------- +/** + * @brief SaveData Put dialog data in local variables + */ void DialogSplinePath::SaveData() { const quint32 d = path.GetDuplicate();//Save previous value @@ -165,6 +217,369 @@ void DialogSplinePath::SaveData() visPath->RefreshGeometry(); } +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::CheckState() +{ + SCASSERT(bOk != nullptr); + + bool fAngle1 = false, fAngle2 = false, fLength1 = false, fLength2 = false; + + for (qint32 i = 0; i < ui->listWidget->count(); ++i) + { + fAngle1 = fAngle1 && flagAngle1.at(i); + fAngle2 = fAngle2 && flagAngle2.at(i); + fLength1 = fLength1 && flagLength1.at(i); + fLength2 = fLength2 && flagLength2.at(i); + } + + bOk->setEnabled(fAngle1 && fAngle2 && fLength1 && fLength2 && flagError); + // In case dialog hasn't apply button + if (bApply != nullptr) + { + bApply->setEnabled(bOk->isEnabled()); + } +} + +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::closeEvent(QCloseEvent *event) +{ + ui->plainTextEditAngle1F->blockSignals(true); + ui->plainTextEditAngle2F->blockSignals(true); + ui->plainTextEditLength1F->blockSignals(true); + ui->plainTextEditLength2F->blockSignals(true); + DialogTool::closeEvent(event); +} + +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::DeployAngle1TextEdit() +{ + DeployFormula(ui->plainTextEditAngle1F, ui->pushButtonGrowAngle1, formulaBaseHeightAngle1); +} + +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::DeployAngle2TextEdit() +{ + DeployFormula(ui->plainTextEditAngle2F, ui->pushButtonGrowAngle2, formulaBaseHeightAngle2); +} + +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::DeployLength1TextEdit() +{ + DeployFormula(ui->plainTextEditLength1F, ui->pushButtonGrowLength1, formulaBaseHeightLength1); +} + +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::DeployLength2TextEdit() +{ + DeployFormula(ui->plainTextEditLength2F, ui->pushButtonGrowLength2, formulaBaseHeightLength2); +} + +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::Angle1Changed() +{ + const int row = ui->listWidget->currentRow(); + if (row == -1) + { + return; + } + + labelEditFormula = ui->labelEditAngle1; + labelResultCalculation = ui->labelResultAngle1; + ValFormulaChanged(flagAngle1[row], ui->plainTextEditAngle1F, timerAngle1); + + QListWidgetItem *item = ui->listWidget->item(row); + SCASSERT(item != nullptr); + VSplinePoint p = qvariant_cast(item->data(Qt::UserRole)); + + const QString angle1F = ui->plainTextEditAngle1F->toPlainText().replace("\n", " "); + const qreal angle1 = Visualization::FindVal(angle1F, data->PlainVariables()); + p.SetAngle1(angle1, qApp->TrVars()->FormulaFromUser(angle1F, qApp->Settings()->GetOsSeparator())); + + item->setData(Qt::UserRole, QVariant::fromValue(p)); + + ShowPointIssue(p.P().name()); + + ui->plainTextEditAngle2F->blockSignals(true); + ui->plainTextEditAngle2F->setPlainText(qApp->TrVars()->FormulaToUser(p.Angle2Formula())); + EvalAngle2(); + ui->plainTextEditAngle2F->blockSignals(false); +} + +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::Angle2Changed() +{ + const int row = ui->listWidget->currentRow(); + if (row == -1) + { + return; + } + + labelEditFormula = ui->labelEditAngle2; + labelResultCalculation = ui->labelResultAngle2; + ValFormulaChanged(flagAngle2[row], ui->plainTextEditAngle2F, timerAngle2); + + QListWidgetItem *item = ui->listWidget->item(row); + SCASSERT(item != nullptr); + VSplinePoint p = qvariant_cast(item->data(Qt::UserRole)); + + const QString angle2F = ui->plainTextEditAngle2F->toPlainText().replace("\n", " "); + const qreal angle2 = Visualization::FindVal(angle2F, data->PlainVariables()); + p.SetAngle2(angle2, qApp->TrVars()->FormulaFromUser(angle2F, qApp->Settings()->GetOsSeparator())); + + item->setData(Qt::UserRole, QVariant::fromValue(p)); + + ShowPointIssue(p.P().name()); + + ui->plainTextEditAngle1F->blockSignals(true); + ui->plainTextEditAngle1F->setPlainText(qApp->TrVars()->FormulaToUser(p.Angle1Formula())); + EvalAngle1(); + ui->plainTextEditAngle1F->blockSignals(false); +} + +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::Length1Changed() +{ + const int row = ui->listWidget->currentRow(); + if (row == -1) + { + return; + } + + labelEditFormula = ui->labelEditLength1; + labelResultCalculation = ui->labelResultLength1; + ValFormulaChanged(flagLength1[row], ui->plainTextEditLength1F, timerLength1); + + QListWidgetItem *item = ui->listWidget->item(row); + SCASSERT(item != nullptr); + VSplinePoint p = qvariant_cast(item->data(Qt::UserRole)); + + const QString length1F = ui->plainTextEditLength1F->toPlainText().replace("\n", " "); + const qreal length1 = Visualization::FindLength(length1F, data->PlainVariables()); + p.SetLength1(length1, qApp->TrVars()->FormulaFromUser(length1F, qApp->Settings()->GetOsSeparator())); + + item->setData(Qt::UserRole, QVariant::fromValue(p)); + + ShowPointIssue(p.P().name()); +} + +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::Length2Changed() +{ + const int row = ui->listWidget->currentRow(); + if (row == -1) + { + return; + } + + labelEditFormula = ui->labelEditLength2; + labelResultCalculation = ui->labelResultLength2; + ValFormulaChanged(flagLength2[row], ui->plainTextEditLength2F, timerLength2); + + QListWidgetItem *item = ui->listWidget->item(row); + SCASSERT(item != nullptr); + VSplinePoint p = qvariant_cast(item->data(Qt::UserRole)); + + const QString length2F = ui->plainTextEditLength2F->toPlainText().replace("\n", " "); + const qreal length2 = Visualization::FindLength(length2F, data->PlainVariables()); + p.SetLength2(length2, qApp->TrVars()->FormulaFromUser(length2F, qApp->Settings()->GetOsSeparator())); + + item->setData(Qt::UserRole, QVariant::fromValue(p)); + + ShowPointIssue(p.P().name()); +} + +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::FXAngle1() +{ + auto dialog = new DialogEditWrongFormula(data, toolId, this); + dialog->setWindowTitle(tr("Edit first control point angle")); + QString angle1F = qApp->TrVars()->FormulaFromUser(ui->plainTextEditAngle1F->toPlainText(), + qApp->Settings()->GetOsSeparator()); + dialog->SetFormula(angle1F); + dialog->setPostfix(VDomDocument::UnitsToStr(qApp->patternUnit(), true)); + if (dialog->exec() == QDialog::Accepted) + { + angle1F = qApp->TrVars()->FormulaToUser(dialog->GetFormula()); + // increase height if needed. + if (angle1F.length() > 80) + { + DeployAngle1TextEdit(); + } + ui->plainTextEditAngle1F->setPlainText(angle1F); + MoveCursorToEnd(ui->plainTextEditAngle1F); + } + delete dialog; +} + +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::FXAngle2() +{ + auto dialog = new DialogEditWrongFormula(data, toolId, this); + dialog->setWindowTitle(tr("Edit second control point angle")); + QString angle2F = qApp->TrVars()->FormulaFromUser(ui->plainTextEditAngle2F->toPlainText(), + qApp->Settings()->GetOsSeparator()); + dialog->SetFormula(angle2F); + dialog->setPostfix(VDomDocument::UnitsToStr(qApp->patternUnit(), true)); + if (dialog->exec() == QDialog::Accepted) + { + angle2F = qApp->TrVars()->FormulaToUser(dialog->GetFormula()); + // increase height if needed. + if (angle2F.length() > 80) + { + DeployAngle1TextEdit(); + } + ui->plainTextEditAngle2F->setPlainText(angle2F); + MoveCursorToEnd(ui->plainTextEditAngle2F); + } + delete dialog; +} + +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::FXLength1() +{ + auto dialog = new DialogEditWrongFormula(data, toolId, this); + dialog->setWindowTitle(tr("Edit first control point length")); + QString length1F = qApp->TrVars()->FormulaFromUser(ui->plainTextEditLength1F->toPlainText(), + qApp->Settings()->GetOsSeparator()); + dialog->SetFormula(length1F); + dialog->setPostfix(VDomDocument::UnitsToStr(qApp->patternUnit(), true)); + if (dialog->exec() == QDialog::Accepted) + { + length1F = qApp->TrVars()->FormulaToUser(dialog->GetFormula()); + // increase height if needed. + if (length1F.length() > 80) + { + DeployLength1TextEdit(); + } + ui->plainTextEditLength1F->setPlainText(length1F); + MoveCursorToEnd(ui->plainTextEditLength1F); + } + delete dialog; +} + +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::FXLength2() +{ + auto dialog = new DialogEditWrongFormula(data, toolId, this); + dialog->setWindowTitle(tr("Edit second control point length")); + QString length2F = qApp->TrVars()->FormulaFromUser(ui->plainTextEditLength2F->toPlainText(), + qApp->Settings()->GetOsSeparator()); + dialog->SetFormula(length2F); + dialog->setPostfix(VDomDocument::UnitsToStr(qApp->patternUnit(), true)); + if (dialog->exec() == QDialog::Accepted) + { + length2F = qApp->TrVars()->FormulaToUser(dialog->GetFormula()); + // increase height if needed. + if (length2F.length() > 80) + { + DeployLength2TextEdit(); + } + ui->plainTextEditLength2F->setPlainText(length2F); + MoveCursorToEnd(ui->plainTextEditLength2F); + } + delete dialog; +} + +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::EvalAngle1() +{ + const int row = ui->listWidget->currentRow(); + if (row == -1) + { + return; + } + + labelEditFormula = ui->labelEditAngle1; + Eval(ui->plainTextEditAngle1F->toPlainText(), flagAngle1[row], ui->labelResultAngle1, degreeSymbol, false); + + QListWidgetItem *item = ui->listWidget->item(row); + SCASSERT(item != nullptr); + VSplinePoint p = qvariant_cast(item->data(Qt::UserRole)); + + ShowPointIssue(p.P().name()); +} + +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::EvalAngle2() +{ + const int row = ui->listWidget->currentRow(); + if (row == -1) + { + return; + } + + labelEditFormula = ui->labelEditAngle2; + Eval(ui->plainTextEditAngle2F->toPlainText(), flagAngle2[row], ui->labelResultAngle2, degreeSymbol, false); + + QListWidgetItem *item = ui->listWidget->item(row); + SCASSERT(item != nullptr); + VSplinePoint p = qvariant_cast(item->data(Qt::UserRole)); + + ShowPointIssue(p.P().name()); +} + +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::EvalLength1() +{ + const int row = ui->listWidget->currentRow(); + if (row == -1) + { + return; + } + + labelEditFormula = ui->labelEditLength1; + const QString postfix = VDomDocument::UnitsToStr(qApp->patternUnit(), true); + const qreal length1 = Eval(ui->plainTextEditLength1F->toPlainText(), flagLength1[row], ui->labelResultLength1, + postfix); + + if (length1 < 0) + { + flagLength1[row] = false; + ChangeColor(labelEditFormula, Qt::red); + ui->labelResultLength1->setText(tr("Error") + " (" + postfix + ")"); + ui->labelResultLength1->setToolTip(tr("Length can't be negative")); + + CheckState(); + } + + QListWidgetItem *item = ui->listWidget->item(row); + SCASSERT(item != nullptr); + VSplinePoint p = qvariant_cast(item->data(Qt::UserRole)); + + ShowPointIssue(p.P().name()); +} + +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::EvalLength2() +{ + const int row = ui->listWidget->currentRow(); + if (row == -1) + { + return; + } + + labelEditFormula = ui->labelEditLength2; + const QString postfix = VDomDocument::UnitsToStr(qApp->patternUnit(), true); + const qreal length2 = Eval(ui->plainTextEditLength2F->toPlainText(), flagLength2[row], ui->labelResultLength2, + postfix); + + if (length2 < 0) + { + flagLength2[row] = false; + ChangeColor(labelEditFormula, Qt::red); + ui->labelResultLength2->setText(tr("Error") + " (" + postfix + ")"); + ui->labelResultLength2->setToolTip(tr("Length can't be negative")); + + CheckState(); + } + + QListWidgetItem *item = ui->listWidget->item(row); + SCASSERT(item != nullptr); + VSplinePoint p = qvariant_cast(item->data(Qt::UserRole)); + + ShowPointIssue(p.P().name()); +} + //--------------------------------------------------------------------------------------------------------------------- /** * @brief PointChanged selected another point in list @@ -176,9 +591,7 @@ void DialogSplinePath::PointChanged(int row) { return; } - QListWidgetItem *item = ui->listWidget->item( row ); - VSplinePoint p = qvariant_cast(item->data(Qt::UserRole)); - DataPoint(p.P().id(), p.KAsm1(), p.Angle1(), p.KAsm2(), p.Angle2()); + DataPoint(qvariant_cast(ui->listWidget->item(row)->data(Qt::UserRole))); EnableFields(); } @@ -189,16 +602,15 @@ void DialogSplinePath::PointChanged(int row) */ void DialogSplinePath::currentPointChanged(int index) { - quint32 id = qvariant_cast(ui->comboBoxPoint->itemData(index)); - qint32 row = ui->listWidget->currentRow(); - QListWidgetItem *item = ui->listWidget->item( row ); + const quint32 id = qvariant_cast(ui->comboBoxPoint->itemData(index)); + QListWidgetItem *item = ui->listWidget->item( ui->listWidget->currentRow() ); VSplinePoint p = qvariant_cast(item->data(Qt::UserRole)); const QSharedPointer point = data->GeometricObject(id); p.SetP(*point); - DataPoint(p.P().id(), p.KAsm1(), p.Angle1(), p.KAsm2(), p.Angle2()); + DataPoint(p); EnableFields(); item->setData(Qt::UserRole, QVariant::fromValue(p)); - item->setText(p.P().name()); + ShowPointIssue(p.P().name()); QColor color = okColor; if (not IsPathValid()) @@ -239,66 +651,6 @@ void DialogSplinePath::currentPointChanged(int index) CheckState(); } -//--------------------------------------------------------------------------------------------------------------------- -/** - * @brief Angle1Changed changed first angle - * @param index index in list - */ -void DialogSplinePath::Angle1Changed(qreal index) -{ - qint32 row = ui->listWidget->currentRow(); - QListWidgetItem *item = ui->listWidget->item( row ); - SCASSERT(item != nullptr); - VSplinePoint p = qvariant_cast(item->data(Qt::UserRole)); - p.SetAngle1(index); - DataPoint(p.P().id(), p.KAsm1(), p.Angle1(), p.KAsm2(), p.Angle2()); - item->setData(Qt::UserRole, QVariant::fromValue(p)); -} - -//--------------------------------------------------------------------------------------------------------------------- -/** - * @brief Angle2Changed changed second angle - * @param index index in list - */ -void DialogSplinePath::Angle2Changed(qreal index) -{ - qint32 row = ui->listWidget->currentRow(); - QListWidgetItem *item = ui->listWidget->item( row ); - SCASSERT(item != nullptr); - VSplinePoint p = qvariant_cast(item->data(Qt::UserRole)); - p.SetAngle2(index); - DataPoint(p.P().id(), p.KAsm1(), p.Angle1(), p.KAsm2(), p.Angle2()); - item->setData(Qt::UserRole, QVariant::fromValue(p)); -} - -//--------------------------------------------------------------------------------------------------------------------- -/** - * @brief KAsm1Changed changed first coefficient asymmetry - * @param d value - */ -void DialogSplinePath::KAsm1Changed(qreal d) -{ - qint32 row = ui->listWidget->currentRow(); - QListWidgetItem *item = ui->listWidget->item( row ); - VSplinePoint p = qvariant_cast(item->data(Qt::UserRole)); - p.SetKAsm1(d); - item->setData(Qt::UserRole, QVariant::fromValue(p)); -} - -//--------------------------------------------------------------------------------------------------------------------- -/** - * @brief KAsm2Changed changed second coefficient asymmetry - * @param d value - */ -void DialogSplinePath::KAsm2Changed(qreal d) -{ - qint32 row = ui->listWidget->currentRow(); - QListWidgetItem *item = ui->listWidget->item( row ); - VSplinePoint p = qvariant_cast(item->data(Qt::UserRole)); - p.SetKAsm2(d); - item->setData(Qt::UserRole, QVariant::fromValue(p)); -} - //--------------------------------------------------------------------------------------------------------------------- void DialogSplinePath::ShowDialog(bool click) { @@ -333,20 +685,19 @@ void DialogSplinePath::ShowVisualization() //--------------------------------------------------------------------------------------------------------------------- /** * @brief NewItem add point to list - * @param id id - * @param kAsm1 first coefficient asymmetry - * @param angle1 first angle in degree - * @param kAsm2 second coefficient asymmetry - * @param angle2 second angle in degree + * @param point spline path point */ -void DialogSplinePath::NewItem(quint32 id, qreal kAsm1, qreal angle1, qreal kAsm2, qreal angle2) +void DialogSplinePath::NewItem(const VSplinePoint &point) { - const QSharedPointer point = data->GeometricObject(id); - QListWidgetItem *item = new QListWidgetItem(point->name()); + auto item = new QListWidgetItem(point.P().name()); item->setFont(QFont("Times", 12, QFont::Bold)); - VSplinePoint p(*point.data(), kAsm1, angle1, kAsm2, angle2); - DataPoint(point->id(), kAsm1, angle1, kAsm2, angle2); - item->setData(Qt::UserRole, QVariant::fromValue(p)); + item->setData(Qt::UserRole, QVariant::fromValue(point)); + + flagAngle1.append(false); + flagAngle2.append(false); + flagLength1.append(false); + flagLength2.append(false); + ui->listWidget->addItem(item); ui->listWidget->setCurrentItem(item); if (ui->listWidget->count() >= 2) @@ -354,37 +705,34 @@ void DialogSplinePath::NewItem(quint32 id, qreal kAsm1, qreal angle1, qreal kAsm bOk = ui->buttonBox->button(QDialogButtonBox::Ok); bOk->setEnabled(true); } + + ui->comboBoxPoint->blockSignals(true); + ChangeCurrentData(ui->comboBoxPoint, point.P().id()); + ui->comboBoxPoint->blockSignals(false); + + ui->plainTextEditAngle1F->setPlainText(qApp->TrVars()->FormulaToUser(point.Angle1Formula())); + ui->plainTextEditAngle2F->setPlainText(qApp->TrVars()->FormulaToUser(point.Angle2Formula())); + ui->plainTextEditLength1F->setPlainText(qApp->TrVars()->FormulaToUser(point.Length1Formula())); + ui->plainTextEditLength2F->setPlainText(qApp->TrVars()->FormulaToUser(point.Length2Formula())); + EnableFields(); } //--------------------------------------------------------------------------------------------------------------------- /** * @brief dataPoint show data of point in fields - * @param id id - * @param kAsm1 first coefficient asymmetry - * @param angle1 first angle of spline - * @param kAsm2 second coefficient asymmetry - * @param angle2 second angle of spline + * @param p spline path point */ -void DialogSplinePath::DataPoint(quint32 id, qreal kAsm1, qreal angle1, qreal kAsm2, qreal angle2) +void DialogSplinePath::DataPoint(const VSplinePoint &p) { ui->comboBoxPoint->blockSignals(true); - ui->doubleSpinBoxAngle1->blockSignals(true); - ui->doubleSpinBoxAngle2->blockSignals(true); - ui->doubleSpinBoxKasm1->blockSignals(true); - ui->doubleSpinBoxKasm2->blockSignals(true); - - ChangeCurrentData(ui->comboBoxPoint, id); - ui->doubleSpinBoxKasm1->setValue(kAsm1); - ui->doubleSpinBoxKasm2->setValue(kAsm2); - ui->doubleSpinBoxAngle2->setValue(angle2); - ui->doubleSpinBoxAngle1->setValue(angle1); - + ChangeCurrentData(ui->comboBoxPoint, p.P().id()); ui->comboBoxPoint->blockSignals(false); - ui->doubleSpinBoxAngle1->blockSignals(false); - ui->doubleSpinBoxAngle2->blockSignals(false); - ui->doubleSpinBoxKasm1->blockSignals(false); - ui->doubleSpinBoxKasm2->blockSignals(false); + + ui->plainTextEditAngle1F->setPlainText(qApp->TrVars()->FormulaToUser(p.Angle1Formula())); + ui->plainTextEditAngle2F->setPlainText(qApp->TrVars()->FormulaToUser(p.Angle2Formula())); + ui->plainTextEditLength1F->setPlainText(qApp->TrVars()->FormulaToUser(p.Length1Formula())); + ui->plainTextEditLength2F->setPlainText(qApp->TrVars()->FormulaToUser(p.Length2Formula())); } //--------------------------------------------------------------------------------------------------------------------- @@ -393,22 +741,56 @@ void DialogSplinePath::DataPoint(quint32 id, qreal kAsm1, qreal angle1, qreal kA */ void DialogSplinePath::EnableFields() { - ui->doubleSpinBoxKasm1->setEnabled(true); - ui->doubleSpinBoxAngle1->setEnabled(true); - ui->doubleSpinBoxKasm2->setEnabled(true); - ui->doubleSpinBoxAngle2->setEnabled(true); - qint32 row = ui->listWidget->currentRow(); - if (row == 0) + + const qint32 row = ui->listWidget->currentRow(); + if (row == -1) { - ui->doubleSpinBoxKasm1->setEnabled(false); - ui->doubleSpinBoxAngle1->setEnabled(false); + ui->plainTextEditAngle1F->setEnabled(false); + ui->plainTextEditAngle2F->setEnabled(false); + ui->plainTextEditLength1F->setEnabled(false); + ui->plainTextEditLength2F->setEnabled(false); + + const QString error = tr("Error"); + + ui->plainTextEditAngle1F->setPlainText(error); + ui->plainTextEditAngle2F->setPlainText(error); + ui->plainTextEditLength1F->setPlainText(error); + ui->plainTextEditLength2F->setPlainText(error); return; } - if (row == ui->listWidget->count()-1) + else { - ui->doubleSpinBoxKasm2->setEnabled(false); - ui->doubleSpinBoxAngle2->setEnabled(false); - return; + ui->plainTextEditAngle1F->setEnabled(true); + ui->plainTextEditAngle2F->setEnabled(true); + ui->plainTextEditLength1F->setEnabled(true); + ui->plainTextEditLength2F->setEnabled(true); + } + + const QString field = tr("Not used"); + + if (row == 0) + { + ui->plainTextEditAngle1F->blockSignals(true); + ui->plainTextEditAngle1F->setPlainText(field); + ui->plainTextEditAngle1F->setEnabled(false); + ui->plainTextEditAngle1F->blockSignals(false); + + ui->plainTextEditLength1F->blockSignals(true); + ui->plainTextEditLength1F->setPlainText(field); + ui->plainTextEditLength1F->setEnabled(false); + ui->plainTextEditLength1F->blockSignals(false); + } + else if (row == ui->listWidget->count()-1) + { + ui->plainTextEditAngle2F->blockSignals(true); + ui->plainTextEditAngle2F->setPlainText(field); + ui->plainTextEditAngle2F->setEnabled(false); + ui->plainTextEditAngle2F->blockSignals(false); + + ui->plainTextEditLength2F->blockSignals(true); + ui->plainTextEditLength2F->setPlainText(field); + ui->plainTextEditLength2F->setEnabled(false); + ui->plainTextEditLength2F->blockSignals(false); } } @@ -445,10 +827,32 @@ bool DialogSplinePath::IsPathValid() const //--------------------------------------------------------------------------------------------------------------------- VSplinePath DialogSplinePath::ExtractPath() const { - VSplinePath path(ui->doubleSpinBoxKcurve->value()); + QVector points; for (qint32 i = 0; i < ui->listWidget->count(); ++i) { - path.append( qvariant_cast(ui->listWidget->item(i)->data(Qt::UserRole))); + points.append(qvariant_cast(ui->listWidget->item(i)->data(Qt::UserRole))); + } + return VSplinePath(points); +} + +//--------------------------------------------------------------------------------------------------------------------- +void DialogSplinePath::ShowPointIssue(const QString &pName) +{ + const int row = ui->listWidget->currentRow(); + if (row == -1) + { + return; + } + + QListWidgetItem *item = ui->listWidget->item(row); + SCASSERT(item != nullptr); + + if (flagAngle1.at(row) && flagAngle2.at(row) && flagLength1.at(row) && flagLength2.at(row)) + { + item->setText(pName); + } + else + { + item->setText(pName + QLatin1Literal("(!)")); } - return path; } diff --git a/src/libs/vtools/dialogs/tools/dialogsplinepath.h b/src/libs/vtools/dialogs/tools/dialogsplinepath.h index b992a697f..8ed56859b 100644 --- a/src/libs/vtools/dialogs/tools/dialogsplinepath.h +++ b/src/libs/vtools/dialogs/tools/dialogsplinepath.h @@ -47,27 +47,38 @@ public: DialogSplinePath(const VContainer *data, const quint32 &toolId, QWidget *parent = nullptr); virtual ~DialogSplinePath() Q_DECL_OVERRIDE; - VSplinePath GetPath() const; - void SetPath(const VSplinePath &value); + VSplinePath GetPath() const; + void SetPath(const VSplinePath &value); - QString GetColor() const; - void SetColor(const QString &value); + QString GetColor() const; + void SetColor(const QString &value); public slots: - virtual void ChosenObject(quint32 id, const SceneObject &type) Q_DECL_OVERRIDE; - void PointChanged(int row); - void currentPointChanged( int index ); - void Angle1Changed(qreal index ); - void Angle2Changed( qreal index ); - void KAsm1Changed(qreal d); - void KAsm2Changed(qreal d); - virtual void ShowDialog(bool click) Q_DECL_OVERRIDE; - void PathUpdated(const VSplinePath &path); + virtual void ChosenObject(quint32 id, const SceneObject &type) Q_DECL_OVERRIDE; + virtual void ShowDialog(bool click) Q_DECL_OVERRIDE; + void PathUpdated(const VSplinePath &path); protected: - virtual void ShowVisualization() Q_DECL_OVERRIDE; - /** - * @brief SaveData Put dialog data in local variables - */ - virtual void SaveData() Q_DECL_OVERRIDE; + virtual void ShowVisualization() Q_DECL_OVERRIDE; + virtual void SaveData() Q_DECL_OVERRIDE; + virtual void CheckState() Q_DECL_OVERRIDE; + virtual void closeEvent(QCloseEvent *event) Q_DECL_OVERRIDE; +private slots: + void PointChanged(int row); + void currentPointChanged(int index); + + void DeployAngle1TextEdit(); + void DeployAngle2TextEdit(); + void DeployLength1TextEdit(); + void DeployLength2TextEdit(); + + void Angle1Changed(); + void Angle2Changed(); + void Length1Changed(); + void Length2Changed(); + + void FXAngle1(); + void FXAngle2(); + void FXLength1(); + void FXLength2(); private: Q_DISABLE_COPY(DialogSplinePath) @@ -75,17 +86,41 @@ private: Ui::DialogSplinePath *ui; /** @brief path spline path */ - VSplinePath path; + VSplinePath path; - qint32 newDuplicate; + qint32 newDuplicate; - void NewItem(quint32 id, qreal kAsm1, qreal angle1, qreal kAsm2, qreal angle2); - void DataPoint(quint32 id, qreal kAsm1, qreal angle1, qreal kAsm2, qreal angle2); - void EnableFields(); - void SavePath(); - QSet AllIds() const; - bool IsPathValid() const; - VSplinePath ExtractPath() const; + /** @brief formulaBaseHeight base height defined by dialogui */ + int formulaBaseHeightAngle1; + int formulaBaseHeightAngle2; + int formulaBaseHeightLength1; + int formulaBaseHeightLength2; + + /** @brief timerAngle1 timer of check first angle formula */ + QTimer *timerAngle1; + QTimer *timerAngle2; + QTimer *timerLength1; + QTimer *timerLength2; + + /** @brief flagAngle1 true if value of first angle is correct */ + QVector flagAngle1; + QVector flagAngle2; + QVector flagLength1; + QVector flagLength2; + + void EvalAngle1(); + void EvalAngle2(); + void EvalLength1(); + void EvalLength2(); + + void NewItem(const VSplinePoint &point); + void DataPoint(const VSplinePoint &p); + void EnableFields(); + void SavePath(); + QSet AllIds() const; + bool IsPathValid() const; + VSplinePath ExtractPath() const; + void ShowPointIssue(const QString &pName); }; //--------------------------------------------------------------------------------------------------------------------- diff --git a/src/libs/vtools/dialogs/tools/dialogsplinepath.ui b/src/libs/vtools/dialogs/tools/dialogsplinepath.ui index e5e2ebb88..c70030d08 100644 --- a/src/libs/vtools/dialogs/tools/dialogsplinepath.ui +++ b/src/libs/vtools/dialogs/tools/dialogsplinepath.ui @@ -6,8 +6,8 @@ 0 0 - 519 - 401 + 456 + 532 @@ -20,7 +20,7 @@ - + @@ -44,46 +44,372 @@ First control point - - - QFormLayout::AllNonFixedFieldsGrow - - - - - Angle: - - - true - - - - - - - 360.000000000000000 - - - - - - - 0.010000000000000 - - - 1.000000000000000 - - - - - - - Length ratio: - - - true - - + + + + + + + + + + 0 + 0 + + + + + + + + + 255 + 0 + 0 + + + + + + + + + 255 + 0 + 0 + + + + + + + + + 159 + 158 + 158 + + + + + + + + Length: + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + Formula wizard + + + ... + + + + :/icon/24x24/fx.png:/icon/24x24/fx.png + + + + 24 + 24 + + + + + + + + + + + :/icon/24x24/equal.png + + + + + + + + 0 + 0 + + + + + 87 + 0 + + + + Value + + + _ + + + + + + + + + + + + 0 + 0 + + + + + 16777215 + 28 + + + + Calulation + + + true + + + + + + + + 18 + 18 + + + + + 0 + 0 + + + + <html><head/><body><p>Show full calculation in message box</p></body></html> + + + + + + + + + + + + 16 + 16 + + + + true + + + + + + + + + + + + 0 + 0 + + + + + + + + + 255 + 0 + 0 + + + + + + + + + 255 + 0 + 0 + + + + + + + + + 159 + 158 + 158 + + + + + + + + Angle: + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + Formula wizard + + + ... + + + + :/icon/24x24/fx.png:/icon/24x24/fx.png + + + + 24 + 24 + + + + + + + + + + + :/icon/24x24/equal.png + + + + + + + + 0 + 0 + + + + + 87 + 0 + + + + Value + + + _ + + + + + + + + + + + + 0 + 0 + + + + + 16777215 + 28 + + + + Calulation + + + true + + + + + + + + 18 + 18 + + + + + 0 + 0 + + + + <html><head/><body><p>Show full calculation in message box</p></body></html> + + + + + + + + + + + + 16 + 16 + + + + true + + + + + + @@ -93,45 +419,376 @@ Second control point - - - - - Length ratio: - - - true - - - - - - - 0.010000000000000 - - - 1.000000000000000 - - - - - - - Angle: - - - true - - - - - - - 360.000000000000000 - - + + + + + + + + + + 0 + 0 + + + + + + + + + 255 + 0 + 0 + + + + + + + + + 255 + 0 + 0 + + + + + + + + + 159 + 158 + 158 + + + + + + + + Length: + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + Formula wizard + + + ... + + + + :/icon/24x24/fx.png:/icon/24x24/fx.png + + + + 24 + 24 + + + + + + + + + + + :/icon/24x24/equal.png + + + + + + + + 0 + 0 + + + + + 87 + 0 + + + + Value + + + _ + + + + + + + + + + + + 0 + 0 + + + + + 16777215 + 28 + + + + Calulation + + + true + + + + + + + + 18 + 18 + + + + + 0 + 0 + + + + <html><head/><body><p>Show full calculation in message box</p></body></html> + + + + + + + + + + + + 16 + 16 + + + + true + + + + + + + + + + + + 0 + 0 + + + + + + + + + 255 + 0 + 0 + + + + + + + + + 255 + 0 + 0 + + + + + + + + + 159 + 158 + 158 + + + + + + + + Angle: + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + Formula wizard + + + ... + + + + :/icon/24x24/fx.png:/icon/24x24/fx.png + + + + 24 + 24 + + + + + + + + + + + :/icon/24x24/equal.png + + + + + + + + 0 + 0 + + + + + 87 + 0 + + + + Value + + + _ + + + + + + + + + + + + 0 + 0 + + + + + 16777215 + 28 + + + + Calulation + + + true + + + + + + + + 18 + 18 + + + + + 0 + 0 + + + + <html><head/><body><p>Show full calculation in message box</p></body></html> + + + + + + + + + + + + 16 + 16 + + + + true + + + + + + + layoutWidget_2 + layoutWidget_2 @@ -151,64 +808,23 @@ QFormLayout::ExpandingFieldsGrow - - - - 0 - 0 - - - - - 0 - 0 - - - - Coefficient of curvature of the curve: - - - - - - - - 0 - 0 - - - - - 72 - 0 - - - - 0.010000000000000 - - - 1.000000000000000 - - - - Color: - + - + Name: - + true diff --git a/src/libs/vtools/tools/drawTools/toolcurve/vabstractspline.cpp b/src/libs/vtools/tools/drawTools/toolcurve/vabstractspline.cpp index f6e31f2b9..3cd08c5c7 100644 --- a/src/libs/vtools/tools/drawTools/toolcurve/vabstractspline.cpp +++ b/src/libs/vtools/tools/drawTools/toolcurve/vabstractspline.cpp @@ -28,6 +28,7 @@ #include "vabstractspline.h" #include "../vwidgets/vcontrolpointspline.h" +#include "../qmuparser/qmutokenparser.h" #include @@ -242,6 +243,66 @@ void VAbstractSpline::SaveOptions(QDomElement &tag, QSharedPointer &ob doc->SetAttribute(tag, AttrColor, lineColor); } +//--------------------------------------------------------------------------------------------------------------------- +VSpline VAbstractSpline::CorrectedSpline(const VSpline &spline, const SplinePointPosition &position, + const QPointF &pos) const +{ + VSpline spl; + if (position == SplinePointPosition::FirstPoint) + { + QLineF line(spline.GetP1().toQPointF(), pos); + + qreal newAngle1 = line.angle(); + QString newAngle1F = QString().setNum(newAngle1); + + qreal newLength1 = line.length(); + QString newLength1F = QString().setNum(qApp->fromPixel(newLength1)); + + if (not qmu::QmuTokenParser::IsSingle(spline.GetStartAngleFormula())) + { + newAngle1 = spline.GetStartAngle(); + newAngle1F = spline.GetStartAngleFormula(); + } + + if (not qmu::QmuTokenParser::IsSingle(spline.GetC1LengthFormula())) + { + newLength1 = spline.GetC1Length(); + newLength1F = spline.GetC1LengthFormula(); + } + + spl = VSpline(spline.GetP1(), spline.GetP4(), newAngle1, newAngle1F, spline.GetEndAngle(), + spline.GetEndAngleFormula(), newLength1, newLength1F, spline.GetC2Length(), + spline.GetC2LengthFormula()); + } + else + { + QLineF line(spline.GetP4().toQPointF(), pos); + + qreal newAngle2 = line.angle(); + QString newAngle2F = QString().setNum(newAngle2); + + qreal newLength2 = line.length(); + QString newLength2F = QString().setNum(qApp->fromPixel(newLength2)); + + if (not qmu::QmuTokenParser::IsSingle(spline.GetEndAngleFormula())) + { + newAngle2 = spline.GetEndAngle(); + newAngle2F = spline.GetEndAngleFormula(); + } + + if (not qmu::QmuTokenParser::IsSingle(spline.GetC2LengthFormula())) + { + newLength2 = spline.GetC2Length(); + newLength2F = spline.GetC2LengthFormula(); + } + spl = VSpline(spline.GetP1(), spline.GetP4(), spline.GetStartAngle(), spline.GetStartAngleFormula(), + newAngle2, newAngle2F, spline.GetC1Length(), spline.GetC1LengthFormula(), + newLength2, newLength2F); + } + + return spl; +} + //--------------------------------------------------------------------------------------------------------------------- void VAbstractSpline::ShowHandles(bool show) { diff --git a/src/libs/vtools/tools/drawTools/toolcurve/vabstractspline.h b/src/libs/vtools/tools/drawTools/toolcurve/vabstractspline.h index 40f874c0d..821c56899 100644 --- a/src/libs/vtools/tools/drawTools/toolcurve/vabstractspline.h +++ b/src/libs/vtools/tools/drawTools/toolcurve/vabstractspline.h @@ -34,6 +34,7 @@ #include class VControlPointSpline; +class VSpline; class VAbstractSpline:public VDrawTool, public QGraphicsPathItem { @@ -87,6 +88,8 @@ protected: virtual void ReadToolAttributes(const QDomElement &domElement) Q_DECL_OVERRIDE; virtual void SaveOptions(QDomElement &tag, QSharedPointer &obj) Q_DECL_OVERRIDE; + VSpline CorrectedSpline(const VSpline &spline, const SplinePointPosition &position, const QPointF &pos) const; + template void ShowToolVisualization(bool show); diff --git a/src/libs/vtools/tools/drawTools/toolcurve/vtoolspline.cpp b/src/libs/vtools/tools/drawTools/toolcurve/vtoolspline.cpp index 92adf8563..0bada6c17 100644 --- a/src/libs/vtools/tools/drawTools/toolcurve/vtoolspline.cpp +++ b/src/libs/vtools/tools/drawTools/toolcurve/vtoolspline.cpp @@ -200,11 +200,11 @@ VToolSpline *VToolSpline::Create(const quint32 _id, quint32 point1, quint32 poin VMainGraphicsScene *scene, VAbstractPattern *doc, VContainer *data, const Document &parse, const Source &typeCreation) { - qreal calcAngle1 = CheckFormula(_id, a1, data); - qreal calcAngle2 = CheckFormula(_id, a2, data); + const qreal calcAngle1 = CheckFormula(_id, a1, data); + const qreal calcAngle2 = CheckFormula(_id, a2, data); - qreal calcLength1 = qApp->toPixel(CheckFormula(_id, l1, data)); - qreal calcLength2 = qApp->toPixel(CheckFormula(_id, l2, data)); + const qreal calcLength1 = qApp->toPixel(CheckFormula(_id, l1, data)); + const qreal calcLength2 = qApp->toPixel(CheckFormula(_id, l2, data)); auto p1 = data->GeometricObject(point1); auto p4 = data->GeometricObject(point4); @@ -252,58 +252,7 @@ void VToolSpline::ControlPointChangePosition(const qint32 &indexSpline, const Sp { Q_UNUSED(indexSpline); const QSharedPointer spline = VAbstractTool::data.GeometricObject(id); - VSpline spl; - if (position == SplinePointPosition::FirstPoint) - { - QLineF line(spline->GetP1().toQPointF(), pos); - - qreal newAngle1 = line.angle(); - QString newAngle1F = QString().setNum(newAngle1); - - qreal newLength1 = line.length(); - QString newLength1F = QString().setNum(qApp->fromPixel(newLength1)); - - if (not qmu::QmuTokenParser::IsSingle(spline->GetStartAngleFormula())) - { - newAngle1 = spline->GetStartAngle(); - newAngle1F = spline->GetStartAngleFormula(); - } - - if (not qmu::QmuTokenParser::IsSingle(spline->GetC1LengthFormula())) - { - newLength1 = spline->GetC1Length(); - newLength1F = spline->GetC1LengthFormula(); - } - - spl = VSpline(spline->GetP1(), spline->GetP4(), newAngle1, newAngle1F, spline->GetEndAngle(), - spline->GetEndAngleFormula(), newLength1, newLength1F, spline->GetC2Length(), - spline->GetC2LengthFormula()); - } - else - { - QLineF line(spline->GetP4().toQPointF(), pos); - - qreal newAngle2 = line.angle(); - QString newAngle2F = QString().setNum(newAngle2); - - qreal newLength2 = line.length(); - QString newLength2F = QString().setNum(qApp->fromPixel(newLength2)); - - if (not qmu::QmuTokenParser::IsSingle(spline->GetEndAngleFormula())) - { - newAngle2 = spline->GetEndAngle(); - newAngle2F = spline->GetEndAngleFormula(); - } - - if (not qmu::QmuTokenParser::IsSingle(spline->GetC2LengthFormula())) - { - newLength2 = spline->GetC2Length(); - newLength2F = spline->GetC2LengthFormula(); - } - spl = VSpline(spline->GetP1(), spline->GetP4(), spline->GetStartAngle(), spline->GetStartAngleFormula(), - newAngle2, newAngle2F, spline->GetC1Length(), spline->GetC1LengthFormula(), - newLength2, newLength2F); - } + const VSpline spl = CorrectedSpline(*spline, position, pos); MoveSpline *moveSpl = new MoveSpline(doc, spline.data(), spl, id, this->scene()); connect(moveSpl, &MoveSpline::NeedLiteParsing, doc, &VAbstractPattern::LiteParseTree); diff --git a/src/libs/vtools/tools/drawTools/toolcurve/vtoolsplinepath.cpp b/src/libs/vtools/tools/drawTools/toolcurve/vtoolsplinepath.cpp index 9ae386104..08d42d543 100644 --- a/src/libs/vtools/tools/drawTools/toolcurve/vtoolsplinepath.cpp +++ b/src/libs/vtools/tools/drawTools/toolcurve/vtoolsplinepath.cpp @@ -31,6 +31,7 @@ #include "../../../undocommands/movesplinepath.h" #include "../../../visualization/vistoolsplinepath.h" #include "../vwidgets/vcontrolpointspline.h" +#include "../qmuparser/qmutokenparser.h" #if QT_VERSION < QT_VERSION_CHECK(5, 1, 0) # include "../vmisc/vmath.h" @@ -38,7 +39,8 @@ # include #endif -const QString VToolSplinePath::ToolType = QStringLiteral("path"); +const QString VToolSplinePath::ToolType = QStringLiteral("pathInteractive"); +const QString VToolSplinePath::OldToolType = QStringLiteral("path"); //--------------------------------------------------------------------------------------------------------------------- /** @@ -66,17 +68,25 @@ VToolSplinePath::VToolSplinePath(VAbstractPattern *doc, VContainer *data, quint3 const QSharedPointer splPath = data->GeometricObject(id); for (qint32 i = 1; i<=splPath->Count(); ++i) { - VSpline spl = splPath->GetSpline(i); + const VSpline spl = splPath->GetSpline(i); + + const bool freeAngle1 = qmu::QmuTokenParser::IsSingle(spl.GetStartAngleFormula()); + const bool freeLength1 = qmu::QmuTokenParser::IsSingle(spl.GetC1LengthFormula()); + auto *controlPoint = new VControlPointSpline(i, SplinePointPosition::FirstPoint, spl.GetP2(), - spl.GetP1().toQPointF(), *data->GetPatternUnit(), true, true, this); + spl.GetP1().toQPointF(), *data->GetPatternUnit(), freeAngle1, + freeLength1, this); connect(controlPoint, &VControlPointSpline::ControlPointChangePosition, this, &VToolSplinePath::ControlPointChangePosition); connect(this, &VToolSplinePath::setEnabledPoint, controlPoint, &VControlPointSpline::setEnabledPoint); connect(controlPoint, &VControlPointSpline::ShowContextMenu, this, &VToolSplinePath::contextMenuEvent); controlPoints.append(controlPoint); + const bool freeAngle2 = qmu::QmuTokenParser::IsSingle(spl.GetEndAngleFormula()); + const bool freeLength2 = qmu::QmuTokenParser::IsSingle(spl.GetC2LengthFormula()); + controlPoint = new VControlPointSpline(i, SplinePointPosition::LastPoint, spl.GetP3(), spl.GetP4().toQPointF(), - *data->GetPatternUnit(), true, true, this); + *data->GetPatternUnit(), freeAngle2, freeLength2, this); connect(controlPoint, &VControlPointSpline::ControlPointChangePosition, this, &VToolSplinePath::ControlPointChangePosition); connect(this, &VToolSplinePath::setEnabledPoint, controlPoint, &VControlPointSpline::setEnabledPoint); @@ -184,6 +194,31 @@ VToolSplinePath* VToolSplinePath::Create(const quint32 _id, VSplinePath *path, c return nullptr; } +//--------------------------------------------------------------------------------------------------------------------- +VToolSplinePath *VToolSplinePath::Create(const quint32 _id, const QVector &points, QVector &a1, + QVector &a2, QVector &l1, QVector &l2, + const QString &color, VMainGraphicsScene *scene, VAbstractPattern *doc, + VContainer *data, const Document &parse, const Source &typeCreation) +{ + auto path = new VSplinePath(); + + for (int i = 0; i < points.size(); ++i) + { + const qreal calcAngle1 = CheckFormula(_id, a1[i], data); + const qreal calcAngle2 = CheckFormula(_id, a2[i], data); + + const qreal calcLength1 = qApp->toPixel(CheckFormula(_id, l1[i], data)); + const qreal calcLength2 = qApp->toPixel(CheckFormula(_id, l2[i], data)); + + const auto p = *data->GeometricObject(points.at(i)); + + path->append(VSplinePoint(p, calcAngle1, a1.at(i), calcAngle2, a2.at(i), calcLength1, l1.at(i), calcLength2, + l2.at(i))); + } + + return VToolSplinePath::Create(_id, path, color, scene, doc, data, parse, typeCreation); +} + //--------------------------------------------------------------------------------------------------------------------- /** * @brief ControlPointChangePosition handle change position control point. @@ -194,18 +229,9 @@ VToolSplinePath* VToolSplinePath::Create(const quint32 _id, VSplinePath *path, c void VToolSplinePath::ControlPointChangePosition(const qint32 &indexSpline, const SplinePointPosition &position, const QPointF &pos) { - VSplinePath oldSplPath = *VAbstractTool::data.GeometricObject(id); + const VSplinePath oldSplPath = *VAbstractTool::data.GeometricObject(id); VSplinePath newSplPath = oldSplPath; - VSpline spl = newSplPath.GetSpline(indexSpline); - if (position == SplinePointPosition::FirstPoint) - { - spl = VSpline(spl.GetP1(), pos, spl.GetP3(), spl.GetP4()); - } - else - { - spl = VSpline(spl.GetP1(), spl.GetP2(), pos, spl.GetP4()); - } - + const VSpline spl = CorrectedSpline(newSplPath.GetSpline(indexSpline), position, pos); UpdateControlPoints(spl, newSplPath, indexSpline); MoveSplinePath *moveSplPath = new MoveSplinePath(doc, oldSplPath, newSplPath, id, this->scene()); @@ -229,56 +255,51 @@ void VToolSplinePath::EnableToolMove(bool move) void VToolSplinePath::UpdateControlPoints(const VSpline &spl, VSplinePath &splPath, const qint32 &indexSpline) const { VSplinePoint p = splPath.GetSplinePoint(indexSpline, SplinePointPosition::FirstPoint); - p.SetAngle2(spl.GetStartAngle()); - p.SetKAsm2(spl.GetKasm1()); + p.SetAngle2(spl.GetStartAngle(), spl.GetStartAngleFormula()); + p.SetLength2(spl.GetC2Length(), spl.GetC2LengthFormula()); splPath.UpdatePoint(indexSpline, SplinePointPosition::FirstPoint, p); p = splPath.GetSplinePoint(indexSpline, SplinePointPosition::LastPoint); - p.SetAngle2(spl.GetEndAngle()-180); - p.SetKAsm1(spl.GetKasm2()); + p.SetAngle1(spl.GetEndAngle(), spl.GetEndAngleFormula()); + p.SetLength1(spl.GetC2Length(), spl.GetC2LengthFormula()); splPath.UpdatePoint(indexSpline, SplinePointPosition::LastPoint, p); } //--------------------------------------------------------------------------------------------------------------------- -void VToolSplinePath::RefreshSplinePath(VSplinePath &splPath) +void VToolSplinePath::SetSplinePathAttributes(QDomElement &domElement, const VSplinePath &path) { - for (qint32 i = 1; i<=splPath.Count(); ++i) + doc->SetAttribute(domElement, AttrType, ToolType); + + if (path.GetDuplicate() > 0) { - VSpline spl = splPath.GetSpline(i); - qint32 j = i*2; - - controlPoints[j-2]->blockSignals(true); - controlPoints[j-1]->blockSignals(true); - - controlPoints[j-2]->setPos(spl.GetP2()); - controlPoints[j-1]->setPos(spl.GetP3()); - - controlPoints[j-2]->blockSignals(false); - controlPoints[j-1]->blockSignals(false); - - spl = VSpline (spl.GetP1(), controlPoints[j-2]->pos(), controlPoints[j-1]->pos(), spl.GetP4()); - UpdateControlPoints(spl, splPath, i); + doc->SetAttribute(domElement, AttrDuplicate, path.GetDuplicate()); } + else + { + if (domElement.hasAttribute(AttrDuplicate)) + { + domElement.removeAttribute(AttrDuplicate); + } + } + + if (domElement.hasAttribute(AttrKCurve)) + { + domElement.removeAttribute(AttrKCurve); + } + + UpdatePathPoints(doc, domElement, path); } //--------------------------------------------------------------------------------------------------------------------- /** - * @brief UpdatePathPoint update spline path in pattern file. + * @brief UpdatePathPoints update spline path in pattern file. * @param doc dom document container. * @param node tag in file. * @param path spline path. */ -void VToolSplinePath::UpdatePathPoint(VAbstractPattern *doc, QDomNode& node, const VSplinePath &path) +void VToolSplinePath::UpdatePathPoints(VAbstractPattern *doc, QDomElement &element, const VSplinePath &path) { - SCASSERT(doc != nullptr); - QDomElement element = node.toElement(); - if (element.isElement() == false) - { - qDebug()<<"Couldn't convert parent to element."; - return; - } - - doc->removeAllChilds(element); + VDomDocument::RemoveAllChildren(element); for (qint32 i = 0; i < path.CountPoint(); ++i) { AddPathPoint(doc, element, path.at(i)); @@ -325,24 +346,6 @@ void VToolSplinePath::contextMenuEvent(QGraphicsSceneContextMenuEvent *event) } } -//--------------------------------------------------------------------------------------------------------------------- -/** - * @brief RefreshDataInFile refresh attributes in file. If attributes don't exist create them. - */ -void VToolSplinePath::RefreshDataInFile() -{ - QDomElement domElement = doc->elementById(id); - if (domElement.isElement() == false) - { - qDebug()<<"Can't find element with id="<(id); - RefreshSplinePath(splPath); - doc->SetAttribute(domElement, AttrKCurve, QString().setNum(splPath.GetKCurve())); - UpdatePathPoint(doc, domElement, splPath); -} - //--------------------------------------------------------------------------------------------------------------------- /** * @brief AddPathPoint write path point to pattern file. @@ -355,9 +358,25 @@ void VToolSplinePath::AddPathPoint(VAbstractPattern *doc, QDomElement &domElemen QDomElement pathPoint = doc->createElement(AttrPathPoint); doc->SetAttribute(pathPoint, AttrPSpline, splPoint.P().id()); - doc->SetAttribute(pathPoint, AttrKAsm1, splPoint.KAsm1()); - doc->SetAttribute(pathPoint, AttrKAsm2, splPoint.KAsm2()); - doc->SetAttribute(pathPoint, AttrAngle, splPoint.Angle2()); + doc->SetAttribute(pathPoint, AttrLength1, splPoint.Length1Formula()); + doc->SetAttribute(pathPoint, AttrLength2, splPoint.Length2Formula()); + doc->SetAttribute(pathPoint, AttrAngle1, splPoint.Angle1Formula()); + doc->SetAttribute(pathPoint, AttrAngle2, splPoint.Angle2Formula()); + + if (domElement.hasAttribute(AttrKAsm1)) + { + domElement.removeAttribute(AttrKAsm1); + } + + if (domElement.hasAttribute(AttrKAsm2)) + { + domElement.removeAttribute(AttrKAsm2); + } + + if (domElement.hasAttribute(AttrAngle)) + { + domElement.removeAttribute(AttrAngle); + } domElement.appendChild(pathPoint); } @@ -385,11 +404,24 @@ void VToolSplinePath::SaveDialog(QDomElement &domElement) DialogSplinePath *dialogTool = qobject_cast(dialog); SCASSERT(dialogTool != nullptr); - VSplinePath splPath = dialogTool->GetPath(); - RefreshSplinePath(splPath); - doc->SetAttribute(domElement, AttrKCurve, QString().setNum(splPath.GetKCurve())); + const VSplinePath splPath = dialogTool->GetPath(); + for (qint32 i = 1; i <= splPath.Count(); ++i) + { + VSpline spl = splPath.GetSpline(i); + qint32 j = i*2; + + controlPoints[j-2]->blockSignals(true); + controlPoints[j-1]->blockSignals(true); + + controlPoints[j-2]->setPos(spl.GetP2()); + controlPoints[j-1]->setPos(spl.GetP3()); + + controlPoints[j-2]->blockSignals(false); + controlPoints[j-1]->blockSignals(false); + } + doc->SetAttribute(domElement, AttrColor, dialogTool->GetColor()); - UpdatePathPoint(doc, domElement, splPath); + SetSplinePathAttributes(domElement, splPath); } //--------------------------------------------------------------------------------------------------------------------- @@ -400,26 +432,7 @@ void VToolSplinePath::SaveOptions(QDomElement &tag, QSharedPointer &ob QSharedPointer splPath = qSharedPointerDynamicCast(obj); SCASSERT(splPath.isNull() == false); - doc->SetAttribute(tag, AttrType, ToolType); - doc->SetAttribute(tag, AttrKCurve, splPath->GetKCurve()); - - if (splPath->GetDuplicate() > 0) - { - doc->SetAttribute(tag, AttrDuplicate, splPath->GetDuplicate()); - } - else - { - if (tag.hasAttribute(AttrDuplicate)) - { - tag.removeAttribute(AttrDuplicate); - } - } - - doc->RemoveAllChild(tag); - for (qint32 i = 0; i < splPath->CountPoint(); ++i) - { - AddPathPoint(doc, tag, splPath->at(i)); - } + SetSplinePathAttributes(tag, *splPath); } //--------------------------------------------------------------------------------------------------------------------- @@ -608,13 +621,21 @@ void VToolSplinePath::RefreshGeometry() const auto spl = splPath->GetSpline(i); { + const bool freeAngle1 = qmu::QmuTokenParser::IsSingle(spl.GetStartAngleFormula()); + const bool freeLength1 = qmu::QmuTokenParser::IsSingle(spl.GetC1LengthFormula()); + const auto splinePoint = spl.GetP1().toQPointF(); - controlPoints[j-2]->RefreshCtrlPoint(i, SplinePointPosition::FirstPoint, spl.GetP2(), splinePoint); + controlPoints[j-2]->RefreshCtrlPoint(i, SplinePointPosition::FirstPoint, spl.GetP2(), splinePoint, + freeAngle1, freeLength1); } { + const bool freeAngle2 = qmu::QmuTokenParser::IsSingle(spl.GetEndAngleFormula()); + const bool freeLength2 = qmu::QmuTokenParser::IsSingle(spl.GetC2LengthFormula()); + const auto splinePoint = spl.GetP4().toQPointF(); - controlPoints[j-1]->RefreshCtrlPoint(i, SplinePointPosition::LastPoint, spl.GetP3(), splinePoint); + controlPoints[j-1]->RefreshCtrlPoint(i, SplinePointPosition::LastPoint, spl.GetP3(), splinePoint, + freeAngle2, freeLength2); } controlPoints[j-2]->blockSignals(false); diff --git a/src/libs/vtools/tools/drawTools/toolcurve/vtoolsplinepath.h b/src/libs/vtools/tools/drawTools/toolcurve/vtoolsplinepath.h index ab6ca7db6..840d652c0 100644 --- a/src/libs/vtools/tools/drawTools/toolcurve/vtoolsplinepath.h +++ b/src/libs/vtools/tools/drawTools/toolcurve/vtoolsplinepath.h @@ -53,8 +53,14 @@ public: VMainGraphicsScene *scene, VAbstractPattern *doc, VContainer *data, const Document &parse, const Source &typeCreation); + + static VToolSplinePath *Create(const quint32 _id, const QVector &points, QVector &a1, + QVector &a2, QVector &l1, QVector &l2, + const QString &color, VMainGraphicsScene *scene, VAbstractPattern *doc, + VContainer *data, const Document &parse, const Source &typeCreation); static const QString ToolType; - static void UpdatePathPoint(VAbstractPattern *doc, QDomNode& node, const VSplinePath &path); + static const QString OldToolType; + static void UpdatePathPoints(VAbstractPattern *doc, QDomElement &element, const VSplinePath &path); virtual int type() const Q_DECL_OVERRIDE {return Type;} enum { Type = UserType + static_cast(Tool::SplinePath)}; @@ -84,7 +90,6 @@ public slots: virtual void EnableToolMove(bool move) Q_DECL_OVERRIDE; protected: virtual void contextMenuEvent ( QGraphicsSceneContextMenuEvent * event ) Q_DECL_OVERRIDE; - virtual void RefreshDataInFile() Q_DECL_OVERRIDE; virtual void RemoveReferens() Q_DECL_OVERRIDE; virtual void SaveDialog(QDomElement &domElement) Q_DECL_OVERRIDE; virtual void SaveOptions(QDomElement &tag, QSharedPointer &obj) Q_DECL_OVERRIDE; @@ -100,7 +105,7 @@ private: void RefreshGeometry(); static void AddPathPoint(VAbstractPattern *doc, QDomElement &domElement, const VSplinePoint &splPoint); void UpdateControlPoints(const VSpline &spl, VSplinePath &splPath, const qint32 &indexSpline) const; - void RefreshSplinePath(VSplinePath &splPath); + void SetSplinePathAttributes(QDomElement &domElement, const VSplinePath &path); }; #endif // VTOOLSPLINEPATH_H diff --git a/src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/toolcut/vtoolcutsplinepath.cpp b/src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/toolcut/vtoolcutsplinepath.cpp index bcebedd16..2cba23674 100644 --- a/src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/toolcut/vtoolcutsplinepath.cpp +++ b/src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/toolcut/vtoolcutsplinepath.cpp @@ -160,10 +160,19 @@ VToolCutSplinePath* VToolCutSplinePath::Create(const quint32 _id, const QString { if (i == p1) { - splPath1->append(VSplinePoint(splP1.P(), splP1.KAsm1(), spl1.GetStartAngle()+180, spl1.GetKasm1(), - spl1.GetStartAngle())); - VSplinePoint cutPoint; - cutPoint = VSplinePoint(*p, spl1.GetKasm2(), spl1.GetEndAngle(), spl2.GetKasm1(), spl1.GetEndAngle()+180); + const qreal angle1 = spl1.GetStartAngle()+180; + const QString angle1F = QString().number(angle1); + + splPath1->append(VSplinePoint(splP1.P(), angle1, angle1F, spl1.GetStartAngle(), + spl1.GetStartAngleFormula(), splP1.Length1(), splP1.Length1Formula(), + spl1.GetC1Length(), spl1.GetC1LengthFormula())); + + const qreal angle2 = spl1.GetEndAngle()+180; + const QString angle2F = QString().number(angle2); + + const auto cutPoint = VSplinePoint(*p, spl1.GetEndAngle(), spl1.GetEndAngleFormula(), angle2, angle2F, + spl1.GetC2Length(), spl1.GetC2LengthFormula(), spl2.GetC1Length(), + spl2.GetC1LengthFormula()); splPath1->append(cutPoint); continue; } @@ -173,18 +182,27 @@ VToolCutSplinePath* VToolCutSplinePath::Create(const quint32 _id, const QString { if (i == p2) { - const VSplinePoint cutPoint = VSplinePoint(*p, spl1.GetKasm2(), spl2.GetStartAngle()+180, - spl2.GetKasm1(), spl2.GetStartAngle()); + const qreal angle1 = spl2.GetStartAngle()+180; + const QString angle1F = QString().number(angle1); + + const auto cutPoint = VSplinePoint(*p, angle1, angle1F, spl2.GetStartAngle(), + spl2.GetStartAngleFormula(), spl1.GetC2Length(), + spl1.GetC2LengthFormula(), spl2.GetC1Length(), + spl2.GetC1LengthFormula()); + splPath2->append(cutPoint); - splPath2->append(VSplinePoint(splP2.P(), spl2.GetKasm2(), spl2.GetEndAngle(), splP2.KAsm2(), - spl2.GetEndAngle()+180)); + + const qreal angle2 = spl2.GetEndAngle()+180; + const QString angle2F = QString().number(angle2); + + splPath2->append(VSplinePoint(splP2.P(), spl2.GetEndAngle(), spl2.GetEndAngleFormula(), angle2, angle2F, + spl2.GetC2Length(), spl2.GetC2LengthFormula(), splP2.Length2(), + splP2.Length2Formula())); continue; } splPath2->append(splPath->at(i)); } } - splPath1->SetKCurve(splPath->GetKCurve()); - splPath2->SetKCurve(splPath->GetKCurve()); if (typeCreation == Source::FromGui) { diff --git a/src/libs/vtools/tools/vtooldetail.cpp b/src/libs/vtools/tools/vtooldetail.cpp index 7262c5258..e3fd18cea 100644 --- a/src/libs/vtools/tools/vtooldetail.cpp +++ b/src/libs/vtools/tools/vtooldetail.cpp @@ -330,7 +330,7 @@ void VToolDetail::RefreshDataInFile() doc->SetAttribute(domElement, AttrSupplement, QString().setNum(static_cast(det.getSeamAllowance()))); doc->SetAttribute(domElement, AttrClosed, QString().setNum(static_cast(det.getClosed()))); doc->SetAttribute(domElement, AttrWidth, QString().setNum(det.getWidth())); - doc->RemoveAllChild(domElement); + doc->RemoveAllChildren(domElement); for (int i = 0; i < det.CountNode(); ++i) { AddNode(doc, domElement, det.at(i)); diff --git a/src/libs/vtools/tools/vtooluniondetails.cpp b/src/libs/vtools/tools/vtooluniondetails.cpp index a77423d1a..714bf7a7e 100644 --- a/src/libs/vtools/tools/vtooluniondetails.cpp +++ b/src/libs/vtools/tools/vtooluniondetails.cpp @@ -220,9 +220,9 @@ void VToolUnionDetails::AddToNewDetail(VMainGraphicsScene *scene, VAbstractPatte { const VSplinePoint &point1 = splinePath->at(i-1); const VSplinePoint &point2 = splinePath->at(i); - VSpline spline(point1.P(), point2.P(), - point1.Angle2(), point2.Angle1(), point1.KAsm2(), - point2.KAsm1(), splinePath->GetKCurve()); + VSpline spline(point1.P(), point2.P(), point1.Angle2(), point1.Angle2Formula(), point2.Angle1(), + point2.Angle1Formula(), point1.Length2(), point1.Length2Formula(), point2.Length1(), + point2.Length1Formula()); const QPointF p = data->GeometricObject(pRotate)->toQPointF(); VPointF *p1 = new VPointF(spline.GetP1()); @@ -240,11 +240,21 @@ void VToolUnionDetails::AddToNewDetail(VMainGraphicsScene *scene, VAbstractPatte VSpline spl = VSpline(*p1, p2.toQPointF(), p3.toQPointF(), *p4); if (i==1) { - path->append(VSplinePoint(*p1, point1.KAsm1(), spl.GetStartAngle()+180, - point1.KAsm2(), spl.GetStartAngle())); + const qreal angle1 = spl.GetStartAngle()+180; + const QString angle1F = QString().number(angle1); + + path->append(VSplinePoint(*p1, angle1, angle1F, spl.GetStartAngle(), spl.GetStartAngleFormula(), + point1.Length1(), point1.Length1Formula(), point1.Length2(), + point1.Length2Formula())); } - path->append(VSplinePoint(*p4, point2.KAsm1(), spl.GetEndAngle(), - point2.KAsm2(), spl.GetEndAngle()+180)); + + const qreal angle2 = spl.GetEndAngle()+180; + const QString angle2F = QString().number(angle2); + + path->append(VSplinePoint(*p4, spl.GetEndAngle(), spl.GetEndAngleFormula(), angle2, angle2F, + point2.Length1(), point2.Length1Formula(), point2.Length2(), + point2.Length2Formula())); + delete p4; delete p1; } @@ -360,9 +370,10 @@ void VToolUnionDetails::UpdatePoints(VContainer *data, const VDetail &det, const { const VSplinePoint &point1 = splinePath->at(i-1); const VSplinePoint &point2 = splinePath->at(i); - VSpline spline(point1.P(), point2.P(), - point1.Angle2(), point2.Angle1(), point1.KAsm2(), - point2.KAsm1(), splinePath->GetKCurve()); + + VSpline spline(point1.P(), point2.P(), point1.Angle2(), point1.Angle2Formula(), point2.Angle1(), + point2.Angle1Formula(), point1.Length2(), point1.Length2Formula(), point2.Length1(), + point2.Length1Formula()); const QPointF p = data->GeometricObject(pRotate)->toQPointF(); VPointF *p1 = new VPointF(spline.GetP1()); @@ -380,11 +391,21 @@ void VToolUnionDetails::UpdatePoints(VContainer *data, const VDetail &det, const VSpline spl = VSpline(*p1, p2.toQPointF(), p3.toQPointF(), *p4); if (i==1) { - path->append(VSplinePoint(*p1, point1.KAsm1(), spl.GetStartAngle()+180, - point1.KAsm2(), spl.GetStartAngle())); + const qreal angle1 = spl.GetStartAngle()+180; + const QString angle1F = QString().number(angle1); + + path->append(VSplinePoint(*p1, angle1, angle1F, spl.GetStartAngle(), spl.GetStartAngleFormula(), + point1.Length1(), point1.Length1Formula(), point1.Length2(), + point1.Length2Formula())); } - path->append(VSplinePoint(*p4, point2.KAsm1(), spl.GetEndAngle(), - point2.KAsm2(), spl.GetEndAngle()+180)); + + const qreal angle2 = spl.GetEndAngle()+180; + const QString angle2F = QString().number(angle2); + + path->append(VSplinePoint(*p4, spl.GetEndAngle(), spl.GetEndAngleFormula(), angle2, angle2F, + point2.Length1(), point2.Length1Formula(), point2.Length2(), + point2.Length2Formula())); + delete p1; delete p4; } @@ -847,7 +868,7 @@ QDomNode VToolUnionDetails::UpdateDetail(const QDomNode &domNode, const VDetail { if (domElement.tagName() == VToolUnionDetails::TagDetail) { - doc->removeAllChilds(domElement);//delete all nodes in detail + VDomDocument::RemoveAllChildren(domElement);//delete all nodes in detail for (int i = 0; i < d.CountNode(); ++i) { AddNode(domElement, d.at(i));//rewrite nodes of detail diff --git a/src/libs/vtools/undocommands/movesplinepath.cpp b/src/libs/vtools/undocommands/movesplinepath.cpp index 398ed9605..f744fa770 100644 --- a/src/libs/vtools/undocommands/movesplinepath.cpp +++ b/src/libs/vtools/undocommands/movesplinepath.cpp @@ -89,8 +89,7 @@ void MoveSplinePath::Do(const VSplinePath &splPath) QDomElement domElement = doc->elementById(nodeId); if (domElement.isElement()) { - doc->SetAttribute(domElement, AttrKCurve, QString().setNum(splPath.GetKCurve())); - VToolSplinePath::UpdatePathPoint(doc, domElement, splPath); + VToolSplinePath::UpdatePathPoints(doc, domElement, splPath); emit NeedLiteParsing(Document::LiteParse); } diff --git a/src/libs/vtools/undocommands/savedetailoptions.cpp b/src/libs/vtools/undocommands/savedetailoptions.cpp index fe5d270e5..7b3fddf30 100644 --- a/src/libs/vtools/undocommands/savedetailoptions.cpp +++ b/src/libs/vtools/undocommands/savedetailoptions.cpp @@ -54,7 +54,7 @@ void SaveDetailOptions::undo() if (domElement.isElement()) { SaveDet(domElement, oldDet); - doc->RemoveAllChild(domElement); + doc->RemoveAllChildren(domElement); for (int i = 0; i < oldDet.CountNode(); ++i) { VToolDetail::AddNode(doc, domElement, oldDet.at(i)); @@ -85,7 +85,7 @@ void SaveDetailOptions::redo() if (domElement.isElement()) { SaveDet(domElement, newDet); - doc->RemoveAllChild(domElement); + doc->RemoveAllChildren(domElement); for (int i = 0; i < newDet.CountNode(); ++i) { VToolDetail::AddNode(doc, domElement, newDet.at(i)); diff --git a/src/libs/vtools/visualization/vistoolcutsplinepath.cpp b/src/libs/vtools/visualization/vistoolcutsplinepath.cpp index 2737cc7d0..2b43faf89 100644 --- a/src/libs/vtools/visualization/vistoolcutsplinepath.cpp +++ b/src/libs/vtools/visualization/vistoolcutsplinepath.cpp @@ -79,11 +79,21 @@ void VisToolCutSplinePath::RefreshGeometry() { if (i == p1) { - spPath1.append(VSplinePoint(splP1.P(), splP1.KAsm1(), spl1.GetStartAngle()+180, spl1.GetKasm1(), - spl1.GetStartAngle())); - VSplinePoint cutPoint; - cutPoint = VSplinePoint(p, spl1.GetKasm2(), spl1.GetEndAngle(), spl2.GetKasm1(), - spl1.GetEndAngle()+180); + const qreal angle1 = spl1.GetStartAngle()+180; + const QString angle1F = QString().number(angle1); + + spPath1.append(VSplinePoint(splP1.P(), angle1, angle1F, spl1.GetStartAngle(), + spl1.GetStartAngleFormula(), splP1.Length1(), + splP1.Length1Formula(), spl1.GetC1Length(), + spl1.GetC1LengthFormula())); + + const qreal angle2 = spl1.GetEndAngle()+180; + const QString angle2F = QString().number(angle2); + + const auto cutPoint = VSplinePoint(p, spl1.GetEndAngle(), spl1.GetEndAngleFormula(), angle2, + angle2F, spl1.GetC2Length(), spl1.GetC2LengthFormula(), + spl2.GetC1Length(), spl2.GetC1LengthFormula()); + spPath1.append(cutPoint); continue; } @@ -93,20 +103,29 @@ void VisToolCutSplinePath::RefreshGeometry() { if (i == p2) { - const VSplinePoint cutPoint = VSplinePoint(p, spl1.GetKasm2(), spl2.GetStartAngle()+180, - spl2.GetKasm1(), spl2.GetStartAngle()); + const qreal angle1 = spl2.GetStartAngle()+180; + const QString angle1F = QString().number(angle1); + + const auto cutPoint = VSplinePoint(p, angle1, angle1F, spl2.GetStartAngle(), + spl2.GetStartAngleFormula(), spl1.GetC2Length(), + spl1.GetC2LengthFormula(), spl2.GetC1Length(), + spl2.GetC1LengthFormula()); + spPath2.append(cutPoint); - spPath2.append(VSplinePoint(splP2.P(), spl2.GetKasm2(), spl2.GetEndAngle(), splP2.KAsm2(), - spl2.GetEndAngle()+180)); + + const qreal angle2 = spl2.GetEndAngle()+180; + const QString angle2F = QString().number(angle2); + + spPath2.append(VSplinePoint(splP2.P(), spl2.GetEndAngle(), spl2.GetEndAngleFormula(), angle2, + angle2F, spl2.GetC2Length(), spl2.GetC2LengthFormula(), + splP2.Length2(), splP2.Length2Formula())); + continue; } spPath2.append(splPath->at(i)); } } - spPath1.SetKCurve(splPath->GetKCurve()); - spPath2.SetKCurve(splPath->GetKCurve()); - DrawPoint(point, cutPoint, mainColor); DrawPath(splPath1, spPath1.GetPath(PathDirection::Show), Qt::darkGreen, Qt::SolidLine, Qt::RoundCap); diff --git a/src/libs/vtools/visualization/vistoolsplinepath.cpp b/src/libs/vtools/visualization/vistoolsplinepath.cpp index f5367f8de..a9dfb6617 100644 --- a/src/libs/vtools/visualization/vistoolsplinepath.cpp +++ b/src/libs/vtools/visualization/vistoolsplinepath.cpp @@ -234,14 +234,14 @@ void VisToolSplinePath::Creating(const QPointF &pSpl, int size) if (size == 1) { - path[size-1].SetAngle2(spline.GetStartAngle()); + path[size-1].SetAngle2(spline.GetStartAngle(), spline.GetStartAngleFormula()); if (ctrlPoint != pSpl) { - path[size-1].SetKAsm2(spline.GetKasm1()); + path[size-1].SetLength2(spline.GetC1Length(), spline.GetC1LengthFormula()); } else { - path[size-1].SetKAsm2(0); + path[size-1].SetLength2(0, "0"); } emit PathChanged(path); } @@ -250,16 +250,16 @@ void VisToolSplinePath::Creating(const QPointF &pSpl, int size) const VSpline spl = path.GetSpline(size - 1); VSpline preSpl(spl.GetP1(), spl.GetP2(), ctrlLine.p2(), VPointF(pSpl)); - path[size-1].SetAngle2(spline.GetStartAngle()); + path[size-1].SetAngle2(spline.GetStartAngle(), spline.GetStartAngleFormula()); if (ctrlPoint != pSpl) { - path[size-1].SetKAsm1(preSpl.GetKasm2()); - path[size-1].SetKAsm2(spline.GetKasm1()); + path[size-1].SetLength1(preSpl.GetC2Length(), preSpl.GetC2LengthFormula()); + path[size-1].SetLength2(spline.GetC1Length(), spline.GetC1LengthFormula()); } else { - path[size-1].SetKAsm1(0); - path[size-1].SetKAsm2(0); + path[size-1].SetLength1(0, "0"); + path[size-1].SetLength2(0, "0"); } emit PathChanged(path); } @@ -270,15 +270,15 @@ void VisToolSplinePath::Creating(const QPointF &pSpl, int size) VSpline spline(VPointF(pSpl), ctrlPoint, Visualization::scenePos, VPointF(Visualization::scenePos)); - path[size-1].SetAngle2(spline.GetStartAngle()); + path[size-1].SetAngle2(spline.GetStartAngle(), spline.GetStartAngleFormula()); if (ctrlPoint != pSpl) { - path[size-1].SetKAsm2(spline.GetKasm1()); + path[size-1].SetLength2(spline.GetC1Length(), spline.GetC1LengthFormula()); } else { - path[size-1].SetKAsm2(0); + path[size-1].SetLength2(0, "0"); } emit PathChanged(path); diff --git a/src/test/ValentinaTest/tst_vdetail.cpp b/src/test/ValentinaTest/tst_vdetail.cpp index 423b8da4c..15bb16b6a 100644 --- a/src/test/ValentinaTest/tst_vdetail.cpp +++ b/src/test/ValentinaTest/tst_vdetail.cpp @@ -59,27 +59,27 @@ void TST_VDetail::ClearLoop() data->UpdateGObject(203, new VPointF(642.96276692900597, 581.21895343695326, "С1", 88.99993700787401, 50.000125984251973)); - VSplinePath *path = new VSplinePath(); + QVector points; { const QSharedPointer point = data->GeometricObject(203); - VSplinePoint p(*point.data(), 0.79455646129695412, 449.62747641208136, 1.6867283804609809, 269.62747641208136); - path->append(p); + VFSplinePoint p(*point.data(), 0.79455646129695412, 449.62747641208136, 1.6867283804609809, 269.62747641208136); + points.append(p); } { const QSharedPointer point = data->GeometricObject(57); - VSplinePoint p(*point.data(), 0.4456850846354396, 120.24000000000034, 1.0255399999999999, 300.24000000000035); - path->append(p); + VFSplinePoint p(*point.data(), 0.4456850846354396, 120.24000000000034, 1.0255399999999999, 300.24000000000035); + points.append(p); } { const QSharedPointer point = data->GeometricObject(56); - VSplinePoint p(*point.data(), 1.0085299999999999, 184.58891, 1, 4.5889100000000003); - path->append(p); + VFSplinePoint p(*point.data(), 1.0085299999999999, 184.58891, 1, 4.5889100000000003); + points.append(p); } - data->UpdateGObject(308, path); + data->UpdateGObject(308, new VSplinePath(points)); data->UpdateGObject(309, new VPointF(799.45989815267649, 850.6707401574804, "Г8", -30.431206299212597, 29.487155905511813));