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

First build.

Browse Source 
--HG--
branch : feature
This commit is contained in:
dismine 2014-08-26 21:31:28 +03:00
parent 988be1732f
commit bdfd292386
67 changed files with 218 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/app/dialogs/app/dialoghistory.cpp
View File

@ -213,44 +213,44 @@ QString DialogHistory::Record(const VToolRecord &tool)
{
switch ( tool.getTypeTool() )
{
case Tool::ArrowTool:
case Tool::Arrow:
Q_UNREACHABLE();
break;
case Tool::SinglePointTool:
case Tool::SinglePoint:
{
return QString(tr("%1 - Base point")).arg(PointName(tool.getId()));
}
case Tool::EndLineTool:
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::LineTool:
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::AlongLineTool:
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::ShoulderPointTool:
case Tool::ShoulderPoint:
{
return QString(tr("%1 - Point of shoulder")).arg(PointName(tool.getId()));
}
case Tool::NormalTool:
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::BisectorTool:
case Tool::Bisector:
{
return QString(tr("%4 - bisector of angle %1_%2_%3"))
.arg(PointName(AttrUInt(domElem, VAbstractTool::AttrFirstPoint)))
@ -258,7 +258,7 @@ QString DialogHistory::Record(const VToolRecord &tool)
.arg(PointName(AttrUInt(domElem, VAbstractTool::AttrThirdPoint)))
.arg(PointName(tool.getId()));
}
case Tool::LineIntersectTool:
case Tool::LineIntersect:
{
return QString(tr("%5 - intersection of lines %1_%2 and %3_%4"))
.arg(PointName(AttrUInt(domElem, VAbstractTool::AttrP1Line1)))
@ -267,19 +267,19 @@ QString DialogHistory::Record(const VToolRecord &tool)
.arg(PointName(AttrUInt(domElem, VAbstractTool::AttrP2Line2)))
.arg(PointName(tool.getId()));
}
case Tool::SplineTool:
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::ArcTool:
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::SplinePathTool:
case Tool::SplinePath:
{
const QSharedPointer<VSplinePath> splPath = data->GeometricObject<VSplinePath>(tool.getId());
SCASSERT(splPath != nullptr);
@ -331,7 +331,7 @@ QString DialogHistory::Record(const VToolRecord &tool)
.arg(PointName(AttrUInt(domElem, VAbstractTool::AttrFirstPoint)))
.arg(PointName(AttrUInt(domElem, VAbstractTool::AttrSecondPoint)));
}
case Tool::CutArcTool:
case Tool::CutArc:
{
const QSharedPointer<VArc> arc = data->GeometricObject<VArc>(AttrUInt(domElem, VToolCutArc::AttrArc));
SCASSERT(arc != nullptr);
@ -339,7 +339,7 @@ QString DialogHistory::Record(const VToolRecord &tool)
.arg(PointName(tool.getId()))
.arg(PointName(arc->GetCenter().id()));
}
case Tool::CutSplineTool:
case Tool::CutSpline:
{
const quint32 splineId = AttrUInt(domElem, VToolCutSpline::AttrSpline);
const QSharedPointer<VSpline> spl = data->GeometricObject<VSpline>(splineId);
@ -349,7 +349,7 @@ QString DialogHistory::Record(const VToolRecord &tool)
.arg(PointName(spl->GetP1().id()))
.arg(PointName(spl->GetP4().id()));
}
case Tool::CutSplinePathTool:
case Tool::CutSplinePath:
{
const quint32 splinePathId = AttrUInt(domElem, VToolCutSplinePath::AttrSplinePath);
const QSharedPointer<VSplinePath> splPath = data->GeometricObject<VSplinePath>(splinePathId);
@ -375,7 +375,7 @@ QString DialogHistory::Record(const VToolRecord &tool)
}
//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::DetailTool:
case Tool::Detail:
break;
case Tool::UnionDetails:
break;

66
src/app/mainwindow.cpp
View File

@ -61,7 +61,7 @@
* @param parent parent widget.
*/
MainWindow::MainWindow(QWidget *parent)
:QMainWindow(parent), ui(new Ui::MainWindow), pattern(nullptr), doc(nullptr), tool(Tool::ArrowTool),
:QMainWindow(parent), ui(new Ui::MainWindow), pattern(nullptr), doc(nullptr), tool(Tool::Arrow),
currentScene(nullptr), sceneDraw(nullptr), sceneDetails(nullptr), mouseCoordinate(nullptr), helpLabel(nullptr),
isInitialized(false), dialogTable(nullptr), dialogTool(nullptr), dialogHistory(nullptr),
comboBoxDraws(nullptr), curFile(QString()), mode(Draw::Calculation), currentDrawIndex(0),
@ -202,7 +202,7 @@ void MainWindow::ActionNewPP()
QHash<quint32, VDataTool*>* tools = doc->getTools();
SCASSERT(tools != nullptr);
tools->insert(id, spoint);
VDrawTool::AddRecord(id, Tool::SinglePointTool, doc);
VDrawTool::AddRecord(id, Tool::SinglePoint, doc);
SetEnableTool(true);
SetEnableWidgets(true);
@ -387,7 +387,7 @@ void MainWindow::ApplyDialog()
*/
void MainWindow::ToolEndLine(bool checked)
{
SetToolButtonWithApply<DialogEndLine>(checked, Tool::EndLineTool, ":/cursor/endline_cursor.png", tr("Select point"),
SetToolButtonWithApply<DialogEndLine>(checked, Tool::EndLine, ":/cursor/endline_cursor.png", tr("Select point"),
&MainWindow::ClosedDialogWithApply<VToolEndLine>,
&MainWindow::ApplyDialog<VToolEndLine>);
}
@ -399,7 +399,7 @@ void MainWindow::ToolEndLine(bool checked)
*/
void MainWindow::ToolLine(bool checked)
{
SetToolButtonWithApply<DialogLine>(checked, Tool::LineTool, ":/cursor/line_cursor.png", tr("Select first point"),
SetToolButtonWithApply<DialogLine>(checked, Tool::Line, ":/cursor/line_cursor.png", tr("Select first point"),
&MainWindow::ClosedDialogWithApply<VToolLine>,
&MainWindow::ApplyDialog<VToolLine>);
}
@ -411,7 +411,7 @@ void MainWindow::ToolLine(bool checked)
*/
void MainWindow::ToolAlongLine(bool checked)
{
SetToolButtonWithApply<DialogAlongLine>(checked, Tool::AlongLineTool, ":/cursor/alongline_cursor.png",
SetToolButtonWithApply<DialogAlongLine>(checked, Tool::AlongLine, ":/cursor/alongline_cursor.png",
tr("Select point"), &MainWindow::ClosedDialogWithApply<VToolAlongLine>,
&MainWindow::ApplyDialog<VToolAlongLine>);
}
@ -423,7 +423,7 @@ void MainWindow::ToolAlongLine(bool checked)
*/
void MainWindow::ToolShoulderPoint(bool checked)
{
SetToolButtonWithApply<DialogShoulderPoint>(checked, Tool::ShoulderPointTool, ":/cursor/shoulder_cursor.png",
SetToolButtonWithApply<DialogShoulderPoint>(checked, Tool::ShoulderPoint, ":/cursor/shoulder_cursor.png",
tr("Select point of shoulder"),
&MainWindow::ClosedDialogWithApply<VToolShoulderPoint>,
&MainWindow::ApplyDialog<VToolShoulderPoint>);
@ -436,7 +436,7 @@ void MainWindow::ToolShoulderPoint(bool checked)
*/
void MainWindow::ToolNormal(bool checked)
{
SetToolButtonWithApply<DialogNormal>(checked, Tool::NormalTool, ":/cursor/normal_cursor.png",
SetToolButtonWithApply<DialogNormal>(checked, Tool::Normal, ":/cursor/normal_cursor.png",
tr("Select first point of line"),
&MainWindow::ClosedDialogWithApply<VToolNormal>,
&MainWindow::ApplyDialog<VToolNormal>);
@ -449,7 +449,7 @@ void MainWindow::ToolNormal(bool checked)
*/
void MainWindow::ToolBisector(bool checked)
{
SetToolButtonWithApply<DialogBisector>(checked, Tool::BisectorTool, ":/cursor/bisector_cursor.png",
SetToolButtonWithApply<DialogBisector>(checked, Tool::Bisector, ":/cursor/bisector_cursor.png",
tr("Select first point of angle"),
&MainWindow::ClosedDialogWithApply<VToolBisector>,
&MainWindow::ApplyDialog<VToolBisector>);
@ -462,7 +462,7 @@ void MainWindow::ToolBisector(bool checked)
*/
void MainWindow::ToolLineIntersect(bool checked)
{
SetToolButtonWithApply<DialogLineIntersect>(checked, Tool::LineIntersectTool, ":/cursor/intersect_cursor.png",
SetToolButtonWithApply<DialogLineIntersect>(checked, Tool::LineIntersect, ":/cursor/intersect_cursor.png",
tr("Select first point of first line"),
&MainWindow::ClosedDialogWithApply<VToolLineIntersect>,
&MainWindow::ApplyDialog<VToolLineIntersect>);
@ -475,7 +475,7 @@ void MainWindow::ToolLineIntersect(bool checked)
*/
void MainWindow::ToolSpline(bool checked)
{
SetToolButtonWithApply<DialogSpline>(checked, Tool::SplineTool, ":/cursor/spline_cursor.png",
SetToolButtonWithApply<DialogSpline>(checked, Tool::Spline, ":/cursor/spline_cursor.png",
tr("Select first point curve"),
&MainWindow::ClosedDialogWithApply<VToolSpline>,
&MainWindow::ApplyDialog<VToolSpline>);
@ -488,7 +488,7 @@ void MainWindow::ToolSpline(bool checked)
*/
void MainWindow::ToolCutSpline(bool checked)
{
SetToolButton<DialogCutSpline>(checked, Tool::CutSplineTool, ":/cursor/spline_cut_point_cursor.png",
SetToolButton<DialogCutSpline>(checked, Tool::CutSpline, ":/cursor/spline_cut_point_cursor.png",
tr("Select simple curve"), &MainWindow::ClosedDialog<VToolCutSpline>);
}
@ -499,7 +499,7 @@ void MainWindow::ToolCutSpline(bool checked)
*/
void MainWindow::ToolArc(bool checked)
{
SetToolButtonWithApply<DialogArc>(checked, Tool::ArcTool, ":/cursor/arc_cursor.png",
SetToolButtonWithApply<DialogArc>(checked, Tool::Arc, ":/cursor/arc_cursor.png",
tr("Select point of center of arc"), &MainWindow::ClosedDialogWithApply<VToolArc>,
&MainWindow::ApplyDialog<VToolArc>);
}
@ -511,7 +511,7 @@ void MainWindow::ToolArc(bool checked)
*/
void MainWindow::ToolSplinePath(bool checked)
{
SetToolButton<DialogSplinePath>(checked, Tool::SplinePathTool, ":/cursor/splinepath_cursor.png",
SetToolButton<DialogSplinePath>(checked, Tool::SplinePath, ":/cursor/splinepath_cursor.png",
tr("Select point of curve path"), &MainWindow::ClosedDialog<VToolSplinePath>);
}
@ -522,7 +522,7 @@ void MainWindow::ToolSplinePath(bool checked)
*/
void MainWindow::ToolCutSplinePath(bool checked)
{
SetToolButton<DialogCutSplinePath>(checked, Tool::CutSplinePathTool,
SetToolButton<DialogCutSplinePath>(checked, Tool::CutSplinePath,
":/cursor/splinepath_cut_point_cursor.png", tr("Select curve path"),
&MainWindow::ClosedDialog<VToolCutSplinePath>);
}
@ -547,7 +547,7 @@ void MainWindow::ToolPointOfContact(bool checked)
*/
void MainWindow::ToolDetail(bool checked)
{
SetToolButton<DialogDetail>(checked, Tool::DetailTool, "://cursor/new_detail_cursor.png",
SetToolButton<DialogDetail>(checked, Tool::Detail, "://cursor/new_detail_cursor.png",
tr("Select points, arcs, curves clockwise."), &MainWindow::ClosedDialogDetail);
}
@ -636,7 +636,7 @@ void MainWindow::ClosedDialogUnionDetails(int result)
*/
void MainWindow::ToolCutArc(bool checked)
{
SetToolButtonWithApply<DialogCutArc>(checked, Tool::CutArcTool, ":/cursor/arc_cut_cursor.png",
SetToolButtonWithApply<DialogCutArc>(checked, Tool::CutArc, ":/cursor/arc_cut_cursor.png",
tr("Select arc"), &MainWindow::ClosedDialogWithApply<VToolCutArc>,
&MainWindow::ApplyDialog<VToolCutArc>);
}
@ -944,60 +944,60 @@ void MainWindow::CancelTool()
dialogTool = nullptr;
switch ( tool )
{
case Tool::ArrowTool:
case Tool::Arrow:
ui->actionArrowTool->setChecked(false);
helpLabel->setText("");
break;
case Tool::SinglePointTool:
case Tool::SinglePoint:
Q_UNREACHABLE();
//Nothing to do here because we can't create this tool from main window.
break;
case Tool::EndLineTool:
case Tool::EndLine:
ui->toolButtonEndLine->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::LineTool:
case Tool::Line:
ui->toolButtonLine->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearFocus();
break;
case Tool::AlongLineTool:
case Tool::AlongLine:
ui->toolButtonAlongLine->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::ShoulderPointTool:
case Tool::ShoulderPoint:
ui->toolButtonShoulderPoint->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::NormalTool:
case Tool::Normal:
ui->toolButtonNormal->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::BisectorTool:
case Tool::Bisector:
ui->toolButtonBisector->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::LineIntersectTool:
case Tool::LineIntersect:
ui->toolButtonLineIntersect->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::SplineTool:
case Tool::Spline:
ui->toolButtonSpline->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::ArcTool:
case Tool::Arc:
ui->toolButtonArc->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::SplinePathTool:
case Tool::SplinePath:
ui->toolButtonSplinePath->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
@ -1007,7 +1007,7 @@ void MainWindow::CancelTool()
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::DetailTool:
case Tool::Detail:
ui->toolButtonNewDetail->setChecked(false);
break;
case Tool::Height:
@ -1025,12 +1025,12 @@ void MainWindow::CancelTool()
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::CutSplineTool:
case Tool::CutSpline:
ui->toolButtonSplineCutPoint->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::CutSplinePathTool:
case Tool::CutSplinePath:
ui->toolButtonSplinePathCutPoint->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
@ -1040,7 +1040,7 @@ void MainWindow::CancelTool()
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::CutArcTool:
case Tool::CutArc:
ui->toolButtonArcCutPoint->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
@ -1063,7 +1063,7 @@ void MainWindow::ArrowTool()
{
CancelTool();
ui->actionArrowTool->setChecked(true);
tool = Tool::ArrowTool;
tool = Tool::Arrow;
QCursor cur(Qt::ArrowCursor);
ui->view->setCursor(cur);
helpLabel->setText("");

2
src/app/tools/drawTools/vabstractspline.h
View File

@ -40,6 +40,8 @@ public:
VAbstractSpline(VPattern *doc, VContainer *data, quint32 id, QGraphicsItem * parent = nullptr);
static const QString TagName;
virtual void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget = 0);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::AbstractSpline)};
public slots:
virtual void FullUpdateFromFile ();
void Disable(bool disable);

2
src/app/tools/drawTools/vtoolalongline.cpp
View File

@ -272,7 +272,7 @@ VToolAlongLine* VToolAlongLine::Create(const quint32 _id, const QString &pointNa
doc->UpdateToolData(id, data);
}
}
VDrawTool::AddRecord(id, Tool::AlongLineTool, doc);
VDrawTool::AddRecord(id, Tool::AlongLine, doc);
if (parse == Document::FullParse)
{
VToolAlongLine *point = new VToolAlongLine(doc, data, id, formula, firstPointId,

2
src/app/tools/drawTools/vtoolalongline.h
View File

@ -49,6 +49,8 @@ public:
const qreal &mx, const qreal &my, VMainGraphicsScene *scene, VPattern *doc,
VContainer *data, const Document &parse, const Source &typeCreation);
static const QString ToolType;
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::AlongLine)};
public slots:
virtual void FullUpdateFromFile();
virtual void SetFactor(qreal factor);

2
src/app/tools/drawTools/vtoolarc.cpp
View File

@ -149,7 +149,7 @@ VToolArc* VToolArc::Create(const quint32 _id, const quint32 &center, QString &ra
doc->UpdateToolData(id, data);
}
}
VDrawTool::AddRecord(id, Tool::ArcTool, doc);
VDrawTool::AddRecord(id, Tool::Arc, doc);
if (parse == Document::FullParse)
{
VToolArc *toolArc = new VToolArc(doc, data, id, typeCreation);

2
src/app/tools/drawTools/vtoolarc.h
View File

@ -46,6 +46,8 @@ public:
const Source &typeCreation);
static const QString TagName;
static const QString ToolType;
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::Arc)};
public slots:
virtual void FullUpdateFromFile();
protected:

2
src/app/tools/drawTools/vtoolbisector.cpp
View File

@ -196,7 +196,7 @@ VToolBisector* VToolBisector::Create(const quint32 _id, QString &formula, const
doc->UpdateToolData(id, data);
}
}
VDrawTool::AddRecord(id, Tool::BisectorTool, doc);
VDrawTool::AddRecord(id, Tool::Bisector, doc);
if (parse == Document::FullParse)
{
VToolBisector *point = new VToolBisector(doc, data, id, typeLine, formula, firstPointId, secondPointId,

2
src/app/tools/drawTools/vtoolbisector.h
View File

@ -53,6 +53,8 @@ public:
VPattern *doc, VContainer *data, const Document &parse,
const Source &typeCreation);
static const QString ToolType;
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::Bisector)};
public slots:
virtual void FullUpdateFromFile();
virtual void SetFactor(qreal factor);

2
src/app/tools/drawTools/vtoolcut.h
View File

@ -38,6 +38,8 @@ class VToolCut : public VToolPoint
public:
VToolCut(VPattern *doc, VContainer *data, const quint32 &id, const QString &formula, const quint32 &curveCutId,
const quint32 &curve1id, const quint32 &curve2id, QGraphicsItem * parent = nullptr);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::Cut)};
public slots:
virtual void ChangedActivDraw(const QString &newName);
virtual void CurveChoosed(quint32 id)=0;

2
src/app/tools/drawTools/vtoolcutarc.cpp
View File

@ -163,7 +163,7 @@ VToolCutArc* VToolCutArc::Create(const quint32 _id, const QString &pointName, QS
}
}
VDrawTool::AddRecord(id, Tool::CutArcTool, doc);
VDrawTool::AddRecord(id, Tool::CutArc, doc);
if (parse == Document::FullParse)
{
VToolCutArc *point = new VToolCutArc(doc, data, id, formula, arcId, arc1id, arc2id, typeCreation);

2
src/app/tools/drawTools/vtoolcutarc.h
View File

@ -48,6 +48,8 @@ public:
VContainer *data, const Document &parse, const Source &typeCreation);
static const QString ToolType;
static const QString AttrArc;
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::CutArc)};
public slots:
virtual void FullUpdateFromFile();
virtual void CurveChoosed(quint32 id);

2
src/app/tools/drawTools/vtoolcutspline.cpp
View File

@ -163,7 +163,7 @@ void VToolCutSpline::Create(const quint32 _id, const QString &pointName, QString
doc->UpdateToolData(id, data);
}
}
VDrawTool::AddRecord(id, Tool::CutSplineTool, doc);
VDrawTool::AddRecord(id, Tool::CutSpline, doc);
if (parse == Document::FullParse)
{
VToolCutSpline *point = new VToolCutSpline(doc, data, id, formula, splineId, spl1id, spl2id, typeCreation);

2
src/app/tools/drawTools/vtoolcutspline.h
View File

@ -49,6 +49,8 @@ public:
const Document &parse, const Source &typeCreation);
static const QString ToolType;
static const QString AttrSpline;
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::CutSpline)};
public slots:
virtual void FullUpdateFromFile();
virtual void CurveChoosed(quint32 id);

2
src/app/tools/drawTools/vtoolcutsplinepath.cpp
View File

@ -217,7 +217,7 @@ void VToolCutSplinePath::Create(const quint32 _id, const QString &pointName, QSt
}
}
VDrawTool::AddRecord(id, Tool::CutSplinePathTool, doc);
VDrawTool::AddRecord(id, Tool::CutSplinePath, doc);
if (parse == Document::FullParse)
{
VToolCutSplinePath *point = new VToolCutSplinePath(doc, data, id, formula, splinePathId, splPath1id,

2
src/app/tools/drawTools/vtoolcutsplinepath.h
View File

@ -50,6 +50,8 @@ public:
const Document &parse, const Source &typeCreation);
static const QString ToolType;
static const QString AttrSplinePath;
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::CutSplinePath)};
public slots:
virtual void FullUpdateFromFile();
virtual void CurveChoosed(quint32 id);

2
src/app/tools/drawTools/vtoolendline.cpp
View File

@ -154,7 +154,7 @@ VToolEndLine* VToolEndLine::Create(const quint32 _id, const QString &pointName,
doc->UpdateToolData(id, data);
}
}
VDrawTool::AddRecord(id, Tool::EndLineTool, doc);
VDrawTool::AddRecord(id, Tool::EndLine, doc);
if (parse == Document::FullParse)
{
VToolEndLine *point = new VToolEndLine(doc, data, id, typeLine, formulaLength, formulaAngle, basePointId,

2
src/app/tools/drawTools/vtoolendline.h
View File

@ -49,6 +49,8 @@ public:
const qreal &mx, const qreal &my, VMainGraphicsScene *scene, VPattern *doc,
VContainer *data, const Document &parse, const Source &typeCreation);
static const QString ToolType;
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::EndLine)};
public slots:
virtual void FullUpdateFromFile();
virtual void ShowContextMenu(QGraphicsSceneContextMenuEvent *event);

2
src/app/tools/drawTools/vtoolheight.h
View File

@ -50,6 +50,8 @@ public:
VContainer *data, const Document &parse, const Source &typeCreation);
static QPointF FindPoint(const QLineF &line, const QPointF &point);
static const QString ToolType;
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::Height)};
public slots:
virtual void FullUpdateFromFile();
virtual void ShowContextMenu(QGraphicsSceneContextMenuEvent *event);

