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

Merge with feature.

Browse Source 
--HG--
branch : develop
This commit is contained in:
Roman Telezhynskyi 2016-03-31 21:13:34 +03:00
commit 5c487b7b78
68 changed files with 981 additions and 269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

285
src/app/valentina/mainwindow.cpp
View File

@ -242,18 +242,11 @@ void MainWindow::AddPP(const QString &PPName)
ui->view->itemClicked(nullptr);//hide options previous tool
const QString label = doc->GenerateLabel(LabelType::NewPatternPiece);
const QPointF startPosition = StartPositionNewPP();
const quint32 id = pattern->AddGObject(new VPointF(startPosition.x(), startPosition.y(), label, 5, 10));
VToolBasePoint *spoint = new VToolBasePoint(doc, pattern, id, Source::FromGui, PPName);
sceneDraw->addItem(spoint);
VPointF *point = new VPointF(startPosition.x(), startPosition.y(), label, 5, 10);
auto spoint = VToolBasePoint::Create(0, PPName, point, sceneDraw, doc, pattern, Document::FullParse,
Source::FromGui);
ui->view->itemClicked(spoint);
connect(spoint, &VToolSinglePoint::ChoosedTool, sceneDraw, &VMainGraphicsScene::ChoosedItem);
connect(sceneDraw, &VMainGraphicsScene::DisableItem, spoint, &VToolBasePoint::Disable);
connect(sceneDraw, &VMainGraphicsScene::NewFactor, spoint, &VToolBasePoint::SetFactor);
connect(sceneDraw, &VMainGraphicsScene::EnableToolMove, spoint, &VToolBasePoint::EnableToolMove);
doc->AddTool(id, spoint);
VDrawTool::AddRecord(id, Tool::BasePoint, doc);
SetEnableTool(true);
SetEnableWidgets(true);
@ -308,9 +301,34 @@ void MainWindow::InitScenes()
currentScene = sceneDraw;
qApp->setCurrentScene(currentScene);
connect(this, &MainWindow::EnableItemMove, sceneDraw, &VMainGraphicsScene::EnableItemMove);
connect(this, &MainWindow::ItemsSelection, sceneDraw, &VMainGraphicsScene::ItemsSelection);
connect(this, &MainWindow::EnableLabelSelection, sceneDraw, &VMainGraphicsScene::ToggleLabelSelection);
connect(this, &MainWindow::EnablePointSelection, sceneDraw, &VMainGraphicsScene::TogglePointSelection);
connect(this, &MainWindow::EnableArcSelection, sceneDraw, &VMainGraphicsScene::ToggleArcSelection);
connect(this, &MainWindow::EnableSplineSelection, sceneDraw, &VMainGraphicsScene::ToggleSplineSelection);
connect(this, &MainWindow::EnableSplinePathSelection, sceneDraw, &VMainGraphicsScene::ToggleSplinePathSelection);
connect(this, &MainWindow::EnableLabelHover, sceneDraw, &VMainGraphicsScene::ToggleLabelHover);
connect(this, &MainWindow::EnablePointHover, sceneDraw, &VMainGraphicsScene::TogglePointHover);
connect(this, &MainWindow::EnableLineHover, sceneDraw, &VMainGraphicsScene::ToggleLineHover);
connect(this, &MainWindow::EnableArcHover, sceneDraw, &VMainGraphicsScene::ToggleArcHover);
connect(this, &MainWindow::EnableSplineHover, sceneDraw, &VMainGraphicsScene::ToggleSplineHover);
connect(this, &MainWindow::EnableSplinePathHover, sceneDraw, &VMainGraphicsScene::ToggleSplinePathHover);
connect(sceneDraw, &VMainGraphicsScene::mouseMove, this, &MainWindow::mouseMove);
sceneDetails = new VMainGraphicsScene();
connect(this, &MainWindow::EnableItemMove, sceneDetails, &VMainGraphicsScene::EnableItemMove);
connect(this, &MainWindow::EnableNodeLabelSelection, sceneDetails, &VMainGraphicsScene::ToggleNodeLabelSelection);
connect(this, &MainWindow::EnableNodePointSelection, sceneDetails, &VMainGraphicsScene::ToggleNodePointSelection);
connect(this, &MainWindow::EnableDetailSelection, sceneDetails, &VMainGraphicsScene::ToggleDetailSelection);
connect(this, &MainWindow::EnableNodeLabelHover, sceneDetails, &VMainGraphicsScene::ToggleNodeLabelHover);
connect(this, &MainWindow::EnableNodePointHover, sceneDetails, &VMainGraphicsScene::ToggleNodePointHover);
connect(this, &MainWindow::EnableDetailHover, sceneDetails, &VMainGraphicsScene::ToggleDetailHover);
connect(sceneDetails, &VMainGraphicsScene::mouseMove, this, &MainWindow::mouseMove);
ui->view->setScene(currentScene);
@ -689,6 +707,7 @@ void MainWindow::ApplyDialog()
*/
void MainWindow::ToolEndLine(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogEndLine>(checked, Tool::EndLine, ":/cursor/endline_cursor.png", tr("Select point"),
&MainWindow::ClosedDialogWithApply<VToolEndLine>,
&MainWindow::ApplyDialog<VToolEndLine>);
@ -701,6 +720,7 @@ void MainWindow::ToolEndLine(bool checked)
*/
void MainWindow::ToolLine(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogLine>(checked, Tool::Line, ":/cursor/line_cursor.png", tr("Select first point"),
&MainWindow::ClosedDialogWithApply<VToolLine>,
&MainWindow::ApplyDialog<VToolLine>);
@ -713,6 +733,7 @@ void MainWindow::ToolLine(bool checked)
*/
void MainWindow::ToolAlongLine(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogAlongLine>(checked, Tool::AlongLine, ":/cursor/alongline_cursor.png",
tr("Select point"), &MainWindow::ClosedDialogWithApply<VToolAlongLine>,
&MainWindow::ApplyDialog<VToolAlongLine>);
@ -725,6 +746,7 @@ void MainWindow::ToolAlongLine(bool checked)
*/
void MainWindow::ToolShoulderPoint(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogShoulderPoint>(checked, Tool::ShoulderPoint, ":/cursor/shoulder_cursor.png",
tr("Select point"),
&MainWindow::ClosedDialogWithApply<VToolShoulderPoint>,
@ -738,6 +760,7 @@ void MainWindow::ToolShoulderPoint(bool checked)
*/
void MainWindow::ToolNormal(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogNormal>(checked, Tool::Normal, ":/cursor/normal_cursor.png",
tr("Select first point of line"),
&MainWindow::ClosedDialogWithApply<VToolNormal>,
@ -751,6 +774,7 @@ void MainWindow::ToolNormal(bool checked)
*/
void MainWindow::ToolBisector(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogBisector>(checked, Tool::Bisector, ":/cursor/bisector_cursor.png",
tr("Select first point of angle"),
&MainWindow::ClosedDialogWithApply<VToolBisector>,
@ -764,6 +788,7 @@ void MainWindow::ToolBisector(bool checked)
*/
void MainWindow::ToolLineIntersect(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogLineIntersect>(checked, Tool::LineIntersect, ":/cursor/intersect_cursor.png",
tr("Select first point of first line"),
&MainWindow::ClosedDialogWithApply<VToolLineIntersect>,
@ -777,6 +802,7 @@ void MainWindow::ToolLineIntersect(bool checked)
*/
void MainWindow::ToolSpline(bool checked)
{
ToolSelectPointByPress();
SetToolButtonWithApply<DialogSpline>(checked, Tool::Spline, ":/cursor/spline_cursor.png",
tr("Select first point curve"),
&MainWindow::ClosedDialogWithApply<VToolSpline>,
@ -786,6 +812,7 @@ void MainWindow::ToolSpline(bool checked)
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolCubicBezier(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogCubicBezier>(checked, Tool::CubicBezier, ":/cursor/cubic_bezier_cursor.png",
tr("Select first curve point"),
&MainWindow::ClosedDialogWithApply<VToolCubicBezier>,
@ -799,6 +826,7 @@ void MainWindow::ToolCubicBezier(bool checked)
*/
void MainWindow::ToolCutSpline(bool checked)
{
ToolSelectSpline();
SetToolButtonWithApply<DialogCutSpline>(checked, Tool::CutSpline, ":/cursor/spline_cut_point_cursor.png",
tr("Select simple curve"),
&MainWindow::ClosedDialogWithApply<VToolCutSpline>,
@ -812,6 +840,7 @@ void MainWindow::ToolCutSpline(bool checked)
*/
void MainWindow::ToolArc(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogArc>(checked, Tool::Arc, ":/cursor/arc_cursor.png",
tr("Select point of center of arc"), &MainWindow::ClosedDialogWithApply<VToolArc>,
&MainWindow::ApplyDialog<VToolArc>);
@ -824,6 +853,7 @@ void MainWindow::ToolArc(bool checked)
*/
void MainWindow::ToolSplinePath(bool checked)
{
ToolSelectPointByPress();
SetToolButtonWithApply<DialogSplinePath>(checked, Tool::SplinePath, ":/cursor/splinepath_cursor.png",
tr("Select point of curve path"),
&MainWindow::ClosedDialogWithApply<VToolSplinePath>,
@ -833,6 +863,7 @@ void MainWindow::ToolSplinePath(bool checked)
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolCubicBezierPath(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogCubicBezierPath>(checked, Tool::CubicBezierPath,
":/cursor/cubic_bezier_path_cursor.png",
tr("Select point of cubic bezier path"),
@ -847,6 +878,7 @@ void MainWindow::ToolCubicBezierPath(bool checked)
*/
void MainWindow::ToolCutSplinePath(bool checked)
{
ToolSelectSplinePath();
SetToolButtonWithApply<DialogCutSplinePath>(checked, Tool::CutSplinePath,
":/cursor/splinepath_cut_point_cursor.png", tr("Select curve path"),
&MainWindow::ClosedDialogWithApply<VToolCutSplinePath>,
@ -860,6 +892,7 @@ void MainWindow::ToolCutSplinePath(bool checked)
*/
void MainWindow::ToolPointOfContact(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogPointOfContact>(checked, Tool::PointOfContact, ":/cursor/pointcontact_cursor.png",
tr("Select first point of line"),
&MainWindow::ClosedDialogWithApply<VToolPointOfContact>,
@ -873,6 +906,7 @@ void MainWindow::ToolPointOfContact(bool checked)
*/
void MainWindow::ToolDetail(bool checked)
{
ToolSelectAllObjects();
SetToolButton<DialogDetail>(checked, Tool::Detail, "://cursor/new_detail_cursor.png",
tr("Select points, arcs, curves clockwise."), &MainWindow::ClosedDialogDetail);
}
@ -899,6 +933,7 @@ void MainWindow::ClosedDialogDetail(int result)
*/
void MainWindow::ToolHeight(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogHeight>(checked, Tool::Height, ":/cursor/height_cursor.png", tr("Select base point"),
&MainWindow::ClosedDialogWithApply<VToolHeight>,
&MainWindow::ApplyDialog<VToolHeight>);
@ -911,6 +946,7 @@ void MainWindow::ToolHeight(bool checked)
*/
void MainWindow::ToolTriangle(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogTriangle>(checked, Tool::Triangle, ":/cursor/triangle_cursor.png",
tr("Select first point of axis"),
&MainWindow::ClosedDialogWithApply<VToolTriangle>,
@ -924,6 +960,7 @@ void MainWindow::ToolTriangle(bool checked)
*/
void MainWindow::ToolPointOfIntersection(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogPointOfIntersection>(checked, Tool::PointOfIntersection,
":/cursor/pointofintersect_cursor.png",
tr("Select point for X value (vertical)"),
@ -938,6 +975,7 @@ void MainWindow::ToolPointOfIntersection(bool checked)
*/
void MainWindow::ToolUnionDetails(bool checked)
{
ToolSelectDetail();
SetToolButton<DialogUnionDetails>(checked, Tool::UnionDetails, ":/cursor/union_cursor.png",
tr("Select detail"), &MainWindow::ClosedDialogUnionDetails);
}
@ -960,6 +998,7 @@ void MainWindow::ClosedDialogUnionDetails(int result)
*/
void MainWindow::ToolCutArc(bool checked)
{
ToolSelectArc();
SetToolButtonWithApply<DialogCutArc>(checked, Tool::CutArc, ":/cursor/arc_cut_cursor.png",
tr("Select arc"), &MainWindow::ClosedDialogWithApply<VToolCutArc>,
&MainWindow::ApplyDialog<VToolCutArc>);
@ -968,6 +1007,7 @@ void MainWindow::ToolCutArc(bool checked)
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolLineIntersectAxis(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogLineIntersectAxis>(checked, Tool::LineIntersectAxis,
":/cursor/line_intersect_axis_cursor.png",
tr("Select first point of line"),
@ -978,6 +1018,7 @@ void MainWindow::ToolLineIntersectAxis(bool checked)
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolCurveIntersectAxis(bool checked)
{
ToolSelectAllObjects();
SetToolButtonWithApply<DialogCurveIntersectAxis>(checked, Tool::CurveIntersectAxis,
":/cursor/curve_intersect_axis_cursor.png",
tr("Select curve"),
@ -988,6 +1029,7 @@ void MainWindow::ToolCurveIntersectAxis(bool checked)
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolArcIntersectAxis(bool checked)
{
ToolSelectAllObjects();
// Reuse ToolCurveIntersectAxis but with different cursor and tool tip
SetToolButtonWithApply<DialogCurveIntersectAxis>(checked, Tool::CurveIntersectAxis,
":/cursor/arc_intersect_axis_cursor.png",
@ -999,6 +1041,7 @@ void MainWindow::ToolArcIntersectAxis(bool checked)
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolPointOfIntersectionArcs(bool checked)
{
ToolSelectArc();
SetToolButtonWithApply<DialogPointOfIntersectionArcs>(checked, Tool::PointOfIntersectionArcs,
"://cursor/point_of_intersection_arcs.png",
tr("Select first an arc"),
@ -1009,6 +1052,7 @@ void MainWindow::ToolPointOfIntersectionArcs(bool checked)
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolPointOfIntersectionCircles(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogPointOfIntersectionCircles>(checked, Tool::PointOfIntersectionCircles,
"://cursor/point_of_intersection_circles.png",
tr("Select first circle center "),
@ -1019,6 +1063,7 @@ void MainWindow::ToolPointOfIntersectionCircles(bool checked)
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolPointOfIntersectionCurves(bool checked)
{
ToolSelectCurve();
SetToolButtonWithApply<DialogPointOfIntersectionCurves>(checked, Tool::PointOfIntersectionCurves,
"://cursor/intersection_curves_cursor.png",
tr("Select first curve"),
@ -1029,6 +1074,7 @@ void MainWindow::ToolPointOfIntersectionCurves(bool checked)
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolPointFromCircleAndTangent(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogPointFromCircleAndTangent>(checked, Tool::PointFromCircleAndTangent,
"://cursor/point_from_circle_and_tangent_cursor.png",
tr("Select point on tangent "),
@ -1039,6 +1085,7 @@ void MainWindow::ToolPointFromCircleAndTangent(bool checked)
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolPointFromArcAndTangent(bool checked)
{
ToolSelectPointArc();
SetToolButtonWithApply<DialogPointFromArcAndTangent>(checked, Tool::PointFromArcAndTangent,
"://cursor/point_from_arc_and_tangent_cursor.png",
tr("Select point on tangent "),
@ -1049,6 +1096,7 @@ void MainWindow::ToolPointFromArcAndTangent(bool checked)
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolArcWithLength(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogArcWithLength>(checked, Tool::ArcWithLength,
"://cursor/arc_with_length_cursor.png",
tr("Select point of the center of the arc"),
@ -1059,6 +1107,7 @@ void MainWindow::ToolArcWithLength(bool checked)
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolTrueDarts(bool checked)
{
ToolSelectPointByRelease();
SetToolButtonWithApply<DialogTrueDarts>(checked, Tool::TrueDarts,
"://cursor/true_darts_cursor.png",
tr("Select the first base line point"),
@ -1841,6 +1890,31 @@ void MainWindow::ArrowTool()
ui->actionStopTool->setEnabled(false);
currentTool = Tool::Arrow;
emit EnableItemMove(true);
emit ItemsSelection(SelectionType::ByMouseRelease);
// Only true for rubber band selection
emit EnableLabelSelection(true);
emit EnablePointSelection(false);
emit EnableArcSelection(false);
emit EnableSplineSelection(false);
emit EnableSplinePathSelection(false);
emit EnableNodeLabelSelection(true);
emit EnableNodePointSelection(true);
emit EnableDetailSelection(true);// Disable when done visualization details
// Hovering
emit EnableLabelHover(true);
emit EnablePointHover(true);
emit EnableLineHover(true);
emit EnableArcHover(true);
emit EnableSplineHover(true);
emit EnableSplinePathHover(true);
emit EnableNodeLabelHover(true);
emit EnableNodePointHover(true);
emit EnableDetailHover(true);
ui->view->AllowRubberBand(true);
QCursor cur(Qt::ArrowCursor);
ui->view->setCursor(cur);
helpLabel->setText("");
@ -4406,3 +4480,194 @@ bool MainWindow::IgnoreLocking(int error, const QString &path)
}
return true;
}
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolSelectPoint() const
{
// Only true for rubber band selection
emit EnableLabelSelection(false);
emit EnablePointSelection(false);
emit EnableArcSelection(false);
emit EnableSplineSelection(false);
emit EnableSplinePathSelection(false);
// Hovering
emit EnableLabelHover(true);
emit EnablePointHover(true);
emit EnableLineHover(false);
emit EnableArcHover(false);
emit EnableSplineHover(false);
emit EnableSplinePathHover(false);
ui->view->AllowRubberBand(false);
}
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolSelectPointByRelease() const
{
ToolSelectPoint();
emit ItemsSelection(SelectionType::ByMouseRelease);
}
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolSelectPointByPress() const
{
ToolSelectPoint();
emit ItemsSelection(SelectionType::ByMousePress);
}
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolSelectSpline() const
{
// Only true for rubber band selection
emit EnableLabelSelection(false);
emit EnablePointSelection(false);
emit EnableArcSelection(false);
emit EnableSplineSelection(false);
emit EnableSplinePathSelection(false);
// Hovering
emit EnableLabelHover(false);
emit EnablePointHover(false);
emit EnableLineHover(false);
emit EnableArcHover(false);
emit EnableSplineHover(true);
emit EnableSplinePathHover(false);
emit ItemsSelection(SelectionType::ByMouseRelease);
ui->view->AllowRubberBand(false);
}
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolSelectSplinePath() const
{
// Only true for rubber band selection
emit EnableLabelSelection(false);
emit EnablePointSelection(false);
emit EnableArcSelection(false);
emit EnableSplineSelection(false);
emit EnableSplinePathSelection(false);
// Hovering
emit EnableLabelHover(false);
emit EnablePointHover(false);
emit EnableLineHover(false);
emit EnableArcHover(false);
emit EnableSplineHover(false);
emit EnableSplinePathHover(true);
emit ItemsSelection(SelectionType::ByMouseRelease);
ui->view->AllowRubberBand(false);
}
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolSelectArc() const
{
// Only true for rubber band selection
emit EnableLabelSelection(false);
emit EnablePointSelection(false);
emit EnableArcSelection(false);
emit EnableSplineSelection(false);
emit EnableSplinePathSelection(false);
// Hovering
emit EnableLabelHover(false);
emit EnablePointHover(false);
emit EnableLineHover(false);
emit EnableArcHover(true);
emit EnableSplineHover(false);
emit EnableSplinePathHover(false);
emit ItemsSelection(SelectionType::ByMouseRelease);
ui->view->AllowRubberBand(false);
}
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolSelectPointArc() const
{
// Only true for rubber band selection
emit EnableLabelSelection(false);
emit EnablePointSelection(false);
emit EnableArcSelection(false);
emit EnableSplineSelection(false);
emit EnableSplinePathSelection(false);
// Hovering
emit EnableLabelHover(true);
emit EnablePointHover(true);
emit EnableLineHover(false);
emit EnableArcHover(true);
emit EnableSplineHover(false);
emit EnableSplinePathHover(false);
emit ItemsSelection(SelectionType::ByMouseRelease);
ui->view->AllowRubberBand(false);
}
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolSelectCurve() const
{
// Only true for rubber band selection
emit EnableLabelSelection(false);
emit EnablePointSelection(false);
emit EnableArcSelection(false);
emit EnableSplineSelection(false);
emit EnableSplinePathSelection(false);
// Hovering
emit EnableLabelHover(false);
emit EnablePointHover(false);
emit EnableLineHover(false);
emit EnableArcHover(true);
emit EnableSplineHover(true);
emit EnableSplinePathHover(true);
emit ItemsSelection(SelectionType::ByMouseRelease);
ui->view->AllowRubberBand(false);
}
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolSelectAllObjects() const
{
// Only true for rubber band selection
emit EnableLabelSelection(false);
emit EnablePointSelection(false);
emit EnableArcSelection(false);
emit EnableSplineSelection(false);
emit EnableSplinePathSelection(false);
// Hovering
emit EnableLabelHover(true);
emit EnablePointHover(true);
emit EnableLineHover(false);
emit EnableArcHover(true);
emit EnableSplineHover(true);
emit EnableSplinePathHover(true);
emit ItemsSelection(SelectionType::ByMouseRelease);
ui->view->AllowRubberBand(false);
}
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::ToolSelectDetail() const
{
// Only true for rubber band selection
emit EnableNodeLabelSelection(false);
emit EnableNodePointSelection(false);
emit EnableDetailSelection(true);// Disable when done visualization details
// Hovering
emit EnableNodeLabelHover(true);
emit EnableNodePointHover(true);
emit EnableDetailHover(true);
emit ItemsSelection(SelectionType::ByMouseRelease);
ui->view->AllowRubberBand(false);
}

31
src/app/valentina/mainwindow.h
View File

@ -157,6 +157,26 @@ public slots:
signals:
void RefreshHistory();
void EnableItemMove(bool move);
void ItemsSelection(SelectionType type) const;
void EnableLabelSelection(bool enable) const;
void EnablePointSelection(bool enable) const;
void EnableArcSelection(bool enable) const;
void EnableSplineSelection(bool enable) const;
void EnableSplinePathSelection(bool enable) const;
void EnableNodeLabelSelection(bool enable) const;
void EnableNodePointSelection(bool enable) const;
void EnableDetailSelection(bool enable) const;
void EnableLabelHover(bool enable) const;
void EnablePointHover(bool enable) const;
void EnableLineHover(bool enable) const;
void EnableArcHover(bool enable) const;
void EnableSplineHover(bool enable) const;
void EnableSplinePathHover(bool enable) const;
void EnableNodeLabelHover(bool enable) const;
void EnableNodePointHover(bool enable) const;
void EnableDetailHover(bool enable) const;
protected:
virtual void keyPressEvent(QKeyEvent *event) Q_DECL_OVERRIDE;
virtual void showEvent(QShowEvent *event) Q_DECL_OVERRIDE;
@ -331,6 +351,17 @@ private:
void UpdateWindowTitle();
bool IgnoreLocking(int error, const QString &path);
void ToolSelectPoint() const;
void ToolSelectPointByPress() const;
void ToolSelectPointByRelease() const;
void ToolSelectSpline() const;
void ToolSelectSplinePath() const;
void ToolSelectArc() const;
void ToolSelectPointArc() const;
void ToolSelectCurve() const;
void ToolSelectAllObjects() const;
void ToolSelectDetail() const;
};
#endif // MAINWINDOW_H

18
src/app/valentina/xml/vpattern.cpp
View File

@ -940,22 +940,8 @@ void VPattern::ParseToolBasePoint(VMainGraphicsScene *scene, const QDomElement &
const qreal x = qApp->toPixel(GetParametrDouble(domElement, AttrX, "10.0"));
const qreal y = qApp->toPixel(GetParametrDouble(domElement, AttrY, "10.0"));
data->UpdateGObject(id, new VPointF(x, y, name, mx, my));
VDrawTool::AddRecord(id, Tool::BasePoint, this);
if (parse != Document::FullParse)
{
UpdateToolData(id, data);
}
if (parse == Document::FullParse)
{
spoint = new VToolBasePoint(this, data, id, Source::FromFile, nameActivPP);
scene->addItem(spoint);
connect(spoint, &VToolBasePoint::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, spoint, &VToolBasePoint::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, spoint, &VToolBasePoint::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, spoint, &VToolBasePoint::EnableToolMove);
tools[id] = spoint;
}
VPointF *point = new VPointF(x, y, name, mx, my);
VToolBasePoint::Create(id, nameActivPP, point, scene, this, data, parse, Source::FromFile);
}
catch (const VExceptionBadId &e)
{

1
src/libs/vmisc/def.h
View File

@ -55,6 +55,7 @@ enum class MeasurementsType : char { Standard, Individual , Unknown};
enum class Unit : char { Mm = 0, Cm, Inch, Px, LAST_UNIT_DO_NOT_USE};
enum class Source : char { FromGui, FromFile, FromTool };
enum class NodeUsage : bool {NotInUse = false, InUse = true};
enum class SelectionType : bool {ByMousePress, ByMouseRelease};
typedef unsigned char ToolVisHolderType;
enum class Tool : ToolVisHolderType

43
src/libs/vtools/tools/drawTools/toolcurve/vabstractspline.cpp
View File

@ -38,25 +38,14 @@ const QString VAbstractSpline::TagName = QStringLiteral("spline");
VAbstractSpline::VAbstractSpline(VAbstractPattern *doc, VContainer *data, quint32 id, QGraphicsItem *parent)
:VDrawTool(doc, data, id), QGraphicsPathItem(parent), controlPoints(QVector<VControlPointSpline *>()),
sceneType(SceneObject::Unknown), isHovered(false), detailsMode(false)
{}
{
setAcceptHoverEvents(true);
}
//---------------------------------------------------------------------------------------------------------------------
VAbstractSpline::~VAbstractSpline()
{}
//---------------------------------------------------------------------------------------------------------------------
void VAbstractSpline::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
/* From question on StackOverflow
* https://stackoverflow.com/questions/10985028/how-to-remove-border-around-qgraphicsitem-when-selected
*
* There's no interface to disable the drawing of the selection border for the build-in QGraphicsItems. The only way
* I can think of is derive your own items from the build-in ones and override the paint() function:*/
QStyleOptionGraphicsItem myOption(*option);
myOption.state &= ~QStyle::State_Selected;
QGraphicsPathItem::paint(painter, &myOption, widget);
}
//---------------------------------------------------------------------------------------------------------------------
QString VAbstractSpline::getTagName() const
{
@ -92,6 +81,18 @@ void VAbstractSpline::DetailsMode(bool mode)
ShowHandles(detailsMode);
}
//---------------------------------------------------------------------------------------------------------------------
void VAbstractSpline::AllowHover(bool enabled)
{
setAcceptHoverEvents(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VAbstractSpline::AllowSelecting(bool enabled)
{
setFlag(QGraphicsItem::ItemIsSelectable, enabled);
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief ShowTool highlight tool.
@ -205,18 +206,26 @@ void VAbstractSpline::keyReleaseEvent(QKeyEvent *event)
QGraphicsItem::keyReleaseEvent ( event );
}
//---------------------------------------------------------------------------------------------------------------------
void VAbstractSpline::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
// Special for not selectable item first need to call standard mousePressEvent then accept event
QGraphicsPathItem::mousePressEvent(event);
event->accept();// Special for not selectable item first need to call standard mousePressEvent then accept event
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief mousePressEvent handle mouse press events.
* @brief mouseReleaseEvent handle mouse release events.
* @param event mouse release event.
*/
void VAbstractSpline::mousePressEvent(QGraphicsSceneMouseEvent *event)
void VAbstractSpline::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
if (event->button() == Qt::LeftButton)
{
emit ChoosedTool(id, sceneType);
}
QGraphicsPathItem::mousePressEvent(event);
QGraphicsPathItem::mouseReleaseEvent(event);
}
//---------------------------------------------------------------------------------------------------------------------

56
src/libs/vtools/tools/drawTools/toolcurve/vabstractspline.h
View File

@ -44,8 +44,6 @@ public:
virtual ~VAbstractSpline() Q_DECL_OVERRIDE;
// cppcheck-suppress duplInheritedMember
static const QString TagName;
virtual void paint(QPainter * painter, const QStyleOptionGraphicsItem * option,
QWidget * widget = 0) Q_DECL_OVERRIDE;
virtual int type() const Q_DECL_OVERRIDE {return Type;}
enum { Type = UserType + static_cast<int>(Tool::AbstractSpline)};
virtual QString getTagName() const Q_DECL_OVERRIDE;
@ -58,7 +56,10 @@ public:
public slots:
virtual void FullUpdateFromFile () Q_DECL_OVERRIDE;
virtual void Disable(bool disable, const QString &namePP) Q_DECL_OVERRIDE;
void DetailsMode(bool mode);
virtual void DetailsMode(bool mode) Q_DECL_OVERRIDE;
virtual void AllowHover(bool enabled) Q_DECL_OVERRIDE;
virtual void AllowSelecting(bool enabled) Q_DECL_OVERRIDE;
virtual void SetFactor(qreal factor) Q_DECL_OVERRIDE;
signals:
/**
* @brief setEnabledPoint disable control points.
@ -78,12 +79,12 @@ protected:
*/
virtual void RefreshGeometry ()=0;
virtual void ShowTool(quint32 id, bool enable) Q_DECL_OVERRIDE;
virtual void SetFactor(qreal factor) Q_DECL_OVERRIDE;
virtual void hoverEnterEvent ( QGraphicsSceneHoverEvent * event ) Q_DECL_OVERRIDE;
virtual void hoverLeaveEvent ( QGraphicsSceneHoverEvent * event ) Q_DECL_OVERRIDE;
virtual QVariant itemChange ( GraphicsItemChange change, const QVariant &value ) Q_DECL_OVERRIDE;
virtual void keyReleaseEvent(QKeyEvent * event) Q_DECL_OVERRIDE;
virtual void mousePressEvent ( QGraphicsSceneMouseEvent * event ) Q_DECL_OVERRIDE;
virtual void mousePressEvent(QGraphicsSceneMouseEvent *event) Q_DECL_OVERRIDE;
virtual void mouseReleaseEvent ( QGraphicsSceneMouseEvent * event ) Q_DECL_OVERRIDE;
QPainterPath ToolPath(PathDirection direction = PathDirection::Hide) const;
virtual void ReadToolAttributes(const QDomElement &domElement) Q_DECL_OVERRIDE;
virtual void SaveOptions(QDomElement &tag, QSharedPointer<VGObject> &obj) Q_DECL_OVERRIDE;
@ -93,6 +94,15 @@ protected:
template <typename T>
void ShowToolVisualization(bool show);
template <typename T>
static void InitSplineToolConnections(VMainGraphicsScene *scene, T *tool);
template <typename T>
static void InitSplinePathToolConnections(VMainGraphicsScene *scene, T *tool);
template <typename T>
static void InitArcToolConnections(VMainGraphicsScene *scene, T *tool);
private:
Q_DISABLE_COPY(VAbstractSpline)
};
@ -137,4 +147,40 @@ inline void VAbstractSpline::ShowToolVisualization(bool show)
}
}
//---------------------------------------------------------------------------------------------------------------------
template <typename T>
void VAbstractSpline::InitSplineToolConnections(VMainGraphicsScene *scene, T *tool)
{
SCASSERT(scene != nullptr);
SCASSERT(tool != nullptr);
InitDrawToolConnections(scene, tool);
QObject::connect(scene, &VMainGraphicsScene::EnableSplineItemHover, tool, &T::AllowHover);
QObject::connect(scene, &VMainGraphicsScene::EnableSplineItemSelection, tool, &T::AllowSelecting);
}
//---------------------------------------------------------------------------------------------------------------------
template <typename T>
void VAbstractSpline::InitSplinePathToolConnections(VMainGraphicsScene *scene, T *tool)
{
SCASSERT(scene != nullptr);
SCASSERT(tool != nullptr);
InitDrawToolConnections(scene, tool);
QObject::connect(scene, &VMainGraphicsScene::EnableSplinePathItemHover, tool, &T::AllowHover);
QObject::connect(scene, &VMainGraphicsScene::EnableSplinePathItemSelection, tool, &T::AllowSelecting);
}
//---------------------------------------------------------------------------------------------------------------------
template <typename T>
void VAbstractSpline::InitArcToolConnections(VMainGraphicsScene *scene, T *tool)
{
SCASSERT(scene != nullptr);
SCASSERT(tool != nullptr);
InitDrawToolConnections(scene, tool);
QObject::connect(scene, &VMainGraphicsScene::EnableArcItemHover, tool, &T::AllowHover);
QObject::connect(scene, &VMainGraphicsScene::EnableArcItemSelection, tool, &T::AllowSelecting);
}
#endif // VABSTRACTSPLINE_H

5
src/libs/vtools/tools/drawTools/toolcurve/vtoolarc.cpp
View File

@ -58,7 +58,6 @@ VToolArc::VToolArc(VAbstractPattern *doc, VContainer *data, quint32 id, const QS
this->setPath(ToolPath());
this->setPen(QPen(Qt::black, qApp->toPixel(WidthHairLine(*VAbstractTool::data.GetPatternUnit()))/factor));
this->setAcceptHoverEvents(true);
ToolCreation(typeCreation);
}
@ -154,9 +153,7 @@ VToolArc* VToolArc::Create(const quint32 _id, const quint32 &center, QString &ra
{
VToolArc *toolArc = new VToolArc(doc, data, id, color, typeCreation);
scene->addItem(toolArc);
connect(toolArc, &VToolArc::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, toolArc, &VToolArc::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, toolArc, &VToolArc::Disable);
InitArcToolConnections(scene, toolArc);
doc->AddTool(id, toolArc);
doc->IncrementReferens(c.getIdTool());
return toolArc;

5
src/libs/vtools/tools/drawTools/toolcurve/vtoolarcwithlength.cpp
View File

@ -49,7 +49,6 @@ VToolArcWithLength::VToolArcWithLength(VAbstractPattern *doc, VContainer *data,
this->setPath(ToolPath());
this->setPen(QPen(Qt::black, qApp->toPixel(WidthHairLine(*VAbstractTool::data.GetPatternUnit()))/factor));
this->setAcceptHoverEvents(true);
ToolCreation(typeCreation);
}
@ -123,9 +122,7 @@ VToolArcWithLength *VToolArcWithLength::Create(const quint32 _id, const quint32
{
VToolArcWithLength *toolArc = new VToolArcWithLength(doc, data, id, color, typeCreation);
scene->addItem(toolArc);
connect(toolArc, &VToolArcWithLength::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, toolArc, &VToolArcWithLength::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, toolArc, &VToolArcWithLength::Disable);
InitArcToolConnections(scene, toolArc);
doc->AddTool(id, toolArc);
doc->IncrementReferens(c.getIdTool());
return toolArc;

5
src/libs/vtools/tools/drawTools/toolcurve/vtoolcubicbezier.cpp
View File

@ -43,7 +43,6 @@ VToolCubicBezier::VToolCubicBezier(VAbstractPattern *doc, VContainer *data, quin
lineColor = color;
this->setPen(QPen(Qt::black, qApp->toPixel(WidthHairLine(*VAbstractTool::data.GetPatternUnit()))/factor));
this->setAcceptHoverEvents(true);
this->setPath(ToolPath());
ToolCreation(typeCreation);
@ -108,9 +107,7 @@ VToolCubicBezier *VToolCubicBezier::Create(const quint32 _id, VCubicBezier *spli
{
auto _spl = new VToolCubicBezier(doc, data, id, color, typeCreation);
scene->addItem(_spl);
connect(_spl, &VToolCubicBezier::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, _spl, &VToolCubicBezier::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, _spl, &VToolCubicBezier::Disable);
InitSplineToolConnections(scene, _spl);
doc->AddTool(id, _spl);
doc->IncrementReferens(spline->GetP1().getIdTool());
doc->IncrementReferens(spline->GetP1().getIdTool());

5
src/libs/vtools/tools/drawTools/toolcurve/vtoolcubicbezierpath.cpp
View File

@ -42,7 +42,6 @@ VToolCubicBezierPath::VToolCubicBezierPath(VAbstractPattern *doc, VContainer *da
this->setPath(ToolPath());
this->setPen(QPen(Qt::black, qApp->toPixel(WidthHairLine(*VAbstractTool::data.GetPatternUnit()))/factor));
this->setAcceptHoverEvents(true);
ToolCreation(typeCreation);
}
@ -109,9 +108,7 @@ VToolCubicBezierPath *VToolCubicBezierPath::Create(const quint32 _id, VCubicBezi
{
VToolCubicBezierPath *spl = new VToolCubicBezierPath(doc, data, id, color, typeCreation);
scene->addItem(spl);
connect(spl, &VToolCubicBezierPath::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, spl, &VToolCubicBezierPath::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, spl, &VToolCubicBezierPath::Disable);
InitSplinePathToolConnections(scene, spl);
doc->AddTool(id, spl);
return spl;
}

7
src/libs/vtools/tools/drawTools/toolcurve/vtoolspline.cpp
View File

@ -62,7 +62,6 @@ VToolSpline::VToolSpline(VAbstractPattern *doc, VContainer *data, quint32 id, co
this->setPen(QPen(Qt::black, qApp->toPixel(WidthHairLine(*VAbstractTool::data.GetPatternUnit()))/factor));
this->setFlag(QGraphicsItem::ItemIsMovable, true);
this->setAcceptHoverEvents(true);
this->setPath(ToolPath());
const auto spl = VAbstractTool::data.GeometricObject<VSpline>(id);
@ -179,11 +178,7 @@ VToolSpline* VToolSpline::Create(const quint32 _id, VSpline *spline, const QStri
{
auto _spl = new VToolSpline(doc, data, id, color, typeCreation);
scene->addItem(_spl);
connect(_spl, &VToolSpline::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, _spl, &VToolSpline::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, _spl, &VToolSpline::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, _spl, &VToolSpline::EnableToolMove);
connect(scene, &VMainGraphicsScene::CurveDetailsMode, _spl, &VToolSpline::DetailsMode);
InitSplineToolConnections(scene, _spl);
doc->AddTool(id, _spl);
doc->IncrementReferens(spline->GetP1().getIdTool());
doc->IncrementReferens(spline->GetP4().getIdTool());

7
src/libs/vtools/tools/drawTools/toolcurve/vtoolsplinepath.cpp
View File

@ -63,7 +63,6 @@ VToolSplinePath::VToolSplinePath(VAbstractPattern *doc, VContainer *data, quint3
this->setPath(ToolPath());
this->setPen(QPen(Qt::black, qApp->toPixel(WidthHairLine(*VAbstractTool::data.GetPatternUnit()))/factor));
this->setFlag(QGraphicsItem::ItemIsMovable, true);
this->setAcceptHoverEvents(true);
const QSharedPointer<VSplinePath> splPath = data->GeometricObject<VSplinePath>(id);
for (qint32 i = 1; i<=splPath->CountSubSpl(); ++i)
@ -183,11 +182,7 @@ VToolSplinePath* VToolSplinePath::Create(const quint32 _id, VSplinePath *path, c
{
VToolSplinePath *spl = new VToolSplinePath(doc, data, id, color, typeCreation);
scene->addItem(spl);
connect(spl, &VToolSplinePath::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, spl, &VToolSplinePath::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, spl, &VToolSplinePath::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, spl, &VToolSplinePath::EnableToolMove);
connect(scene, &VMainGraphicsScene::CurveDetailsMode, spl, &VToolSplinePath::DetailsMode);
InitSplinePathToolConnections(scene, spl);
doc->AddTool(id, spl);
return spl;
}

49
src/libs/vtools/tools/drawTools/toolpoint/tooldoublepoint/vtooldoublepoint.cpp
View File

@ -60,19 +60,6 @@ VToolDoublePoint::VToolDoublePoint(VAbstractPattern *doc, VContainer *data, quin
VToolDoublePoint::~VToolDoublePoint()
{}
//---------------------------------------------------------------------------------------------------------------------
void VToolDoublePoint::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
/* From question on StackOverflow
* https://stackoverflow.com/questions/10985028/how-to-remove-border-around-qgraphicsitem-when-selected
*
* There's no interface to disable the drawing of the selection border for the build-in QGraphicsItems. The only way
* I can think of is derive your own items from the build-in ones and override the paint() function:*/
QStyleOptionGraphicsItem myOption(*option);
myOption.state &= ~QStyle::State_Selected;
QGraphicsPathItem::paint(painter, &myOption, widget);
}
//---------------------------------------------------------------------------------------------------------------------
QString VToolDoublePoint::nameP1() const
{
@ -187,6 +174,42 @@ void VToolDoublePoint::DoChangePosition(quint32 id, qreal mx, qreal my)
}
}
//---------------------------------------------------------------------------------------------------------------------
void VToolDoublePoint::AllowHover(bool enabled)
{
firstPoint->setAcceptHoverEvents(enabled);
secondPoint->setAcceptHoverEvents(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VToolDoublePoint::AllowSelecting(bool enabled)
{
firstPoint->setFlag(QGraphicsItem::ItemIsSelectable, enabled);
secondPoint->setFlag(QGraphicsItem::ItemIsSelectable, enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VToolDoublePoint::AllowLabelHover(bool enabled)
{
firstPoint->AllowLabelHover(enabled);
secondPoint->AllowLabelHover(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VToolDoublePoint::AllowLabelSelecting(bool enabled)
{
firstPoint->AllowLabelSelecting(enabled);
secondPoint->AllowLabelSelecting(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VToolDoublePoint::ToolSelectionType(const SelectionType &type)
{
VAbstractTool::ToolSelectionType(type);
firstPoint->ToolSelectionType(type);
secondPoint->ToolSelectionType(type);
}
//---------------------------------------------------------------------------------------------------------------------
void VToolDoublePoint::UpdateNamePosition(quint32 id)
{

8
src/libs/vtools/tools/drawTools/toolpoint/tooldoublepoint/vtooldoublepoint.h
View File

@ -48,9 +48,6 @@ public:
virtual int type() const Q_DECL_OVERRIDE {return Type;}
enum { Type = UserType + static_cast<int>(Tool::DoublePoint)};
virtual void paint(QPainter * painter, const QStyleOptionGraphicsItem * option,
QWidget * widget = 0) Q_DECL_OVERRIDE;
QString nameP1() const;
void setNameP1(const QString &name);
@ -69,6 +66,11 @@ public slots:
void Point2Choosed();
virtual void FullUpdateFromFile() Q_DECL_OVERRIDE;
virtual void DoChangePosition(quint32 id, qreal mx, qreal my) Q_DECL_OVERRIDE;
virtual void AllowHover(bool enabled) Q_DECL_OVERRIDE;
virtual void AllowSelecting(bool enabled) Q_DECL_OVERRIDE;
void AllowLabelHover(bool enabled);
void AllowLabelSelecting(bool enabled);
virtual void ToolSelectionType(const SelectionType &type) Q_DECL_OVERRIDE;
protected:
VSimplePoint *firstPoint;

5
src/libs/vtools/tools/drawTools/toolpoint/tooldoublepoint/vtooltruedarts.cpp
View File

@ -172,10 +172,7 @@ VToolTrueDarts *VToolTrueDarts::Create(quint32 _id,
VToolTrueDarts *points = new VToolTrueDarts(doc, data, id, p1id, p2id, baseLineP1Id, baseLineP2Id,
dartP1Id, dartP2Id, dartP3Id, typeCreation);
scene->addItem(points);
connect(points, &VToolDoublePoint::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, points, &VToolTrueDarts::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, points, &VToolTrueDarts::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, points, &VToolTrueDarts::EnableToolMove);
InitToolConnections(scene, points);
doc->AddTool(id, points);
doc->IncrementReferens(baseLineP1->getIdTool());
doc->IncrementReferens(baseLineP2->getIdTool());

2
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/toolcut/vtoolcut.h
View File

@ -52,7 +52,7 @@ public:
public slots:
virtual void Disable(bool disable, const QString &namePP) Q_DECL_OVERRIDE;
void DetailsMode(bool mode);
virtual void DetailsMode(bool mode) Q_DECL_OVERRIDE;
virtual void FullUpdateFromFile() Q_DECL_OVERRIDE;
protected:
/** @brief formula keep formula of length */

5
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/toolcut/vtoolcutarc.cpp
View File

@ -163,10 +163,7 @@ VToolCutArc* VToolCutArc::Create(const quint32 _id, const QString &pointName, QS
{
VToolCutArc *point = new VToolCutArc(doc, data, id, formula, arcId, arc1id, arc2id, color, typeCreation);
scene->addItem(point);
connect(point, &VToolSinglePoint::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolCutArc::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolCutArc::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolCutArc::EnableToolMove);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->AddTool(arc1id, point);
doc->AddTool(arc2id, point);

6
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/toolcut/vtoolcutspline.cpp
View File

@ -170,11 +170,7 @@ VToolCutSpline* VToolCutSpline::Create(const quint32 _id, const QString &pointNa
VToolCutSpline *point = new VToolCutSpline(doc, data, id, formula, splineId, spl1id, spl2id, color,
typeCreation);
scene->addItem(point);
connect(point, &VToolSinglePoint::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolCutSpline::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolCutSpline::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolCutSpline::EnableToolMove);
connect(scene, &VMainGraphicsScene::CurveDetailsMode, point, &VToolCutSpline::DetailsMode);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->AddTool(spl1id, point);
doc->AddTool(spl2id, point);

6
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/toolcut/vtoolcutsplinepath.cpp
View File

@ -180,11 +180,7 @@ VToolCutSplinePath* VToolCutSplinePath::Create(const quint32 _id, const QString
VToolCutSplinePath *point = new VToolCutSplinePath(doc, data, id, formula, splinePathId, splPath1id,
splPath2id, color, typeCreation);
scene->addItem(point);
connect(point, &VToolSinglePoint::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolCutSplinePath::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolCutSplinePath::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolCutSplinePath::EnableToolMove);
connect(scene, &VMainGraphicsScene::CurveDetailsMode, point, &VToolCutSplinePath::DetailsMode);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->AddTool(splPath1id, point);
doc->AddTool(splPath2id, point);

5
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/toollinepoint/vtoolalongline.cpp
View File

@ -275,10 +275,7 @@ VToolAlongLine* VToolAlongLine::Create(const quint32 _id, const QString &pointNa
VToolAlongLine *point = new VToolAlongLine(doc, data, id, formula, firstPointId, secondPointId, typeLine,
lineColor, typeCreation);
scene->addItem(point);
connect(point, &VToolAlongLine::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolAlongLine::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolAlongLine::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolAlongLine::EnableToolMove);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->IncrementReferens(firstPoint->getIdTool());
doc->IncrementReferens(secondPoint->getIdTool());

5
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/toollinepoint/vtoolbisector.cpp
View File

@ -200,10 +200,7 @@ VToolBisector* VToolBisector::Create(const quint32 _id, QString &formula, const
VToolBisector *point = new VToolBisector(doc, data, id, typeLine, lineColor, formula, firstPointId,
secondPointId, thirdPointId, typeCreation);
scene->addItem(point);
connect(point, &VToolSinglePoint::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolBisector::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolBisector::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolBisector::EnableToolMove);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->IncrementReferens(firstPoint->getIdTool());
doc->IncrementReferens(secondPoint->getIdTool());

5
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/toollinepoint/vtoolcurveintersectaxis.cpp
View File

@ -129,10 +129,7 @@ VToolCurveIntersectAxis *VToolCurveIntersectAxis::Create(const quint32 _id, cons
VToolCurveIntersectAxis *point = new VToolCurveIntersectAxis(doc, data, id, typeLine, lineColor, formulaAngle,
basePointId, curveId, typeCreation);
scene->addItem(point);
connect(point, &VToolSinglePoint::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolCurveIntersectAxis::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolCurveIntersectAxis::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolCurveIntersectAxis::EnableToolMove);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->IncrementReferens(basePoint->getIdTool());
doc->IncrementReferens(curve->getIdTool());

5
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/toollinepoint/vtoolendline.cpp
View File

@ -165,10 +165,7 @@ VToolEndLine* VToolEndLine::Create(const quint32 _id, const QString &pointName,
VToolEndLine *point = new VToolEndLine(doc, data, id, typeLine, lineColor, formulaLength, formulaAngle,
basePointId, typeCreation);
scene->addItem(point);
connect(point, &VToolSinglePoint::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolEndLine::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolEndLine::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolEndLine::EnableToolMove);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->IncrementReferens(basePoint->getIdTool());
return point;

5
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/toollinepoint/vtoolheight.cpp
View File

@ -157,10 +157,7 @@ VToolHeight* VToolHeight::Create(const quint32 _id, const QString &pointName, co
VToolHeight *point = new VToolHeight(doc, data, id, typeLine, lineColor, basePointId, p1LineId, p2LineId,
typeCreation);
scene->addItem(point);
connect(point, &VToolSinglePoint::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolHeight::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolHeight::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolHeight::EnableToolMove);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->IncrementReferens(basePoint->getIdTool());
doc->IncrementReferens(p1Line->getIdTool());

5
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/toollinepoint/vtoollineintersectaxis.cpp
View File

@ -140,10 +140,7 @@ VToolLineIntersectAxis *VToolLineIntersectAxis::Create(const quint32 _id, const
basePointId, firstPointId, secondPointId,
typeCreation);
scene->addItem(point);
connect(point, &VToolSinglePoint::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolLineIntersectAxis::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolLineIntersectAxis::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolLineIntersectAxis::EnableToolMove);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->IncrementReferens(basePoint->getIdTool());
doc->IncrementReferens(firstPoint->getIdTool());

5
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/toollinepoint/vtoolnormal.cpp
View File

@ -160,10 +160,7 @@ VToolNormal* VToolNormal::Create(const quint32 _id, QString &formula, const quin
VToolNormal *point = new VToolNormal(doc, data, id, typeLine, lineColor, formula, angle, firstPointId,
secondPointId, typeCreation);
scene->addItem(point);
connect(point, &VToolNormal::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolNormal::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolNormal::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolNormal::EnableToolMove);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->IncrementReferens(firstPoint->getIdTool());
doc->IncrementReferens(secondPoint->getIdTool());

5
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/toollinepoint/vtoolshoulderpoint.cpp
View File

@ -204,10 +204,7 @@ VToolShoulderPoint* VToolShoulderPoint::Create(const quint32 _id, QString &formu
p1Line, p2Line, pShoulder,
typeCreation);
scene->addItem(point);
connect(point, &VToolShoulderPoint::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolShoulderPoint::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolShoulderPoint::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolShoulderPoint::EnableToolMove);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->IncrementReferens(firstPoint->getIdTool());
doc->IncrementReferens(secondPoint->getIdTool());

32
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/vtoolbasepoint.cpp
View File

@ -79,6 +79,38 @@ void VToolBasePoint::setDialog()
dialogTool->SetData(p->name(), p->toQPointF());
}
//---------------------------------------------------------------------------------------------------------------------
VToolBasePoint *VToolBasePoint::Create(quint32 _id, const QString &nameActivPP, VPointF *point,
VMainGraphicsScene *scene, VAbstractPattern *doc, VContainer *data,
const Document &parse, const Source &typeCreation)
{
SCASSERT(point != nullptr);
quint32 id = _id;
if (typeCreation == Source::FromGui)
{
id = data->AddGObject(point);
}
else
{
data->UpdateGObject(id, point);
if (parse != Document::FullParse)
{
doc->UpdateToolData(id, data);
}
}
VDrawTool::AddRecord(id, Tool::BasePoint, doc);
if (parse == Document::FullParse)
{
VToolBasePoint *spoint = new VToolBasePoint(doc, data, id, typeCreation, nameActivPP);
scene->addItem(spoint);
InitToolConnections(scene, spoint);
doc->AddTool(id, spoint);
return spoint;
}
return nullptr;
}
//---------------------------------------------------------------------------------------------------------------------
void VToolBasePoint::ShowVisualization(bool show)
{

3
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/vtoolbasepoint.h
View File

@ -43,6 +43,9 @@ public:
const QString &namePP, QGraphicsItem * parent = nullptr );
virtual ~VToolBasePoint() Q_DECL_OVERRIDE;
virtual void setDialog() Q_DECL_OVERRIDE;
static VToolBasePoint *Create(quint32 _id, const QString &nameActivPP, VPointF *point,
VMainGraphicsScene *scene, VAbstractPattern *doc, VContainer *data,
const Document &parse, const Source &typeCreation);
static const QString ToolType;
virtual int type() const Q_DECL_OVERRIDE {return Type;}
enum { Type = UserType + static_cast<int>(Tool::BasePoint)};

5
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/vtoollineintersect.cpp
View File

@ -164,10 +164,7 @@ VToolLineIntersect* VToolLineIntersect::Create(const quint32 _id, const quint32
VToolLineIntersect *point = new VToolLineIntersect(doc, data, id, p1Line1Id, p2Line1Id, p1Line2Id,
p2Line2Id, typeCreation);
scene->addItem(point);
connect(point, &VToolLineIntersect::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolLineIntersect::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolLineIntersect::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolLineIntersect::EnableToolMove);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->IncrementReferens(p1Line1->getIdTool());
doc->IncrementReferens(p2Line1->getIdTool());

5
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/vtoolpointfromarcandtangent.cpp
View File

@ -108,10 +108,7 @@ VToolPointFromArcAndTangent *VToolPointFromArcAndTangent::Create(const quint32 _
VToolPointFromArcAndTangent *point = new VToolPointFromArcAndTangent(doc, data, id, arcId, tangentPointId,
crossPoint, typeCreation);
scene->addItem(point);
connect(point, &VToolPointFromArcAndTangent::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolPointFromArcAndTangent::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolPointFromArcAndTangent::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolPointFromArcAndTangent::EnableToolMove);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->IncrementReferens(arc.getIdTool());
doc->IncrementReferens(tPoint.getIdTool());

5
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/vtoolpointfromcircleandtangent.cpp
View File

@ -118,10 +118,7 @@ VToolPointFromCircleAndTangent *VToolPointFromCircleAndTangent::Create(const qui
circleRadius, tangentPointId,
crossPoint, typeCreation);
scene->addItem(point);
connect(point, &VToolPointFromCircleAndTangent::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolPointFromCircleAndTangent::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolPointFromCircleAndTangent::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolPointFromCircleAndTangent::EnableToolMove);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->IncrementReferens(cPoint.getIdTool());
doc->IncrementReferens(tPoint.getIdTool());

5
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/vtoolpointofcontact.cpp
View File

@ -220,10 +220,7 @@ VToolPointOfContact* VToolPointOfContact::Create(const quint32 _id, QString &rad
VToolPointOfContact *point = new VToolPointOfContact(doc, data, id, radius, center,
firstPointId, secondPointId, typeCreation);
scene->addItem(point);
connect(point, &VToolPointOfContact::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolPointOfContact::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolPointOfContact::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolPointOfContact::EnableToolMove);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->IncrementReferens(centerP->getIdTool());
doc->IncrementReferens(firstP->getIdTool());

5
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/vtoolpointofintersection.cpp
View File

@ -141,10 +141,7 @@ VToolPointOfIntersection *VToolPointOfIntersection::Create(const quint32 _id, co
VToolPointOfIntersection *point = new VToolPointOfIntersection(doc, data, id, firstPointId,
secondPointId, typeCreation);
scene->addItem(point);
connect(point, &VToolPointOfIntersection::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolPointOfIntersection::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolPointOfIntersection::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolPointOfIntersection::EnableToolMove);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->IncrementReferens(firstPoint->getIdTool());
doc->IncrementReferens(secondPoint->getIdTool());

5
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/vtoolpointofintersectionarcs.cpp
View File

@ -109,10 +109,7 @@ VToolPointOfIntersectionArcs *VToolPointOfIntersectionArcs::Create(const quint32
VToolPointOfIntersectionArcs *point = new VToolPointOfIntersectionArcs(doc, data, id, firstArcId,
secondArcId, pType, typeCreation);
scene->addItem(point);
connect(point, &VToolPointOfIntersectionArcs::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolPointOfIntersectionArcs::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolPointOfIntersectionArcs::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolPointOfIntersectionArcs::EnableToolMove);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->IncrementReferens(firstArc->getIdTool());
doc->IncrementReferens(secondArc->getIdTool());

5
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/vtoolpointofintersectioncircles.cpp
View File

@ -130,10 +130,7 @@ VToolPointOfIntersectionCircles *VToolPointOfIntersectionCircles::Create(const q
secondCircleRadius, crossPoint,
typeCreation);
scene->addItem(point);
connect(point, &VToolPointOfIntersectionCircles::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolPointOfIntersectionCircles::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolPointOfIntersectionCircles::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolPointOfIntersectionCircles::EnableToolMove);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->IncrementReferens(c1Point.getIdTool());
doc->IncrementReferens(c2Point.getIdTool());

5
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/vtoolpointofintersectioncurves.cpp
View File

@ -116,10 +116,7 @@ VToolPointOfIntersectionCurves *VToolPointOfIntersectionCurves::Create(const qui
auto point = new VToolPointOfIntersectionCurves(doc, data, id, firstCurveId, secondCurveId, vCrossPoint,
hCrossPoint, typeCreation);
scene->addItem(point);
connect(point, &VToolPointOfIntersectionCurves::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolPointOfIntersectionCurves::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolPointOfIntersectionCurves::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolPointOfIntersectionCurves::EnableToolMove);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->IncrementReferens(curve1->getIdTool());
doc->IncrementReferens(curve2->getIdTool());

75
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/vtoolsinglepoint.cpp
View File

@ -77,19 +77,6 @@ VToolSinglePoint::VToolSinglePoint(VAbstractPattern *doc, VContainer *data, quin
VToolSinglePoint::~VToolSinglePoint()
{}
//---------------------------------------------------------------------------------------------------------------------
void VToolSinglePoint::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
/* From question on StackOverflow
* https://stackoverflow.com/questions/10985028/how-to-remove-border-around-qgraphicsitem-when-selected
*
* There's no interface to disable the drawing of the selection border for the build-in QGraphicsItems. The only way
* I can think of is derive your own items from the build-in ones and override the paint() function:*/
QStyleOptionGraphicsItem myOption(*option);
myOption.state &= ~QStyle::State_Selected;
QGraphicsEllipseItem::paint(painter, &myOption, widget);
}
//---------------------------------------------------------------------------------------------------------------------
QString VToolSinglePoint::name() const
{
@ -131,6 +118,24 @@ void VToolSinglePoint::UpdateNamePosition(quint32 id)
qApp->getUndoStack()->push(moveLabel);
}
//---------------------------------------------------------------------------------------------------------------------
void VToolSinglePoint::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
// Special for not selectable item first need to call standard mousePressEvent then accept event
QGraphicsEllipseItem::mousePressEvent(event);
if (selectionType == SelectionType::ByMouseRelease)
{
event->accept();// Special for not selectable item first need to call standard mousePressEvent then accept event
}
else
{
if (event->button() == Qt::LeftButton)
{
PointChoosed();
}
}
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief SetFactor set current scale factor of scene.
@ -175,16 +180,19 @@ void VToolSinglePoint::FullUpdateFromFile()
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief mousePressEvent handle mouse press events.
* @brief mouseReleaseEvent handle mouse release events.
* @param event mouse release event.
*/
void VToolSinglePoint::mousePressEvent(QGraphicsSceneMouseEvent *event)
void VToolSinglePoint::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
if (event->button() == Qt::LeftButton)
if (selectionType == SelectionType::ByMouseRelease)
{
PointChoosed();
if (event->button() == Qt::LeftButton)
{
PointChoosed();
}
}
QGraphicsEllipseItem::mousePressEvent(event);
QGraphicsEllipseItem::mouseReleaseEvent(event);
}
//---------------------------------------------------------------------------------------------------------------------
@ -333,3 +341,34 @@ void VToolSinglePoint::DoChangePosition(quint32 id, qreal mx, qreal my)
namePoint->blockSignals(false);
RefreshLine(id);
}
//---------------------------------------------------------------------------------------------------------------------
void VToolSinglePoint::AllowHover(bool enabled)
{
setAcceptHoverEvents(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VToolSinglePoint::AllowSelecting(bool enabled)
{
setFlag(QGraphicsItem::ItemIsSelectable, enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VToolSinglePoint::AllowLabelHover(bool enabled)
{
namePoint->setAcceptHoverEvents(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VToolSinglePoint::AllowLabelSelecting(bool enabled)
{
namePoint->setFlag(QGraphicsItem::ItemIsSelectable, enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VToolSinglePoint::ToolSelectionType(const SelectionType &type)
{
VAbstractTool::ToolSelectionType(type);
namePoint->LabelSelectionType(type);
}

10
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/vtoolsinglepoint.h
View File

@ -48,8 +48,6 @@ public:
virtual int type() const Q_DECL_OVERRIDE {return Type;}
enum { Type = UserType + static_cast<int>(Tool::SinglePoint)};
virtual void paint(QPainter * painter, const QStyleOptionGraphicsItem * option,
QWidget * widget = 0) Q_DECL_OVERRIDE;
QString name() const;
void setName(const QString &name);
@ -63,6 +61,11 @@ public slots:
void PointChoosed();
virtual void FullUpdateFromFile() Q_DECL_OVERRIDE;
virtual void DoChangePosition(quint32 id, qreal mx, qreal my) Q_DECL_OVERRIDE;
virtual void AllowHover(bool enabled) Q_DECL_OVERRIDE;
virtual void AllowSelecting(bool enabled) Q_DECL_OVERRIDE;
void AllowLabelHover(bool enabled);
void AllowLabelSelecting(bool enabled);
virtual void ToolSelectionType(const SelectionType &type) Q_DECL_OVERRIDE;
protected:
/** @brief radius radius circle. */
qreal radius;
@ -74,7 +77,8 @@ protected:
QGraphicsLineItem *lineName;
virtual void UpdateNamePosition(quint32 id) Q_DECL_OVERRIDE;
virtual void mousePressEvent ( QGraphicsSceneMouseEvent * event ) Q_DECL_OVERRIDE;
virtual void mousePressEvent(QGraphicsSceneMouseEvent *event) Q_DECL_OVERRIDE;
virtual void mouseReleaseEvent ( QGraphicsSceneMouseEvent * event ) Q_DECL_OVERRIDE;
virtual void hoverEnterEvent ( QGraphicsSceneHoverEvent * event ) Q_DECL_OVERRIDE;
virtual void hoverLeaveEvent ( QGraphicsSceneHoverEvent * event ) Q_DECL_OVERRIDE;
virtual void RefreshPointGeometry(const VPointF &point);

5
src/libs/vtools/tools/drawTools/toolpoint/toolsinglepoint/vtooltriangle.cpp
View File

@ -151,10 +151,7 @@ VToolTriangle* VToolTriangle::Create(const quint32 _id, const QString &pointName
VToolTriangle *point = new VToolTriangle(doc, data, id, axisP1Id, axisP2Id, firstPointId,
secondPointId, typeCreation);
scene->addItem(point);
connect(point, &VToolTriangle::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, point, &VToolTriangle::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, point, &VToolTriangle::Disable);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VToolTriangle::EnableToolMove);
InitToolConnections(scene, point);
doc->AddTool(id, point);
doc->IncrementReferens(axisP1->getIdTool());
doc->IncrementReferens(axisP2->getIdTool());

17
src/libs/vtools/tools/drawTools/toolpoint/vabstractpoint.h
View File

@ -63,6 +63,9 @@ protected:
template <typename T>
void SetToolEnabled(T *item, bool enabled);
template <typename T>
static void InitToolConnections(VMainGraphicsScene *scene, T *tool);
private:
Q_DISABLE_COPY(VAbstractPoint)
};
@ -118,4 +121,18 @@ void VAbstractPoint::ChangePosition(T *item, quint32 id, const QPointF &pos)
UpdateNamePosition(id);
}
//---------------------------------------------------------------------------------------------------------------------
template <typename T>
void VAbstractPoint::InitToolConnections(VMainGraphicsScene *scene, T *tool)
{
SCASSERT(scene != nullptr);
SCASSERT(tool != nullptr);
InitDrawToolConnections(scene, tool);
QObject::connect(scene, &VMainGraphicsScene::EnablePointItemHover, tool, &T::AllowHover);
QObject::connect(scene, &VMainGraphicsScene::EnablePointItemSelection, tool, &T::AllowSelecting);
QObject::connect(scene, &VMainGraphicsScene::EnableLabelItemHover, tool, &T::AllowLabelHover);
QObject::connect(scene, &VMainGraphicsScene::EnableLabelItemSelection, tool, &T::AllowLabelSelecting);
}
#endif // VABSTRACTPOINT_H

7
src/libs/vtools/tools/drawTools/vdrawtool.cpp
View File

@ -265,6 +265,13 @@ void VDrawTool::EnableToolMove(bool move)
// Do nothing.
}
//---------------------------------------------------------------------------------------------------------------------
void VDrawTool::DetailsMode(bool mode)
{
Q_UNUSED(mode)
// Do nothing.
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief CheckFormula check formula.

19
src/libs/vtools/tools/drawTools/vdrawtool.h
View File

@ -70,6 +70,7 @@ public slots:
virtual void SetFactor(qreal factor);
virtual void EnableToolMove(bool move);
virtual void Disable(bool disable, const QString &namePP)=0;
virtual void DetailsMode(bool mode);
protected:
enum class RemoveOption : bool {Disable = false, Enable = true};
@ -115,6 +116,9 @@ protected:
template <typename T>
QString ObjectName(quint32 id) const;
template <typename T>
static void InitDrawToolConnections(VMainGraphicsScene *scene, T *tool);
private:
Q_DISABLE_COPY(VDrawTool)
};
@ -226,4 +230,19 @@ QString VDrawTool::ObjectName(quint32 id) const
}
}
//---------------------------------------------------------------------------------------------------------------------
template <typename T>
void VDrawTool::InitDrawToolConnections(VMainGraphicsScene *scene, T *tool)
{
SCASSERT(scene != nullptr);
SCASSERT(tool != nullptr);
QObject::connect(tool, &T::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
QObject::connect(scene, &VMainGraphicsScene::NewFactor, tool, &T::SetFactor);
QObject::connect(scene, &VMainGraphicsScene::DisableItem, tool, &T::Disable);
QObject::connect(scene, &VMainGraphicsScene::EnableToolMove, tool, &T::EnableToolMove);
QObject::connect(scene, &VMainGraphicsScene::CurveDetailsMode, tool, &T::DetailsMode);
QObject::connect(scene, &VMainGraphicsScene::ItemSelection, tool, &T::ToolSelectionType);
}
#endif // VDRAWTOOL_H

26
src/libs/vtools/tools/drawTools/vtoolline.cpp
View File

@ -152,6 +152,7 @@ VToolLine * VToolLine::Create(const quint32 &_id, const quint32 &firstPoint, con
connect(line, &VToolLine::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::NewFactor, line, &VToolLine::SetFactor);
connect(scene, &VMainGraphicsScene::DisableItem, line, &VToolLine::Disable);
connect(scene, &VMainGraphicsScene::EnableLineItemHover, line, &VToolLine::AllowHover);
doc->AddTool(id, line);
const QSharedPointer<VPointF> first = data->GeometricObject<VPointF>(firstPoint);
@ -164,19 +165,6 @@ VToolLine * VToolLine::Create(const quint32 &_id, const quint32 &firstPoint, con
return nullptr;
}
//---------------------------------------------------------------------------------------------------------------------
void VToolLine::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
/* From question on StackOverflow
* https://stackoverflow.com/questions/10985028/how-to-remove-border-around-qgraphicsitem-when-selected
*
* There's no interface to disable the drawing of the selection border for the build-in QGraphicsItems. The only way
* I can think of is derive your own items from the build-in ones and override the paint() function:*/
QStyleOptionGraphicsItem myOption(*option);
myOption.state &= ~QStyle::State_Selected;
QGraphicsLineItem::paint(painter, &myOption, widget);
}
//---------------------------------------------------------------------------------------------------------------------
QString VToolLine::getTagName() const
{
@ -226,6 +214,18 @@ void VToolLine::Disable(bool disable, const QString &namePP)
LineStyleToPenStyle(typeLine)));
}
//---------------------------------------------------------------------------------------------------------------------
void VToolLine::AllowHover(bool enabled)
{
setAcceptHoverEvents(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VToolLine::AllowSelecting(bool enabled)
{
setFlag(QGraphicsItem::ItemIsSelectable, enabled);
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief contextMenuEvent handle context menu events.

5
src/libs/vtools/tools/drawTools/vtoolline.h
View File

@ -49,8 +49,7 @@ public:
VAbstractPattern *doc, VContainer *data, const Document &parse,
const Source &typeCreation);
static const QString TagName;
virtual void paint(QPainter * painter, const QStyleOptionGraphicsItem * option,
QWidget * widget = 0) Q_DECL_OVERRIDE;
virtual int type() const Q_DECL_OVERRIDE {return Type;}
enum { Type = UserType + static_cast<int>(Tool::Line)};
virtual QString getTagName() const Q_DECL_OVERRIDE;
@ -69,6 +68,8 @@ public slots:
virtual void ShowTool(quint32 id, bool enable) Q_DECL_OVERRIDE;
virtual void SetFactor(qreal factor) Q_DECL_OVERRIDE;
virtual void Disable(bool disable, const QString &namePP) Q_DECL_OVERRIDE;
virtual void AllowHover(bool enabled) Q_DECL_OVERRIDE;
virtual void AllowSelecting(bool enabled) Q_DECL_OVERRIDE;
protected:
virtual void contextMenuEvent ( QGraphicsSceneContextMenuEvent * event ) Q_DECL_OVERRIDE;
virtual void AddToFile() Q_DECL_OVERRIDE;

14
src/libs/vtools/tools/nodeDetails/vnodearc.cpp
View File

@ -99,6 +99,20 @@ QString VNodeArc::getTagName() const
return VNodeArc::TagName;
}
//---------------------------------------------------------------------------------------------------------------------
void VNodeArc::AllowHover(bool enabled)
{
Q_UNUSED(enabled)
// do nothing
}
//---------------------------------------------------------------------------------------------------------------------
void VNodeArc::AllowSelecting(bool enabled)
{
Q_UNUSED(enabled)
// do nothing
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief AddToFile add tag with informations about tool into file.

2
src/libs/vtools/tools/nodeDetails/vnodearc.h
View File

@ -49,6 +49,8 @@ public:
virtual QString getTagName() const Q_DECL_OVERRIDE;
public slots:
virtual void FullUpdateFromFile() Q_DECL_OVERRIDE {}
virtual void AllowHover(bool enabled) Q_DECL_OVERRIDE;
virtual void AllowSelecting(bool enabled) Q_DECL_OVERRIDE;
protected:
virtual void AddToFile() Q_DECL_OVERRIDE;
virtual void RefreshDataInFile() Q_DECL_OVERRIDE;

38
src/libs/vtools/tools/nodeDetails/vnodepoint.cpp
View File

@ -91,6 +91,10 @@ void VNodePoint::Create(VAbstractPattern *doc, VContainer *data, VMainGraphicsSc
VNodePoint *point = new VNodePoint(doc, data, id, idPoint, typeCreation, idTool, doc);
connect(scene, &VMainGraphicsScene::EnableToolMove, point, &VNodePoint::EnableToolMove);
connect(scene, &VMainGraphicsScene::EnablePointItemHover, point, &VNodePoint::AllowHover);
connect(scene, &VMainGraphicsScene::EnablePointItemSelection, point, &VNodePoint::AllowSelecting);
connect(scene, &VMainGraphicsScene::EnableLabelItemHover, point, &VNodePoint::AllowLabelHover);
connect(scene, &VMainGraphicsScene::EnableLabelItemSelection, point, &VNodePoint::AllowLabelSelecting);
doc->AddTool(id, point);
if (idTool != NULL_ID)
{
@ -227,6 +231,14 @@ void VNodePoint::RefreshDataInFile()
}
}
//---------------------------------------------------------------------------------------------------------------------
void VNodePoint::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
// Special for not selectable item first need to call standard mousePressEvent then accept event
QGraphicsEllipseItem::mousePressEvent(event);
event->accept();// Special for not selectable item first need to call standard mousePressEvent then accept event
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief mouseReleaseEvent handle mouse release events.
@ -238,7 +250,7 @@ void VNodePoint::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
emit ChoosedTool(id, SceneObject::Point);
}
QGraphicsItem::mouseReleaseEvent(event);
QGraphicsEllipseItem::mouseReleaseEvent(event);
}
//---------------------------------------------------------------------------------------------------------------------
@ -345,3 +357,27 @@ void VNodePoint::EnableToolMove(bool move)
{
namePoint->setFlag(QGraphicsItem::ItemIsMovable, move);
}
//---------------------------------------------------------------------------------------------------------------------
void VNodePoint::AllowHover(bool enabled)
{
setAcceptHoverEvents(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VNodePoint::AllowSelecting(bool enabled)
{
setFlag(QGraphicsItem::ItemIsSelectable, enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VNodePoint::AllowLabelHover(bool enabled)
{
namePoint->setAcceptHoverEvents(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VNodePoint::AllowLabelSelecting(bool enabled)
{
namePoint->setFlag(QGraphicsItem::ItemIsSelectable, enabled);
}

5
src/libs/vtools/tools/nodeDetails/vnodepoint.h
View File

@ -64,6 +64,10 @@ public slots:
void NameChangePosition(const QPointF &pos);
void PointChoosed();
void EnableToolMove(bool move);
virtual void AllowHover(bool enabled) Q_DECL_OVERRIDE;
virtual void AllowSelecting(bool enabled) Q_DECL_OVERRIDE;
void AllowLabelHover(bool enabled);
void AllowLabelSelecting(bool enabled);
protected:
/** @brief radius radius circle. */
qreal radius;
@ -76,6 +80,7 @@ protected:
virtual void AddToFile() Q_DECL_OVERRIDE;
virtual void RefreshDataInFile() Q_DECL_OVERRIDE;
virtual void mousePressEvent(QGraphicsSceneMouseEvent *event) Q_DECL_OVERRIDE;
virtual void mouseReleaseEvent ( QGraphicsSceneMouseEvent * event ) Q_DECL_OVERRIDE;
virtual void hoverMoveEvent ( QGraphicsSceneHoverEvent * event ) Q_DECL_OVERRIDE;
virtual void hoverLeaveEvent ( QGraphicsSceneHoverEvent * event ) Q_DECL_OVERRIDE;

14
src/libs/vtools/tools/nodeDetails/vnodespline.cpp
View File

@ -102,6 +102,20 @@ QString VNodeSpline::getTagName() const
return VNodeSpline::TagName;
}
//---------------------------------------------------------------------------------------------------------------------
void VNodeSpline::AllowHover(bool enabled)
{
Q_UNUSED(enabled)
// do nothing
}
//---------------------------------------------------------------------------------------------------------------------
void VNodeSpline::AllowSelecting(bool enabled)
{
Q_UNUSED(enabled)
// do nothing
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief AddToFile add tag with informations about tool into file.

2
src/libs/vtools/tools/nodeDetails/vnodespline.h
View File

@ -50,6 +50,8 @@ public:
virtual QString getTagName() const Q_DECL_OVERRIDE;
public slots:
virtual void FullUpdateFromFile () Q_DECL_OVERRIDE {}
virtual void AllowHover(bool enabled) Q_DECL_OVERRIDE;
virtual void AllowSelecting(bool enabled) Q_DECL_OVERRIDE;
protected:
virtual void AddToFile () Q_DECL_OVERRIDE;
virtual void RefreshDataInFile() Q_DECL_OVERRIDE;

14
src/libs/vtools/tools/nodeDetails/vnodesplinepath.cpp
View File

@ -100,6 +100,20 @@ QString VNodeSplinePath::getTagName() const
return VNodeSplinePath::TagName;
}
//---------------------------------------------------------------------------------------------------------------------
void VNodeSplinePath::AllowHover(bool enabled)
{
Q_UNUSED(enabled)
// do nothing
}
//---------------------------------------------------------------------------------------------------------------------
void VNodeSplinePath::AllowSelecting(bool enabled)
{
Q_UNUSED(enabled)
// do nothing
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief AddToFile add tag with informations about tool into file.

2
src/libs/vtools/tools/nodeDetails/vnodesplinepath.h
View File

@ -49,6 +49,8 @@ public:
virtual QString getTagName() const Q_DECL_OVERRIDE;
public slots:
virtual void FullUpdateFromFile() Q_DECL_OVERRIDE {}
virtual void AllowHover(bool enabled) Q_DECL_OVERRIDE;
virtual void AllowSelecting(bool enabled) Q_DECL_OVERRIDE;
protected:
virtual void AddToFile() Q_DECL_OVERRIDE;
virtual void RefreshDataInFile() Q_DECL_OVERRIDE;

9
src/libs/vtools/tools/vabstracttool.cpp
View File

@ -52,7 +52,8 @@ const QString VAbstractTool::AttrInUse = QStringLiteral("inUse");
* @param parent parent object.
*/
VAbstractTool::VAbstractTool(VAbstractPattern *doc, VContainer *data, quint32 id, QObject *parent)
:VDataTool(data, parent), doc(doc), id(id), baseColor(Qt::black), vis(nullptr)
:VDataTool(data, parent), doc(doc), id(id), baseColor(Qt::black), vis(nullptr),
selectionType(SelectionType::ByMouseRelease)
{
SCASSERT(doc != nullptr);
connect(this, &VAbstractTool::toolhaveChange, this->doc, &VAbstractPattern::haveLiteChange);
@ -256,6 +257,12 @@ QMap<QString, quint32> VAbstractTool::PointsList() const
return list;
}
//---------------------------------------------------------------------------------------------------------------------
void VAbstractTool::ToolSelectionType(const SelectionType &type)
{
selectionType = type;
}
//---------------------------------------------------------------------------------------------------------------------
void VAbstractTool::ToolCreation(const Source &typeCreation)
{

4
src/libs/vtools/tools/vabstracttool.h
View File

@ -77,6 +77,9 @@ public slots:
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile()=0;
virtual void AllowHover(bool enabled)=0;
virtual void AllowSelecting(bool enabled)=0;
virtual void ToolSelectionType(const SelectionType &type);
signals:
/**
* @brief toolhaveChange emit if tool create change that need save.
@ -103,6 +106,7 @@ protected:
Qt::GlobalColor baseColor;
Visualization *vis;
SelectionType selectionType;
/**
* @brief AddToFile add tag with informations about tool into file.

20
src/libs/vtools/tools/vtooldetail.cpp
View File

@ -253,6 +253,8 @@ void VToolDetail::Create(const quint32 &_id, const VDetail &newDetail, VMainGrap
VToolDetail *detail = new VToolDetail(doc, data, id, typeCreation, scene, drawName);
scene->addItem(detail);
connect(detail, &VToolDetail::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
connect(scene, &VMainGraphicsScene::EnableDetailItemHover, detail, &VToolDetail::AllowHover);
connect(scene, &VMainGraphicsScene::EnableDetailItemSelection, detail, &VToolDetail::AllowSelecting);
doc->AddTool(id, detail);
}
}
@ -458,6 +460,8 @@ void VToolDetail::keyReleaseEvent(QKeyEvent *event)
//---------------------------------------------------------------------------------------------------------------------
void VToolDetail::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
// Special for not selectable item first need to call standard mousePressEvent then accept event
VNoBrushScalePathItem::mousePressEvent(event);
if (flags() & QGraphicsItem::ItemIsMovable)
{
if (event->button() == Qt::LeftButton && event->type() != QEvent::GraphicsSceneMouseDoubleClick)
@ -471,7 +475,7 @@ void VToolDetail::mousePressEvent(QGraphicsSceneMouseEvent *event)
emit ChoosedTool(id, SceneObject::Detail);
}
VNoBrushScalePathItem::mousePressEvent(event);
event->accept();// Special for not selectable item first need to call standard mousePressEvent then accept event
}
//---------------------------------------------------------------------------------------------------------------------
@ -689,5 +693,17 @@ void VToolDetail::InitTool(VMainGraphicsScene *scene, const VNodeDetail &node)
//---------------------------------------------------------------------------------------------------------------------
void VToolDetail::EnableToolMove(bool move)
{
this->setFlag(QGraphicsItem::ItemIsMovable, move);
setFlag(QGraphicsItem::ItemIsMovable, move);
}
//---------------------------------------------------------------------------------------------------------------------
void VToolDetail::AllowHover(bool enabled)
{
setAcceptHoverEvents(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VToolDetail::AllowSelecting(bool enabled)
{
setFlag(QGraphicsItem::ItemIsSelectable, enabled);
}

2
src/libs/vtools/tools/vtooldetail.h
View File

@ -90,6 +90,8 @@ public slots:
virtual void FullUpdateFromFile () Q_DECL_OVERRIDE;
virtual void FullUpdateFromGuiOk(int result);
void EnableToolMove(bool move);
virtual void AllowHover(bool enabled) Q_DECL_OVERRIDE;
virtual void AllowSelecting(bool enabled) Q_DECL_OVERRIDE;
protected:
virtual void AddToFile () Q_DECL_OVERRIDE;
virtual void RefreshDataInFile() Q_DECL_OVERRIDE;

2
src/libs/vtools/tools/vtooluniondetails.h
View File

@ -89,6 +89,8 @@ public slots:
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile () Q_DECL_OVERRIDE {}
virtual void AllowHover(bool) Q_DECL_OVERRIDE {}
virtual void AllowSelecting(bool) Q_DECL_OVERRIDE {}
protected:
virtual void AddToFile() Q_DECL_OVERRIDE;
virtual void RefreshDataInFile() Q_DECL_OVERRIDE;

13
src/libs/vwidgets/vcontrolpointspline.cpp
View File

@ -89,19 +89,6 @@ VControlPointSpline::~VControlPointSpline()
RestoreOverrideCursor(cursorArrowOpenHand);
}
//---------------------------------------------------------------------------------------------------------------------
void VControlPointSpline::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
/* From question on StackOverflow
* https://stackoverflow.com/questions/10985028/how-to-remove-border-around-qgraphicsitem-when-selected
*
* There's no interface to disable the drawing of the selection border for the build-in QGraphicsItems. The only way
* I can think of is derive your own items from the build-in ones and override the paint() function:*/
QStyleOptionGraphicsItem myOption(*option);
myOption.state &= ~QStyle::State_Selected;
QGraphicsEllipseItem::paint(painter, &myOption, widget);
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief hoverEnterEvent handle hover enter events.

3
src/libs/vwidgets/vcontrolpointspline.h
View File

@ -47,8 +47,7 @@ public:
const QPointF &splinePoint, Unit patternUnit, bool freeAngle, bool freeLength,
QGraphicsItem * parent = nullptr);
virtual ~VControlPointSpline() Q_DECL_OVERRIDE;
virtual void paint(QPainter * painter, const QStyleOptionGraphicsItem * option,
QWidget * widget = 0) Q_DECL_OVERRIDE;
virtual int type() const Q_DECL_OVERRIDE {return Type;}
enum { Type = UserType + static_cast<int>(Vis::ControlPointSpline)};
signals:

35
src/libs/vwidgets/vgraphicssimpletextitem.cpp
View File

@ -45,7 +45,7 @@
* @param parent parent object.
*/
VGraphicsSimpleTextItem::VGraphicsSimpleTextItem(QGraphicsItem * parent)
:QGraphicsSimpleTextItem(parent), fontSize(0)
:QGraphicsSimpleTextItem(parent), fontSize(0), selectionType(SelectionType::ByMouseRelease)
{
this->setFlag(QGraphicsItem::ItemIsMovable, true);
this->setFlag(QGraphicsItem::ItemIsSelectable, true);
@ -64,7 +64,7 @@ VGraphicsSimpleTextItem::VGraphicsSimpleTextItem(QGraphicsItem * parent)
* @param parent parent object.
*/
VGraphicsSimpleTextItem::VGraphicsSimpleTextItem( const QString & text, QGraphicsItem * parent )
:QGraphicsSimpleTextItem(text, parent), fontSize(0)
:QGraphicsSimpleTextItem(text, parent), fontSize(0), selectionType(SelectionType::ByMouseRelease)
{
this->setFlag(QGraphicsItem::ItemIsMovable, true);
this->setFlag(QGraphicsItem::ItemIsSelectable, true);
@ -94,6 +94,12 @@ void VGraphicsSimpleTextItem::setEnabled(bool enabled)
}
}
//---------------------------------------------------------------------------------------------------------------------
void VGraphicsSimpleTextItem::LabelSelectionType(const SelectionType &type)
{
selectionType = type;
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief itemChange handle item change.
@ -158,10 +164,9 @@ void VGraphicsSimpleTextItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
{
if (flags() & QGraphicsItem::ItemIsMovable)
{
this->setBrush(Qt::green);
SetOverrideCursor(cursorArrowOpenHand, 1, 1);
}
this->setBrush(Qt::green);
QGraphicsSimpleTextItem::hoverEnterEvent(event);
}
@ -175,11 +180,10 @@ void VGraphicsSimpleTextItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
Q_UNUSED(event);
if (flags() & QGraphicsItem::ItemIsMovable)
{
this->setBrush(Qt::black);
//Disable cursor-arrow-openhand
RestoreOverrideCursor(cursorArrowOpenHand);
}
this->setBrush(Qt::black);
QGraphicsSimpleTextItem::hoverLeaveEvent(event);
}
@ -196,6 +200,8 @@ void VGraphicsSimpleTextItem::contextMenuEvent(QGraphicsSceneContextMenuEvent *e
//---------------------------------------------------------------------------------------------------------------------
void VGraphicsSimpleTextItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
// Special for not selectable item first need to call standard mousePressEvent then accept event
QGraphicsSimpleTextItem::mousePressEvent(event);
if (flags() & QGraphicsItem::ItemIsMovable)
{
if (event->button() == Qt::LeftButton && event->type() != QEvent::GraphicsSceneMouseDoubleClick)
@ -203,10 +209,14 @@ void VGraphicsSimpleTextItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
SetOverrideCursor(cursorArrowCloseHand, 1, 1);
}
}
emit PointChoosed();
QGraphicsSimpleTextItem::mousePressEvent(event);
if (selectionType == SelectionType::ByMouseRelease)
{
event->accept(); // This help for not selectable items still receive mouseReleaseEvent events
}
else
{
emit PointChoosed();
}
}
//---------------------------------------------------------------------------------------------------------------------
@ -221,6 +231,11 @@ void VGraphicsSimpleTextItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
}
}
if (selectionType == SelectionType::ByMouseRelease)
{
emit PointChoosed();
}
QGraphicsSimpleTextItem::mouseReleaseEvent(event);
}

4
src/libs/vwidgets/vgraphicssimpletextitem.h
View File

@ -49,6 +49,7 @@ public:
enum { Type = UserType + static_cast<int>(Vis::GraphicsSimpleTextItem)};
void setEnabled(bool enabled);
void LabelSelectionType(const SelectionType &type);
signals:
/**
* @brief NameChangePosition emit when label change position.
@ -72,7 +73,8 @@ protected:
virtual void keyReleaseEvent ( QKeyEvent * event ) Q_DECL_OVERRIDE;
private:
/** @brief fontSize label font size. */
qint32 fontSize;
qint32 fontSize;
SelectionType selectionType;
};
//---------------------------------------------------------------------------------------------------------------------

108
src/libs/vwidgets/vmaingraphicsscene.cpp
View File

@ -280,3 +280,111 @@ void VMainGraphicsScene::EnableDetailsMode(bool mode)
{
emit CurveDetailsMode(mode);
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsScene::ItemsSelection(const SelectionType &type)
{
emit ItemSelection(type);
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsScene::ToggleLabelSelection(bool enabled)
{
emit EnableLabelItemSelection(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsScene::TogglePointSelection(bool enabled)
{
emit EnablePointItemSelection(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsScene::ToggleArcSelection(bool enabled)
{
emit EnableArcItemSelection(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsScene::ToggleSplineSelection(bool enabled)
{
emit EnableSplineItemSelection(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsScene::ToggleSplinePathSelection(bool enabled)
{
emit EnableSplinePathItemSelection(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsScene::ToggleNodeLabelSelection(bool enabled)
{
emit EnableNodeLabelItemSelection(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsScene::ToggleNodePointSelection(bool enabled)
{
emit EnableNodePointItemSelection(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsScene::ToggleDetailSelection(bool enabled)
{
emit EnableDetailItemSelection(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsScene::ToggleLabelHover(bool enabled)
{
emit EnableLabelItemHover(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsScene::TogglePointHover(bool enabled)
{
emit EnablePointItemHover(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsScene::ToggleLineHover(bool enabled)
{
emit EnableLineItemHover(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsScene::ToggleArcHover(bool enabled)
{
emit EnableArcItemHover(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsScene::ToggleSplineHover(bool enabled)
{
emit EnableSplineItemHover(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsScene::ToggleSplinePathHover(bool enabled)
{
emit EnableSplinePathItemHover(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsScene::ToggleNodeLabelHover(bool enabled)
{
emit EnableNodeLabelItemHover(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsScene::ToggleNodePointHover(bool enabled)
{
emit EnableNodePointItemHover(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsScene::ToggleDetailHover(bool enabled)
{
emit EnableDetailItemHover(enabled);
}

40
src/libs/vwidgets/vmaingraphicsscene.h
View File

@ -58,6 +58,26 @@ public slots:
void SetFactor(qreal factor);
void EnableItemMove(bool move);
void EnableDetailsMode(bool mode);
void ItemsSelection(const SelectionType &type);
void ToggleLabelSelection(bool enabled);
void TogglePointSelection(bool enabled);
void ToggleArcSelection(bool enabled);
void ToggleSplineSelection(bool enabled);
void ToggleSplinePathSelection(bool enabled);
void ToggleNodeLabelSelection(bool enabled);
void ToggleNodePointSelection(bool enabled);
void ToggleDetailSelection(bool enabled);
void ToggleLabelHover(bool enabled);
void TogglePointHover(bool enabled);
void ToggleLineHover(bool enabled);
void ToggleArcHover(bool enabled);
void ToggleSplineHover(bool enabled);
void ToggleSplinePathHover(bool enabled);
void ToggleNodeLabelHover(bool enabled);
void ToggleNodePointHover(bool enabled);
void ToggleDetailHover(bool enabled);
protected:
virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event) Q_DECL_OVERRIDE;
virtual void mousePressEvent(QGraphicsSceneMouseEvent *event) Q_DECL_OVERRIDE;
@ -86,6 +106,26 @@ signals:
void DisableItem(bool disable, const QString &namePP);
void EnableToolMove(bool move);
void CurveDetailsMode(bool mode);
void ItemSelection(const SelectionType &type);
void EnableLabelItemSelection(bool enable);
void EnablePointItemSelection(bool enable);
void EnableArcItemSelection(bool enable);
void EnableSplineItemSelection(bool enable);
void EnableSplinePathItemSelection(bool enable);
void EnableNodeLabelItemSelection(bool enabled);
void EnableNodePointItemSelection(bool enabled);
void EnableDetailItemSelection(bool enabled);
void EnableLabelItemHover(bool enable);
void EnablePointItemHover(bool enable);
void EnableArcItemHover(bool enable);
void EnableSplineItemHover(bool enable);
void EnableSplinePathItemHover(bool enable);
void EnableNodeLabelItemHover(bool enabled);
void EnableNodePointItemHover(bool enabled);
void EnableDetailItemHover(bool enabled);
void EnableLineItemHover(bool enabled);
private:
/** @brief horScrollBar value horizontal scroll bar. */
qint32 horScrollBar;

15
src/libs/vwidgets/vmaingraphicsview.cpp
View File

@ -321,7 +321,7 @@ bool GraphicsViewZoom::StartHorizontalScrollings(QWheelEvent *wheel_event)
* @param parent parent object.
*/
VMainGraphicsView::VMainGraphicsView(QWidget *parent)
:QGraphicsView(parent), zoom(nullptr), showToolOptions(true)
:QGraphicsView(parent), zoom(nullptr), showToolOptions(true), isAllowRubberBand(true)
{
zoom = new GraphicsViewZoom(this);
this->setResizeAnchor(QGraphicsView::AnchorUnderMouse);
@ -386,7 +386,10 @@ void VMainGraphicsView::mousePressEvent(QMouseEvent *mousePress)
{
case Qt::LeftButton:
{
QGraphicsView::setDragMode(QGraphicsView::RubberBandDrag);
if (isAllowRubberBand)
{
QGraphicsView::setDragMode(QGraphicsView::RubberBandDrag);
}
if (showToolOptions)
{
QList<QGraphicsItem *> list = items(mousePress->pos());
@ -436,7 +439,7 @@ void VMainGraphicsView::mousePressEvent(QMouseEvent *mousePress)
*/
void VMainGraphicsView::mouseReleaseEvent(QMouseEvent *event)
{
QGraphicsView::mouseReleaseEvent ( event );
QGraphicsView::mouseReleaseEvent ( event ); // First because need to hide a rubber band
QGraphicsView::setDragMode( QGraphicsView::NoDrag );
if (event->button() == Qt::LeftButton)
{
@ -450,6 +453,12 @@ void VMainGraphicsView::setShowToolOptions(bool value)
showToolOptions = value;
}
//---------------------------------------------------------------------------------------------------------------------
void VMainGraphicsView::AllowRubberBand(bool value)
{
isAllowRubberBand = value;
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief NewSceneRect calculate scene rect what contains all items and doesn't less that size of scene view.

2
src/libs/vwidgets/vmaingraphicsview.h
View File

@ -109,6 +109,7 @@ public:
explicit VMainGraphicsView(QWidget *parent = nullptr);
void setShowToolOptions(bool value);
void AllowRubberBand(bool value);
static void NewSceneRect(QGraphicsScene *sc, QGraphicsView *view);
static QRectF SceneVisibleArea(QGraphicsView *view);
@ -138,6 +139,7 @@ private:
Q_DISABLE_COPY(VMainGraphicsView)
GraphicsViewZoom* zoom;
bool showToolOptions;
bool isAllowRubberBand;
};
#endif // VMAINGRAPHICSVIEW_H

64
src/libs/vwidgets/vsimplepoint.cpp
View File

@ -39,7 +39,8 @@
//---------------------------------------------------------------------------------------------------------------------
VSimplePoint::VSimplePoint(quint32 id, const QColor &currentColor, Unit patternUnit, qreal *factor, QObject *parent)
:VAbstractSimple(id, currentColor, patternUnit, factor, parent), QGraphicsEllipseItem(),
radius(ToPixel(DefPointRadius/*mm*/, Unit::Mm)), namePoint(nullptr), lineName(nullptr)
radius(ToPixel(DefPointRadius/*mm*/, Unit::Mm)), namePoint(nullptr), lineName(nullptr),
selectionType(SelectionType::ByMouseRelease)
{
namePoint = new VGraphicsSimpleTextItem(this);
connect(namePoint, &VGraphicsSimpleTextItem::ShowContextMenu, this, &VSimplePoint::ContextMenu);
@ -64,19 +65,6 @@ void VSimplePoint::ChangedActivDraw(const bool &flag)
SetPen(this, currentColor, WidthHairLine(patternUnit));
}
//---------------------------------------------------------------------------------------------------------------------
void VSimplePoint::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
/* From question on StackOverflow
* https://stackoverflow.com/questions/10985028/how-to-remove-border-around-qgraphicsitem-when-selected
*
* There's no interface to disable the drawing of the selection border for the build-in QGraphicsItems. The only way
* I can think of is derive your own items from the build-in ones and override the paint() function:*/
QStyleOptionGraphicsItem myOption(*option);
myOption.state &= ~QStyle::State_Selected;
QGraphicsEllipseItem::paint(painter, &myOption, widget);
}
//---------------------------------------------------------------------------------------------------------------------
void VSimplePoint::RefreshLine()
{
@ -146,6 +134,25 @@ void VSimplePoint::EnableToolMove(bool move)
namePoint->setFlag(QGraphicsItem::ItemIsMovable, move);
}
//---------------------------------------------------------------------------------------------------------------------
void VSimplePoint::AllowLabelHover(bool enabled)
{
namePoint->setAcceptHoverEvents(enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VSimplePoint::AllowLabelSelecting(bool enabled)
{
namePoint->setFlag(QGraphicsItem::ItemIsSelectable, enabled);
}
//---------------------------------------------------------------------------------------------------------------------
void VSimplePoint::ToolSelectionType(const SelectionType &type)
{
selectionType = type;
namePoint->LabelSelectionType(type);
}
//---------------------------------------------------------------------------------------------------------------------
void VSimplePoint::DeleteFromLabel()
{
@ -173,11 +180,32 @@ void VSimplePoint::ContextMenu(QGraphicsSceneContextMenuEvent *event)
//---------------------------------------------------------------------------------------------------------------------
void VSimplePoint::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
if (event->button() == Qt::LeftButton)
{
emit Choosed(id);
}
// Special for not selectable item first need to call standard mousePressEvent then accept event
QGraphicsEllipseItem::mousePressEvent(event);
if (selectionType == SelectionType::ByMouseRelease)
{
event->accept();// Special for not selectable item first need to call standard mousePressEvent then accept event
}
else
{
if (event->button() == Qt::LeftButton)
{
emit Choosed(id);
}
}
}
//---------------------------------------------------------------------------------------------------------------------
void VSimplePoint::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
if (selectionType == SelectionType::ByMouseRelease)
{
if (event->button() == Qt::LeftButton)
{
emit Choosed(id);
}
}
QGraphicsEllipseItem::mouseReleaseEvent(event);
}
//---------------------------------------------------------------------------------------------------------------------

10
src/libs/vwidgets/vsimplepoint.h
View File

@ -45,8 +45,6 @@ public:
virtual ~VSimplePoint() Q_DECL_OVERRIDE;
virtual void ChangedActivDraw(const bool &flag) Q_DECL_OVERRIDE;
virtual void paint(QPainter * painter, const QStyleOptionGraphicsItem * option,
QWidget * widget = 0) Q_DECL_OVERRIDE;
virtual int type() const Q_DECL_OVERRIDE {return Type;}
enum { Type = UserType + static_cast<int>(Vis::SimplePoint)};
@ -55,6 +53,9 @@ public:
void RefreshGeometry(const VPointF &point);
void SetEnabled(bool enabled);
void EnableToolMove(bool move);
void AllowLabelHover(bool enabled);
void AllowLabelSelecting(bool enabled);
void ToolSelectionType(const SelectionType &type);
QColor GetCurrentColor() const;
void SetCurrentColor(const QColor &value);
@ -75,7 +76,8 @@ public slots:
void ContextMenu(QGraphicsSceneContextMenuEvent * event);
protected:
virtual void mousePressEvent ( QGraphicsSceneMouseEvent * event ) Q_DECL_OVERRIDE;
virtual void mousePressEvent( QGraphicsSceneMouseEvent * event ) Q_DECL_OVERRIDE;
virtual void mouseReleaseEvent ( QGraphicsSceneMouseEvent * event ) Q_DECL_OVERRIDE;
virtual void hoverEnterEvent ( QGraphicsSceneHoverEvent * event ) Q_DECL_OVERRIDE;
virtual void hoverLeaveEvent ( QGraphicsSceneHoverEvent * event ) Q_DECL_OVERRIDE;
@ -91,6 +93,8 @@ private:
/** @brief lineName line what we see if label moved too away from point. */
QGraphicsLineItem *lineName;
SelectionType selectionType;
};
#endif // VSIMPLEPOINT_H