Example #1
0
/**
 * @brief AddToNewDetail create united detail adding one node per time.
 * @param tool tool that make union.
 * @param doc dom document container.
 * @param data container with variables.
 * @param newDetail united detail.
 * @param det detail what we union.
 * @param i index node in detail.
 * @param idTool id tool union details.
 * @param dx bias node x axis.
 * @param dy bias node y axis.
 * @param pRotate point rotation.
 * @param angle angle rotation.
 */
void VToolUnionDetails::AddToNewDetail(QObject *tool, VPattern *doc, VContainer *data, VDetail &newDetail,
                                       const VDetail &det, const int &i, const quint32 &idTool, const qreal &dx,
                                       const qreal &dy, const quint32 &pRotate, const qreal &angle)
{
    quint32 id = 0, idObject = 0;
    switch (det.at(i).getTypeTool())
    {
        case (Tool::NodePoint):
        {
            if ( qFuzzyCompare(dx+1, 1) && qFuzzyCompare(dy+1, 1) && (pRotate == 0))
            {
                id = det.at(i).getId();
            }
            else
            {
                VPointF *point = new VPointF(*data->GeometricObject<VPointF>(det.at(i).getId()));
                point->setMode(Draw::Modeling);
                BiasRotatePoint(point, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(),
                                angle);
                idObject = data->AddGObject(point);
                VPointF *point1 = new VPointF(*point);
                point1->setMode(Draw::Modeling);
                id = data->AddGObject(point1);
                VNodePoint::Create(doc, data, id, idObject, Document::FullParse, Source::FromGui, idTool, tool);
            }
        }
        break;
        case (Tool::NodeArc):
        {
            if (qFuzzyCompare(dx+1, 1) && qFuzzyCompare(dy+1, 1) && pRotate == 0)
            {
                id = det.at(i).getId();
            }
            else
            {
                const QSharedPointer<VArc> arc = data->GeometricObject<VArc>(det.at(i).getId());
                VPointF p1 = VPointF(arc->GetP1(), "A", 0, 0);
                BiasRotatePoint(&p1, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(), angle);
                VPointF p2 = VPointF(arc->GetP2(), "A", 0, 0);
                BiasRotatePoint(&p2, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(), angle);
                VPointF *center = new VPointF(arc->GetCenter());
                BiasRotatePoint(center, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(),
                                angle);

                QLineF l1(center->toQPointF(), p1.toQPointF());
                QLineF l2(center->toQPointF(), p2.toQPointF());
                center->setMode(Draw::Modeling);
                quint32 idCenter = data->AddGObject(center);
                Q_UNUSED(idCenter);
                VArc *arc1 = new VArc(*center, arc->GetRadius(), arc->GetFormulaRadius(),
                                 l1.angle(), QString().setNum(l1.angle()), l2.angle(),
                                 QString().setNum(l2.angle()));
                arc1->setMode(Draw::Modeling);
                idObject = data->AddGObject(arc1);

                VArc *arc2 = new VArc(*arc1);
                arc2->setMode(Draw::Modeling);
                id = data->AddGObject(arc2);

                VNodeArc::Create(doc, data, id, idObject, Document::FullParse, Source::FromGui, idTool, tool);
            }
        }
        break;
        case (Tool::NodeSpline):
        {
            if (qFuzzyCompare(dx+1, 1) && qFuzzyCompare(dy+1, 1) && pRotate == 0)
            {
                id = det.at(i).getId();
            }
            else
            {
                const QSharedPointer<VSpline> spline = data->GeometricObject<VSpline>(det.at(i).getId());

                VPointF *p1 = new VPointF(spline->GetP1());
                BiasRotatePoint(p1, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(), angle);
                //quint32 idP1 = data->AddGObject(p1);

                VPointF p2 = VPointF(spline->GetP2());
                BiasRotatePoint(&p2, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(), angle);

                VPointF p3 = VPointF(spline->GetP3());
                BiasRotatePoint(&p3, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(), angle);

                VPointF *p4 = new VPointF(spline->GetP4());
                BiasRotatePoint(p4, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(), angle);
                //quint32 idP4 = data->AddGObject(p4);

                VSpline *spl = new VSpline(*p1, p2.toQPointF(), p3.toQPointF(), *p4, spline->GetKcurve(), 0,
                Draw::Modeling);
                idObject = data->AddGObject(spl);

                VSpline *spl1 = new VSpline(*spl);
                spl1->setMode(Draw::Modeling);
                id = data->AddGObject(spl1);
                VNodeSpline::Create(doc, data, id, idObject, Document::FullParse, Source::FromGui, idTool, tool);

                delete p4;
                delete p1;
            }
        }
        break;
        case (Tool::NodeSplinePath):
        {
            if (qFuzzyCompare(dx+1, 1) && qFuzzyCompare(dy+1, 1) && pRotate == 0)
            {
                id = det.at(i).getId();
            }
            else
            {
                VSplinePath *path = new VSplinePath();
                path->setMode(Draw::Modeling);
                const QSharedPointer<VSplinePath> splinePath = data->GeometricObject<VSplinePath>(det.at(i).getId());
                qint32 k = splinePath->getMaxCountPoints();
                for (qint32 i = 1; i <= splinePath->Count(); ++i)
                {
                    VSpline spline(splinePath->at(i-1).P(), splinePath->at(i).P(),
                            splinePath->at(i-1).Angle2(), splinePath->at(i).Angle1(), splinePath->at(i-1).KAsm2(),
                            splinePath->at(i).KAsm1(), splinePath->getKCurve());

                    VPointF *p1 = new VPointF(spline.GetP1());
                    BiasRotatePoint(p1, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(),
                                    angle);
                    //quint32 idP1 = data->AddGObject(p1);
                    --k;

                    VPointF p2 = VPointF(spline.GetP2());
                    BiasRotatePoint(&p2, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(),
                                    angle);

                    VPointF p3 = VPointF(spline.GetP3());
                    BiasRotatePoint(&p3, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(),
                                    angle);

                    VPointF *p4 = new VPointF(spline.GetP4());
                    BiasRotatePoint(p4, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(),
                                    angle);
                    //quint32 idP4 = data->AddGObject(p4);
                    --k;

                    VSpline spl = VSpline(*p1, p2.toQPointF(), p3.toQPointF(), *p4, spline.GetKcurve());
                    if (i==1)
                    {
                        path->append(VSplinePoint(*p1, splinePath->at(i-1).KAsm1(), spl.GetAngle1()+180,
                                                  splinePath->at(i-1).KAsm2(), spl.GetAngle1()));
                    }
                    path->append(VSplinePoint(*p4, splinePath->at(i).KAsm1(), spl.GetAngle2(),
                                              splinePath->at(i).KAsm2(), spl.GetAngle2()+180));
                    delete p4;
                    delete p1;
                }
                while (k>=0)
                {
                    data->getNextId();
                    --k;
                }
                idObject = data->AddGObject(path);

                VSplinePath *path1 = new VSplinePath(*path);
                path1->setMode(Draw::Modeling);
                id = data->AddGObject(path1);
                VNodeSplinePath::Create(doc, data, id, idObject, Document::FullParse, Source::FromGui, idTool, tool);
            }
        }
        break;
        default:
            qDebug()<<"May be wrong tool type!!! Ignoring."<<Q_FUNC_INFO;
            break;
    }
    newDetail.append(VNodeDetail(id, det.at(i).getTypeTool(), NodeDetail::Contour));
}
Example #2
0
/**
 * @brief Record return description for record
 * @param tool record data
 * @return description
 */