2
src/app/tools/drawTools/vtoolline.cpp
View File

@ -147,7 +147,7 @@ VToolLine * VToolLine::Create(const quint32 &_id, const quint32 &firstPoint, con
doc->UpdateToolData(id, data);
}
}
VDrawTool::AddRecord(id, Tool::LineTool, doc);
VDrawTool::AddRecord(id, Tool::Line, doc);
if (parse == Document::FullParse)
{
VToolLine *line = new VToolLine(doc, data, id, firstPoint, secondPoint, typeLine, typeCreation);

2
src/app/tools/drawTools/vtoolline.h
View File

@ -48,6 +48,8 @@ public:
const Document &parse, const Source &typeCreation);
static const QString TagName;
virtual void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget = 0);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::Line)};
public slots:
virtual void FullUpdateFromFile();
virtual void ChangedActivDraw(const QString &newName);

2
src/app/tools/drawTools/vtoollineintersect.cpp
View File

@ -166,7 +166,7 @@ VToolLineIntersect* VToolLineIntersect::Create(const quint32 _id, const quint32
doc->UpdateToolData(id, data);
}
}
VDrawTool::AddRecord(id, Tool::LineIntersectTool, doc);
VDrawTool::AddRecord(id, Tool::LineIntersect, doc);
if (parse == Document::FullParse)
{
VToolLineIntersect *point = new VToolLineIntersect(doc, data, id, p1Line1Id, p2Line1Id, p1Line2Id,

2
src/app/tools/drawTools/vtoollineintersect.h
View File

@ -48,6 +48,8 @@ public:
const qreal &mx, const qreal &my, VMainGraphicsScene *scene, VPattern *doc,
VContainer *data, const Document &parse, const Source &typeCreation);
static const QString ToolType;
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::LineIntersect)};
public slots:
virtual void FullUpdateFromFile();
virtual void SetFactor(qreal factor);

2
src/app/tools/drawTools/vtoollinepoint.h
View File

@ -40,6 +40,8 @@ class VToolLinePoint : public VToolPoint
public:
VToolLinePoint(VPattern *doc, VContainer *data, const quint32 &id, const QString &typeLine, const QString &formula,
const quint32 &basePointId, const qreal &angle, QGraphicsItem * parent = nullptr);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::LinePoint)};
public slots:
virtual void ChangedActivDraw(const QString &newName);
virtual void SetFactor(qreal factor);

2
src/app/tools/drawTools/vtoolnormal.cpp
View File

@ -157,7 +157,7 @@ VToolNormal* VToolNormal::Create(const quint32 _id, QString &formula, const quin
doc->UpdateToolData(id, data);
}
}
VDrawTool::AddRecord(id, Tool::NormalTool, doc);
VDrawTool::AddRecord(id, Tool::Normal, doc);
if (parse == Document::FullParse)
{
VToolNormal *point = new VToolNormal(doc, data, id, typeLine, formula, angle,

2
src/app/tools/drawTools/vtoolnormal.h
View File

@ -50,6 +50,8 @@ public:
static QPointF FindPoint(const QPointF &firstPoint, const QPointF &secondPoint, const qreal &length,
const qreal &angle = 0);
static const QString ToolType;
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::Normal)};
public slots:
virtual void FullUpdateFromFile();
virtual void SetFactor(qreal factor);