QString DialogHistory::Record(const VToolRecord &tool)
{
    const QDomElement domElem = doc->elementById(QString().setNum(tool.getId()));
    if (domElem.isElement() == false)
    {
        qDebug()<<"Can't find element by id"<<Q_FUNC_INFO;
        return QString(tr("Can't create record."));
    }
    try
    {
        switch ( tool.getTypeTool() )
        {
            case Tool::Arrow:
                Q_UNREACHABLE();
                break;
            case Tool::SinglePoint:
            {
                return QString(tr("%1 - Base point")).arg(PointName(tool.getId()));
            }
            case Tool::EndLine:
            {
                return QString(tr("%1_%2 - Line from point %1 to point %2"))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrBasePoint)))
                        .arg(PointName(tool.getId()));
            }
            case Tool::Line:
            {
                return QString(tr("%1_%2 - Line from point %1 to point %2"))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrFirstPoint)))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrSecondPoint)));
            }
            case Tool::AlongLine:
            {
                return QString(tr("%3 - Point along line %1_%2"))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrFirstPoint)))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrSecondPoint)))
                        .arg(PointName(tool.getId()));
            }
            case Tool::ShoulderPoint:
            {
                return QString(tr("%1 - Point of shoulder")).arg(PointName(tool.getId()));
            }
            case Tool::Normal:
            {
                return QString(tr("%3 - normal to line %1_%2"))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrFirstPoint)))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrSecondPoint)))
                        .arg(PointName(tool.getId()));
            }
            case Tool::Bisector:
            {
                return QString(tr("%4 - bisector of angle %1_%2_%3"))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrFirstPoint)))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrSecondPoint)))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrThirdPoint)))
                        .arg(PointName(tool.getId()));
            }
            case Tool::LineIntersect:
            {
                return QString(tr("%5 - intersection of lines %1_%2 and %3_%4"))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrP1Line1)))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrP2Line1)))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrP1Line2)))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrP2Line2)))
                        .arg(PointName(tool.getId()));
            }
            case Tool::Spline:
            {
                const QSharedPointer<VSpline> spl = data->GeometricObject<VSpline>(tool.getId());
                SCASSERT(spl != nullptr);
                return QString(tr("Curve %1_%2")).arg(PointName(spl->GetP1().id())).arg(PointName(spl->GetP4().id()));
            }
            case Tool::Arc:
            {
                const QSharedPointer<VArc> arc = data->GeometricObject<VArc>(tool.getId());
                SCASSERT(arc != nullptr);
                return QString(tr("Arc with center in point %1")).arg(PointName(arc->GetCenter().id()));
            }
            case Tool::SplinePath:
            {
                const QSharedPointer<VSplinePath> splPath = data->GeometricObject<VSplinePath>(tool.getId());
                SCASSERT(splPath != nullptr);
                const QVector<VSplinePoint> points = splPath->GetSplinePath();
                QString record;
                if (points.size() != 0 )
                {
                    // We use only first and last point name in curve
                    record = QString(tr("Curve point %1")).arg(PointName(points.at(0).P().id()));
                    if (points.size() > 1)
                    {
                        record.append(QString("_%1").arg(PointName(points.last().P().id())));
                    }
                }
                else
                {
                    qDebug()<<"Not enough points in splinepath"<<Q_FUNC_INFO;
                    return QString(tr("Can't create record."));
                }
                return record;
            }
            case Tool::PointOfContact:
            {
                return QString(tr("%4 - point of contact of arc with the center in point %1 and line %2_%3"))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrCenter)))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrFirstPoint)))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrSecondPoint)))
                        .arg(PointName(tool.getId()));
            }
            case Tool::Height:
            {
                return QString(tr("Point of perpendicular from point %1 to line %2_%3"))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrBasePoint)))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrP1Line)))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrP2Line)));
            }
            case Tool::Triangle:
            {
                return QString(tr("Triangle: axis %1_%2, points %3 and %4"))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrAxisP1)))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrAxisP2)))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrFirstPoint)))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrSecondPoint)));
            }
            case Tool::PointOfIntersection:
            {
                return QString(tr("%1 - point of intersection %2 and %3"))
                        .arg(PointName(tool.getId()))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrFirstPoint)))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrSecondPoint)));
            }
            case Tool::CutArc:
            {
                const QSharedPointer<VArc> arc = data->GeometricObject<VArc>(AttrUInt(domElem, VToolCutArc::AttrArc));
                SCASSERT(arc != nullptr);
                return QString(tr("%1 - cut arc with center %2"))
                        .arg(PointName(tool.getId()))
                        .arg(PointName(arc->GetCenter().id()));
            }
            case Tool::CutSpline:
            {
                const quint32 splineId = AttrUInt(domElem, VToolCutSpline::AttrSpline);
                const QSharedPointer<VSpline> spl = data->GeometricObject<VSpline>(splineId);
                SCASSERT(spl != nullptr);
                return QString(tr("%1 - cut curve %2_%3"))
                        .arg(PointName(tool.getId()))
                        .arg(PointName(spl->GetP1().id()))
                        .arg(PointName(spl->GetP4().id()));
            }
            case Tool::CutSplinePath:
            {
                const quint32 splinePathId = AttrUInt(domElem, VToolCutSplinePath::AttrSplinePath);
                const QSharedPointer<VSplinePath> splPath = data->GeometricObject<VSplinePath>(splinePathId);
                SCASSERT(splPath != nullptr);
                const QVector<VSplinePoint> points = splPath->GetSplinePath();
                QString record;
                if (points.size() != 0 )
                {
                    record = QString(tr("%1 - cut curve path %2"))
                            .arg(PointName(tool.getId()))
                            .arg(PointName(points.at(0).P().id()));
                    if (points.size() > 1)
                    {
                        record.append(QString("_%1").arg(PointName(points.last().P().id())));
                    }
                }
                else
                {
                    qDebug()<<"Not enough points in splinepath"<<Q_FUNC_INFO;
                    return QString(tr("Can't create record."));
                }
                return record;
            }
            case Tool::LineIntersectAxis:
            {
                return QString(tr("%1 - point of intersection line %2_%3 and axis through point %4"))
                        .arg(PointName(tool.getId()))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrP1Line)))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrP2Line)))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrBasePoint)));
            }
            case Tool::CurveIntersectAxis:
            {
                return QString(tr("%1 - point of intersection curve and axis through point %2"))
                        .arg(PointName(tool.getId()))
                        .arg(PointName(AttrUInt(domElem, VAbstractTool::AttrBasePoint)));
            }
            //Because "history" not only show history of pattern, but help restore current data for each pattern's
            //piece, we need add record about details and nodes, but don't show them.
            case Tool::Detail:
                break;
            case Tool::UnionDetails:
                break;
            case Tool::NodeArc:
                break;
            case Tool::NodePoint:
                break;
            case Tool::NodeSpline:
                break;
            case Tool::NodeSplinePath:
                break;
            default:
                qDebug()<<"Got wrong tool type. Ignore.";
                return QString(tr("Can't create record."));
                break;
        }
    }
    catch (const VExceptionBadId &e)
    {
        qDebug()<<e.ErrorMessage()<<Q_FUNC_INFO;
        return QString(tr("Can't create record."));
    }
    return QString();
}
Example #3
0
/**
 * @brief UpdatePoints update data for united details.
 * @param idDetail id united detail.
 * @param data container with variables.
 * @param det detail what we union.
 * @param i index node in detail.
 * @param idCount count updated or created objects.
 * @param dx bias node x axis.
 * @param dy bias node y axis.
 * @param pRotate point rotation.
 * @param angle angle rotation.
 */