2
src/app/tools/drawTools/vtoolpointofcontact.h
View File

@ -51,6 +51,8 @@ public:
const qreal &mx, const qreal &my, VMainGraphicsScene *scene, VPattern *doc,
VContainer *data, const Document &parse, const Source &typeCreation);
static const QString ToolType;
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::PointOfContact) };
public slots:
virtual void FullUpdateFromFile();
virtual void SetFactor(qreal factor);

2
src/app/tools/drawTools/vtoolpointofintersection.h
View File

@ -49,6 +49,8 @@ public:
VMainGraphicsScene *scene, VPattern *doc, VContainer *data,
const Document &parse, const Source &typeCreation);
static const QString ToolType;
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::PointOfIntersection) };
public slots:
virtual void FullUpdateFromFile();
virtual void ShowContextMenu(QGraphicsSceneContextMenuEvent *event);

2
src/app/tools/drawTools/vtoolshoulderpoint.cpp
View File

@ -199,7 +199,7 @@ VToolShoulderPoint* VToolShoulderPoint::Create(const quint32 _id, QString &formu
doc->UpdateToolData(id, data);
}
}
VDrawTool::AddRecord(id, Tool::ShoulderPointTool, doc);
VDrawTool::AddRecord(id, Tool::ShoulderPoint, doc);
if (parse == Document::FullParse)
{
VToolShoulderPoint *point = new VToolShoulderPoint(doc, data, id, typeLine, formula,

2
src/app/tools/drawTools/vtoolshoulderpoint.h
View File

@ -51,6 +51,8 @@ public:
const qreal &mx, const qreal &my, VMainGraphicsScene *scene, VPattern *doc,
VContainer *data, const Document &parse, const Source &typeCreation);
static const QString ToolType;
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::ShoulderPoint) };
public slots:
virtual void FullUpdateFromFile();
virtual void SetFactor(qreal factor);