void VToolUnionDetails::UpdatePoints(const quint32 &idDetail, VContainer *data, const VDetail &det, const int &i,
                                     quint32 &idCount, const qreal &dx, const qreal &dy, const quint32 &pRotate,
                                     const qreal &angle)
{
    switch (det.at(i).getTypeTool())
    {
        case (Tool::NodePoint):
        {
            if (qFuzzyCompare(dx+1, 1) == false || qFuzzyCompare(dy+1, 1) == false || pRotate != 0)
            {
                VPointF *point = new VPointF(*data->GeometricObject<VPointF>(det.at(i).getId()));
                point->setMode(Draw::Modeling);
                BiasRotatePoint(point, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(), angle);
                ++idCount;
                data->UpdateGObject(idDetail+idCount, point);

                ++idCount;
            }
        }
        break;
        case (Tool::NodeArc):
        {
            if (qFuzzyCompare(dx+1, 1) == false || qFuzzyCompare(dy+1, 1) == false || pRotate != 0)
            {
                const QSharedPointer<VArc> arc = data->GeometricObject<VArc>(det.at(i).getId());
                VPointF p1 = VPointF(arc->GetP1());
                BiasRotatePoint(&p1, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(), angle);
                VPointF p2 = VPointF(arc->GetP2());
                BiasRotatePoint(&p2, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(), angle);
                VPointF *center = new VPointF(arc->GetCenter());
                BiasRotatePoint(center, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(),
                                angle);

                QLineF l1(center->toQPointF(), p1.toQPointF());
                QLineF l2(center->toQPointF(), p2.toQPointF());
                ++idCount;
                center->setMode(Draw::Modeling);
                data->UpdateGObject(idDetail+idCount, center);
                VArc *arc1 = new VArc(*center, arc->GetRadius(), arc->GetFormulaRadius(), l1.angle(),
                                     QString().setNum(l1.angle()), l2.angle(), QString().setNum(l2.angle()));
                arc1->setMode(Draw::Modeling);
                ++idCount;
                data->UpdateGObject(idDetail+idCount, arc1);

                ++idCount;
            }
        }
        break;
        case (Tool::NodeSpline):
        {
            if (qFuzzyCompare(dx+1, 1) == false || qFuzzyCompare(dy+1, 1) == false || pRotate != 0)
            {
                const QSharedPointer<VSpline> spline = data->GeometricObject<VSpline>(det.at(i).getId());

                VPointF *p1 = new VPointF(spline->GetP1());
                BiasRotatePoint(p1, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(), angle);
                ++idCount;
                data->UpdateGObject(idDetail+idCount, p1);

                VPointF p2 = VPointF(spline->GetP2());
                BiasRotatePoint(&p2, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(), angle);

                VPointF p3 = VPointF(spline->GetP3());
                BiasRotatePoint(&p3, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(), angle);

                VPointF *p4 = new VPointF(spline->GetP4());
                BiasRotatePoint(p4, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(), angle);
                ++idCount;
                data->UpdateGObject(idDetail+idCount, p4);

                VSpline *spl = new VSpline(*p1, p2.toQPointF(), p3.toQPointF(), *p4, spline->GetKcurve(), 0,
                Draw::Modeling);

                ++idCount;
                data->UpdateGObject(idDetail+idCount, spl);

                ++idCount;
            }
        }
        break;
        case (Tool::NodeSplinePath):
        {
            if (qFuzzyCompare(dx+1, 1) == false || qFuzzyCompare(dy+1, 1) == false || pRotate != 0)
            {
                VSplinePath *path = new VSplinePath();
                path->setMode(Draw::Modeling);
                const QSharedPointer<VSplinePath> splinePath = data->GeometricObject<VSplinePath>(det.at(i).getId());
                SCASSERT(splinePath != nullptr);
                qint32 k = splinePath->getMaxCountPoints();
                for (qint32 i = 1; i <= splinePath->Count(); ++i)
                {
                    VSpline spline(splinePath->at(i-1).P(), splinePath->at(i).P(),
                            splinePath->at(i-1).Angle2(), splinePath->at(i).Angle1(), splinePath->at(i-1).KAsm2(),
                            splinePath->at(i).KAsm1(), splinePath->getKCurve());

                    VPointF *p1 = new VPointF(spline.GetP1());
                    BiasRotatePoint(p1, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(),
                                    angle);
                    ++idCount;
                    data->UpdateGObject(idDetail+idCount, p1);
                    --k;

                    VPointF p2 = VPointF(spline.GetP2());
                    BiasRotatePoint(&p2, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(),
                                    angle);

                    VPointF p3 = VPointF(spline.GetP3());
                    BiasRotatePoint(&p3, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(),
                                    angle);

                    VPointF *p4 = new VPointF(spline.GetP4());
                    BiasRotatePoint(p4, dx, dy, data->GeometricObject<VPointF>(pRotate)->toQPointF(),
                                    angle);
                    ++idCount;
                    data->UpdateGObject(idDetail+idCount, p4);
                    --k;

                    VSpline spl = VSpline(*p1, p2.toQPointF(), p3.toQPointF(), *p4, spline.GetKcurve());
                    if (i==1)
                    {
                        path->append(VSplinePoint(*p1, splinePath->at(i-1).KAsm1(), spl.GetAngle1()+180,
                                                  splinePath->at(i-1).KAsm2(), spl.GetAngle1()));
                    }
                    path->append(VSplinePoint(*p4, splinePath->at(i).KAsm1(), spl.GetAngle2(),
                                              splinePath->at(i).KAsm2(), spl.GetAngle2()+180));
                }

                while (k>=0)
                {
                    data->getNextId();
                    --k;
                    ++idCount;
                }

                ++idCount;
                data->UpdateGObject(idDetail+idCount, path);

                ++idCount;
            }
        }
        break;
        default:
            qDebug()<<"May be wrong tool type!!! Ignoring."<<Q_FUNC_INFO;
            break;
    }
}