18
src/app/tools/drawTools/vtoolsinglepoint.cpp
View File

@ -82,6 +82,24 @@ void VToolSinglePoint::setDialog()
dialogTool->setData(p->name(), p->toQPointF());
}
//---------------------------------------------------------------------------------------------------------------------
QString VToolSinglePoint::name() const
{
return VAbstractTool::data.GeometricObject<VPointF>(id)->name();
}
//---------------------------------------------------------------------------------------------------------------------
void VToolSinglePoint::setName(const QString &name)
{
}
//---------------------------------------------------------------------------------------------------------------------
int VToolSinglePoint::type() const
{
return Type;
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief AddToFile add tag with informations about tool into file.

4
src/app/tools/drawTools/vtoolsinglepoint.h
View File

@ -43,6 +43,10 @@ public:
const QString &namePP, const QString &mPath, QGraphicsItem * parent = nullptr );
virtual void setDialog();
static const QString ToolType;
QString name() const;
void setName(const QString &name);
virtual int type()const;
enum { Type = UserType + static_cast<int>(Tool::SinglePoint)};
public slots:
virtual void FullUpdateFromFile();
virtual void ChangedActivDraw(const QString &newName);

2
src/app/tools/drawTools/vtoolspline.cpp
View File

@ -172,7 +172,7 @@ VToolSpline* VToolSpline::Create(const quint32 _id, const quint32 &p1, const qui
doc->UpdateToolData(id, data);
}
}
VDrawTool::AddRecord(id, Tool::SplineTool, doc);
VDrawTool::AddRecord(id, Tool::Spline, doc);
if (parse == Document::FullParse)
{
VToolSpline *spl = new VToolSpline(doc, data, id, typeCreation);

2
src/app/tools/drawTools/vtoolspline.h
View File

@ -48,6 +48,8 @@ public:
VMainGraphicsScene *scene, VPattern *doc, VContainer *data,
const Document &parse, const Source &typeCreation);
static const QString ToolType;
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::Spline)};
public slots:
void ControlPointChangePosition (const qint32 &indexSpline, const SplinePointPosition &position,
const QPointF &pos);

2
src/app/tools/drawTools/vtoolsplinepath.cpp
View File

@ -146,7 +146,7 @@ void VToolSplinePath::Create(const quint32 _id, VSplinePath *path, VMainGraphics
doc->UpdateToolData(id, data);
}
}
VDrawTool::AddRecord(id, Tool::SplinePathTool, doc);
VDrawTool::AddRecord(id, Tool::SplinePath, doc);
if (parse == Document::FullParse)
{
VToolSplinePath *spl = new VToolSplinePath(doc, data, id, typeCreation);

2
src/app/tools/drawTools/vtoolsplinepath.h
View File

@ -46,6 +46,8 @@ public:
VContainer *data, const Document &parse, const Source &typeCreation);
static const QString ToolType;
static void UpdatePathPoint(VPattern *doc, QDomNode& node, const VSplinePath &path);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::SplinePath)};
signals:
/**
* @brief RefreshLine refresh control line.

2
src/app/tools/drawTools/vtooltriangle.h
View File

@ -51,6 +51,8 @@ public:
static QPointF FindPoint(const QPointF &axisP1, const QPointF &axisP2, const QPointF &firstPoint,
const QPointF &secondPoint);
static const QString ToolType;
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::Triangle)};
public slots:
virtual void FullUpdateFromFile();
virtual void ShowContextMenu(QGraphicsSceneContextMenuEvent *event);

2
src/app/tools/nodeDetails/vnodearc.h
View File

@ -49,6 +49,8 @@ public:
static const QString ToolType;
virtual void DeleteNode();
virtual void RestoreNode();
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::NodeArc)};
public slots:
virtual void FullUpdateFromFile();
protected:

2
src/app/tools/nodeDetails/vnodepoint.h
View File

@ -55,6 +55,8 @@ public:
static const QString ToolType;
virtual void DeleteNode();
virtual void RestoreNode();
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::NodePoint)};
public slots:
virtual void FullUpdateFromFile();
void NameChangePosition(const QPointF &pos);

2
src/app/tools/nodeDetails/vnodespline.h
View File

@ -49,6 +49,8 @@ public:
static const QString ToolType;
virtual void DeleteNode();
virtual void RestoreNode();
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::NodeSpline)};
public slots:
virtual void FullUpdateFromFile ();
protected:

2
src/app/tools/nodeDetails/vnodesplinepath.h
View File

@ -48,6 +48,8 @@ public:
static const QString ToolType;
virtual void DeleteNode();
virtual void RestoreNode();
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::SplinePath)};
public slots:
virtual void FullUpdateFromFile();
protected:

2
src/app/tools/vtooldetail.cpp
View File

@ -216,7 +216,7 @@ void VToolDetail::Create(const quint32 &_id, const VDetail &newDetail, VMainGrap
doc->UpdateToolData(id, data);
}
}
VAbstractTool::AddRecord(id, Tool::DetailTool, doc);
VAbstractTool::AddRecord(id, Tool::Detail, doc);
if (parse == Document::FullParse)
{
VToolDetail *detail = new VToolDetail(doc, data, id, typeCreation, scene);

2
src/app/tools/vtooldetail.h
View File

@ -82,6 +82,8 @@ public:
static const QString NodeSplinePath;
void Remove(bool ask);
static void AddNode(VPattern *doc, QDomElement &domElement, const VNodeDetail &node);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Tool::Detail)};
public slots:
virtual void FullUpdateFromFile ();
virtual void FullUpdateFromGuiOk(int result);

2
src/app/visualization/vcontrolpointspline.h
View File

@ -43,6 +43,8 @@ public:
VControlPointSpline(const qint32 &indexSpline, SplinePointPosition position, const QPointF &controlPoint,
const QPointF &splinePoint, QGraphicsItem * parent = nullptr);
virtual void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget = 0);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::ControlPointSpline)};
signals:
/**
* @brief ControlPointChangePosition emit when control point change position.

3
src/app/visualization/vgraphicssimpletextitem.h
View File

@ -31,6 +31,7 @@
#include <QGraphicsSimpleTextItem>
#include <QObject>
#include "../options.h"
/**
* @brief The VGraphicsSimpleTextItem class pointer label.
@ -44,6 +45,8 @@ public:
qint32 FontSize()const;
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::GraphicsSimpleTextItem)};
signals:
/**
* @brief NameChangePosition emit when label change position.

2
src/app/visualization/visline.h
View File

@ -42,6 +42,8 @@ public:
VisLine(const VContainer *data, QGraphicsItem *parent = 0);
virtual ~VisLine();
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::Line)};
protected:
QLineF Line(const QPointF &p1, const qreal& length, const qreal &angle);
qreal CorrectAngle(const qreal &angle) const;

2
src/app/visualization/vispath.h
View File

@ -39,6 +39,8 @@ public:
VisPath(const VContainer *data, QGraphicsItem *parent = 0);
virtual ~VisPath();
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::Path)};
protected:
virtual void InitPen();
virtual void AddOnScene();

2
src/app/visualization/vistoolalongline.h
View File

@ -43,6 +43,8 @@ public:
virtual void RefreshGeometry();
void setPoint2Id(const quint32 &value);
void setLength(const QString &expression);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::ToolAlongLine)};
private:
Q_DISABLE_COPY(VisToolAlongLine)
quint32 point2Id;

2
src/app/visualization/vistoolarc.h
View File

@ -43,6 +43,8 @@ public:
void setRadius(const QString &expression);
void setF1(const QString &expression);
void setF2(const QString &expression);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::ToolArc)};
private:
Q_DISABLE_COPY(VisToolArc)
QGraphicsEllipseItem *arcCenter;

2
src/app/visualization/vistoolbisector.h
View File

@ -42,6 +42,8 @@ public:
void setPoint2Id(const quint32 &value);
void setPoint3Id(const quint32 &value);
void setLength(const QString &expression);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::ToolBisector)};
private:
Q_DISABLE_COPY(VisToolBisector)
quint32 point2Id;

2
src/app/visualization/vistoolcutarc.h
View File

@ -40,6 +40,8 @@ public:
virtual void RefreshGeometry();
void setLength(const QString &expression);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::ToolCutArc)};
protected:
Q_DISABLE_COPY(VisToolCutArc)
QGraphicsEllipseItem *point;

2
src/app/visualization/vistoolendline.h
View File

@ -44,6 +44,8 @@ public:
QString Angle() const;
void setAngle(const QString &expression);
void setLength(const QString &expression);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::ToolEndLine)};
private:
Q_DISABLE_COPY(VisToolEndLine)
qreal length;

2
src/app/visualization/vistoolheight.h
View File

@ -42,6 +42,8 @@ public:
void setLineP1Id(const quint32 &value);
void setLineP2Id(const quint32 &value);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::ToolHeight)};
private:
Q_DISABLE_COPY(VisToolHeight)
//base point in parent class

2
src/app/visualization/vistoolline.h
View File

@ -40,6 +40,8 @@ public:
virtual void RefreshGeometry();
void setPoint2Id(const quint32 &value);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::ToolLine)};
private:
Q_DISABLE_COPY(VisToolLine)
quint32 point2Id;

2
src/app/visualization/vistoollineintersect.h
View File

@ -43,6 +43,8 @@ public:
void setLine1P2Id(const quint32 &value);
void setLine2P1Id(const quint32 &value);
void setLine2P2Id(const quint32 &value);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::ToolLineIntersect)};
private:
Q_DISABLE_COPY(VisToolLineIntersect)
quint32 line1P2Id;

2
src/app/visualization/vistoolnormal.h
View File

@ -44,6 +44,8 @@ public:
void setLength(const QString &expression);
qreal getAngle() const;
void setAngle(const qreal &value);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::ToolNormal)};
private:
Q_DISABLE_COPY(VisToolNormal)
quint32 point2Id;

2
src/app/visualization/vistoolpointofcontact.h
View File

@ -42,6 +42,8 @@ public:
void setLineP2Id(const quint32 &value);
void setRadiusId(const quint32 &value);
void setRadius(const QString &expression);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::ToolPointOfContact)};
private:
Q_DISABLE_COPY(VisToolPointOfContact)
quint32 lineP2Id;

2
src/app/visualization/vistoolpointofintersection.h
View File

@ -41,6 +41,8 @@ public:
virtual void RefreshGeometry();
void setPoint2Id(const quint32 &value);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::ToolPointOfIntersection)};
private:
Q_DISABLE_COPY(VisToolPointOfIntersection)
quint32 point2Id;

2
src/app/visualization/vistoolshoulderpoint.h
View File

@ -42,6 +42,8 @@ public:
void setLineP1Id(const quint32 &value);
void setLineP2Id(const quint32 &value);
void setLength(const QString &expression);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::ToolShoulderPoint)};
private:
Q_DISABLE_COPY(VisToolShoulderPoint)
quint32 lineP1Id;

3
src/app/visualization/vistoolspline.h
View File

@ -46,6 +46,9 @@ public:
void setKAsm1(const qreal &value);
void setKAsm2(const qreal &value);
void setKCurve(const qreal &value);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::ToolSpline)};
protected:
Q_DISABLE_COPY(VisToolSpline)
quint32 point4Id;

3
src/app/visualization/vistooltriangle.h
View File

@ -43,6 +43,9 @@ public:
void setPoint2Id(const quint32 &value);
void setHypotenuseP1Id(const quint32 &value);
void setHypotenuseP2Id(const quint32 &value);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::ToolTriangle)};
private:
Q_DISABLE_COPY(VisToolTriangle)
quint32 point2Id;//axis second point

3
src/app/visualization/vsimplecurve.h
View File

@ -45,6 +45,9 @@ public:
qreal *factor = nullptr, QObject *parent = 0);
void ChangedActivDraw(const bool &flag);
virtual void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget = 0);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::SimpleCurvePoint)};
signals:
/**
* @brief Choosed send id when clicked.

3
src/app/visualization/vsimplesplinepath.h
View File

@ -42,6 +42,9 @@ class VSimpleSplinePath : public VAbstractTool, public QGraphicsPathItem
public:
VSimpleSplinePath(VPattern *doc, VContainer *data, quint32 id, qreal *factor);
virtual void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget = 0);
virtual int type() const {return Type;}
enum { Type = UserType + static_cast<int>(Vis::SimpleSplinePath)};
protected:
virtual void mouseReleaseEvent ( QGraphicsSceneMouseEvent * event );
virtual void hoverMoveEvent ( QGraphicsSceneHoverEvent * event );

16
src/app/widgets/vtooloptionspropertybrowser.cpp
View File

@ -46,18 +46,20 @@ VToolOptionsPropertyBrowser::VToolOptionsPropertyBrowser(QDockWidget *parent)
idToProperty(QMap<QString, VProperty *>())
{
PropertyModel = new VPropertyModel(this);
TreeView = new VPropertyFormView(PropertyModel);
TreeView = new VPropertyFormView(PropertyModel, parent);
TreeView->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
QScrollArea *scroll = new QScrollArea();
QScrollArea *scroll = new QScrollArea(parent);
scroll->setWidgetResizable(true);
scroll->setWidget(TreeView);
QHBoxLayout* layout = new QHBoxLayout();
parent->setLayout(layout);
layout->setSpacing(5);
layout->setMargin(0);
layout->addWidget(scroll);
// QLayout* layout = parent->layout();
// layout->setSpacing(5);
// layout->setMargin(0);
// layout->addWidget(scroll);
// parent->setLayout(layout);
parent->setWidget(scroll);
connect(PropertyModel, SIGNAL(onDataChangedByEditor(VProperty*)), this, SLOT(userChangedData(VProperty*)));
}

34
src/app/xml/vpattern.cpp
View File

@ -1095,7 +1095,7 @@ void VPattern::ParsePointElement(VMainGraphicsScene *scene, QDomElement &domElem
const qreal y = qApp->toPixel(GetParametrDouble(domElement, VAbstractTool::AttrY, "10.0"));
data->UpdateGObject(id, new VPointF(x, y, name, mx, my));
VDrawTool::AddRecord(id, Tool::SinglePointTool, this);
VDrawTool::AddRecord(id, Tool::SinglePoint, this);
if (parse != Document::FullParse)
{
UpdateToolData(id, data);
@ -2424,40 +2424,40 @@ QRectF VPattern::ActiveDrawBoundingRect() const
{
switch ( tool.getTypeTool() )
{
case Tool::ArrowTool:
case Tool::Arrow:
Q_UNREACHABLE();
break;
case Tool::SinglePointTool:
case Tool::SinglePoint:
rec = ToolBoundingRect<VToolSinglePoint>(rec, tool.getId());
break;
case Tool::EndLineTool:
case Tool::EndLine:
rec = ToolBoundingRect<VToolEndLine>(rec, tool.getId());
break;
case Tool::LineTool:
case Tool::Line:
rec = ToolBoundingRect<VToolLine>(rec, tool.getId());
break;
case Tool::AlongLineTool:
case Tool::AlongLine:
rec = ToolBoundingRect<VToolAlongLine>(rec, tool.getId());
break;
case Tool::ShoulderPointTool:
case Tool::ShoulderPoint:
rec = ToolBoundingRect<VToolShoulderPoint>(rec, tool.getId());
break;
case Tool::NormalTool:
case Tool::Normal:
rec = ToolBoundingRect<VToolNormal>(rec, tool.getId());
break;
case Tool::BisectorTool:
case Tool::Bisector:
rec = ToolBoundingRect<VToolBisector>(rec, tool.getId());
break;
case Tool::LineIntersectTool:
case Tool::LineIntersect:
rec = ToolBoundingRect<VToolLineIntersect>(rec, tool.getId());
break;
case Tool::SplineTool:
case Tool::Spline:
rec = ToolBoundingRect<VToolSpline>(rec, tool.getId());
break;
case Tool::ArcTool:
case Tool::Arc:
rec = ToolBoundingRect<VToolArc>(rec, tool.getId());
break;
case Tool::SplinePathTool:
case Tool::SplinePath:
rec = ToolBoundingRect<VToolSplinePath>(rec, tool.getId());
break;
case Tool::PointOfContact:
@ -2472,18 +2472,18 @@ QRectF VPattern::ActiveDrawBoundingRect() const
case Tool::PointOfIntersection:
rec = ToolBoundingRect<VToolPointOfIntersection>(rec, tool.getId());
break;
case Tool::CutArcTool:
case Tool::CutArc:
rec = ToolBoundingRect<VToolCutArc>(rec, tool.getId());
break;
case Tool::CutSplineTool:
case Tool::CutSpline:
rec = ToolBoundingRect<VToolCutSpline>(rec, tool.getId());
break;
case Tool::CutSplinePathTool:
case Tool::CutSplinePath:
rec = ToolBoundingRect<VToolCutSplinePath>(rec, tool.getId());
break;
//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::DetailTool:
case Tool::Detail:
break;
case Tool::UnionDetails:
break;

2
src/app/xml/vtoolrecord.cpp
View File

@ -33,7 +33,7 @@
* @brief VToolRecord default constructor.
*/
VToolRecord::VToolRecord()
:id(NULL_ID), typeTool(Tool::ArrowTool), nameDraw(QString())
:id(NULL_ID), typeTool(Tool::Arrow), nameDraw(QString())
{}
//---------------------------------------------------------------------------------------------------------------------

11
src/libs/vpropertyexplorer/vpropertyexplorer.pro
View File

@ -15,6 +15,15 @@ CONFIG += c++11
DEFINES += VPROPERTYEXPLORER_LIBRARY
# directory for executable file
DESTDIR = bin
# files created moc
MOC_DIR = moc
# objecs files
OBJECTS_DIR = obj
SOURCES += \
vproperty.cpp \
vpropertydelegate.cpp \
@ -78,3 +87,5 @@ unix {
target.path = /usr/lib
INSTALLS += target
}
QMAKE_CXXFLAGS += -gdwarf-3