From fb901441764da456dc85c0dc0f5cb7a5d4f2ccff Mon Sep 17 00:00:00 2001 From: Matthias Koefferlein Date: Sat, 5 Sep 2020 23:57:40 +0200 Subject: [PATCH] WIP: mouse cursor and snap highlighting --- src/ant/ant/antPropertiesPage.cc | 20 ++-- src/ant/ant/antService.cc | 18 ++-- src/edt/edt/edtPartialService.cc | 2 +- src/edt/edt/edtService.cc | 84 ++++++++++++++++- src/edt/edt/edtService.h | 18 ++++ src/edt/edt/edtServiceImpl.cc | 12 ++- src/edt/edt/edtServiceImpl.h | 1 + src/laybasic/laybasic/laySnap.cc | 92 +++++++++++++----- src/laybasic/laybasic/laySnap.h | 85 +++++++++++++++-- .../{laySnap.cc => laySnapTests.cc} | 94 ++++++++++--------- src/laybasic/unit_tests/unit_tests.pro | 4 +- 11 files changed, 327 insertions(+), 103 deletions(-) rename src/laybasic/unit_tests/{laySnap.cc => laySnapTests.cc} (55%) diff --git a/src/ant/ant/antPropertiesPage.cc b/src/ant/ant/antPropertiesPage.cc index f94185e0c..f48dec09f 100644 --- a/src/ant/ant/antPropertiesPage.cc +++ b/src/ant/ant/antPropertiesPage.cc @@ -231,11 +231,11 @@ PropertiesPage::snap_to_layout_clicked () while (snap_range < max_range) { - std::pair pp = lay::obj_snap (service->view (), snap_p1 ? p2 : p1, snap_p1 ? p1 : p2, g, ac, snap_range); - if (pp.first) { + lay::PointSnapToObjectResult pp = lay::obj_snap (service->view (), snap_p1 ? p2 : p1, snap_p1 ? p1 : p2, g, ac, snap_range); + if (pp.object_snap != lay::PointSnapToObjectResult::NoObject) { - QString xs = tl::to_qstring (tl::micron_to_string (pp.second.x ())); - QString ys = tl::to_qstring (tl::micron_to_string (pp.second.y ())); + QString xs = tl::to_qstring (tl::micron_to_string (pp.snapped_point.x ())); + QString ys = tl::to_qstring (tl::micron_to_string (pp.snapped_point.y ())); if (sender () == p1_to_layout) { x1->setText (xs); @@ -262,13 +262,13 @@ PropertiesPage::snap_to_layout_clicked () double snap_range = service->widget ()->mouse_event_trans ().inverted ().ctrans (service->snap_range ()); snap_range *= 0.5; - std::pair ee = lay::obj_snap2 (service->view (), p1, p2, g, ac, snap_range, snap_range * 1000.0); - if (ee.first) { + lay::TwoPointSnapToObjectResult ee = lay::obj_snap2 (service->view (), p1, p2, g, ac, snap_range, snap_range * 1000.0); + if (ee.any) { - x1->setText (tl::to_qstring (tl::micron_to_string (ee.second.p1 ().x ()))); - y1->setText (tl::to_qstring (tl::micron_to_string (ee.second.p1 ().y ()))); - x2->setText (tl::to_qstring (tl::micron_to_string (ee.second.p2 ().x ()))); - y2->setText (tl::to_qstring (tl::micron_to_string (ee.second.p2 ().y ()))); + x1->setText (tl::to_qstring (tl::micron_to_string (ee.first.x ()))); + y1->setText (tl::to_qstring (tl::micron_to_string (ee.first.y ()))); + x2->setText (tl::to_qstring (tl::micron_to_string (ee.second.x ()))); + y2->setText (tl::to_qstring (tl::micron_to_string (ee.second.y ()))); db::Transaction t (manager (), tl::to_string (QObject::tr ("Snap both ruler points"))); emit edited (); diff --git a/src/ant/ant/antService.cc b/src/ant/ant/antService.cc index fd0a50dc0..282386c6a 100644 --- a/src/ant/ant/antService.cc +++ b/src/ant/ant/antService.cc @@ -1434,14 +1434,14 @@ Service::mouse_click_event (const db::DPoint &p, unsigned int buttons, bool prio double snap_range = widget ()->mouse_event_trans ().inverted ().ctrans (m_snap_range); snap_range *= 0.5; - std::pair ee = lay::obj_snap2 (mp_view, p, g, ac, snap_range, snap_range * 1000.0); - if (ee.first) { + lay::TwoPointSnapToObjectResult ee = lay::obj_snap2 (mp_view, p, g, ac, snap_range, snap_range * 1000.0); + if (ee.any) { // begin the transaction tl_assert (! manager ()->transacting ()); manager ()->transaction (tl::to_string (QObject::tr ("Create ruler"))); - m_current = ant::Object (ee.second.p1 (), ee.second.p2 (), 0, tpl); + m_current = ant::Object (ee.first, ee.second, 0, tpl); show_message (); insert_ruler (m_current, true); @@ -1505,9 +1505,9 @@ Service::create_measure_ruler (const db::DPoint &pt, lay::angle_constraint_type ant::Template tpl; - std::pair ee = lay::obj_snap2 (mp_view, pt, db::DVector (), ac, snap_range, snap_range * 1000.0); - if (ee.first) { - return ant::Object (ee.second.p1 (), ee.second.p2 (), 0, tpl); + lay::TwoPointSnapToObjectResult ee = lay::obj_snap2 (mp_view, pt, db::DVector (), ac, snap_range, snap_range * 1000.0); + if (ee.any) { + return ant::Object (ee.first, ee.second, 0, tpl); } else { return ant::Object (pt, pt, 0, tpl); } @@ -1545,7 +1545,8 @@ Service::snap1 (const db::DPoint &p, bool obj_snap) } double snap_range = widget ()->mouse_event_trans ().inverted ().ctrans (m_snap_range); - return lay::obj_snap (obj_snap ? mp_view : 0, p, g, snap_range); + lay::PointSnapToObjectResult res = lay::obj_snap (obj_snap ? mp_view : 0, p, g, snap_range); + return std::make_pair (res.object_snap != lay::PointSnapToObjectResult::NoObject, res.snapped_point); } @@ -1560,7 +1561,8 @@ Service::snap2 (const db::DPoint &p1, const db::DPoint &p2, const ant::Object *o double snap_range = widget ()->mouse_event_trans ().inverted ().ctrans (m_snap_range); lay::angle_constraint_type snap_mode = ac == lay::AC_Global ? (obj->angle_constraint () == lay::AC_Global ? m_snap_mode : obj->angle_constraint ()) : ac; - return lay::obj_snap (m_obj_snap && obj->snap () ? mp_view : 0, p1, p2, g, snap_mode, snap_range); + lay::PointSnapToObjectResult res = lay::obj_snap (m_obj_snap && obj->snap () ? mp_view : 0, p1, p2, g, snap_mode, snap_range); + return std::make_pair (res.object_snap != lay::PointSnapToObjectResult::NoObject, res.snapped_point); } diff --git a/src/edt/edt/edtPartialService.cc b/src/edt/edt/edtPartialService.cc index 96dc5c437..31254ae4d 100644 --- a/src/edt/edt/edtPartialService.cc +++ b/src/edt/edt/edtPartialService.cc @@ -1309,7 +1309,7 @@ db::DPoint PartialService::snap2 (const db::DPoint &p) const { double snap_range = widget ()->mouse_event_trans ().inverted ().ctrans (sr_pixels); - return lay::obj_snap (m_snap_to_objects ? view () : 0, p, m_edit_grid == db::DVector () ? m_global_grid : m_edit_grid, snap_range).second; + return lay::obj_snap (m_snap_to_objects ? view () : 0, p, m_edit_grid == db::DVector () ? m_global_grid : m_edit_grid, snap_range).snapped_point; } void diff --git a/src/edt/edt/edtService.cc b/src/edt/edt/edtService.cc index aa5cf2b53..56452b024 100644 --- a/src/edt/edt/edtService.cc +++ b/src/edt/edt/edtService.cc @@ -116,6 +116,7 @@ Service::~Service () } m_edit_markers.clear (); + reset_mouse_cursor (); clear_transient_selection (); } @@ -178,18 +179,24 @@ Service::snap (const db::DPoint &p, const db::DPoint &plast, bool connect) const const int sr_pixels = 8; // TODO: make variable -db::DPoint -Service::snap2 (const db::DPoint &p) const +lay::PointSnapToObjectResult +Service::snap2_details (const db::DPoint &p) const { double snap_range = widget ()->mouse_event_trans ().inverted ().ctrans (sr_pixels); - return lay::obj_snap (m_snap_to_objects ? view () : 0, p, m_edit_grid == db::DVector () ? m_global_grid : m_edit_grid, snap_range).second; + return lay::obj_snap (m_snap_to_objects ? view () : 0, p, m_edit_grid == db::DVector () ? m_global_grid : m_edit_grid, snap_range); +} + +db::DPoint +Service::snap2 (const db::DPoint &p) const +{ + return snap2_details (p).snapped_point; } db::DPoint Service::snap2 (const db::DPoint &p, const db::DPoint &plast, bool connect) const { double snap_range = widget ()->mouse_event_trans ().inverted ().ctrans (sr_pixels); - return lay::obj_snap (m_snap_to_objects ? view () : 0, plast, p, m_edit_grid == db::DVector () ? m_global_grid : m_edit_grid, connect ? connect_ac () : move_ac (), snap_range).second; + return lay::obj_snap (m_snap_to_objects ? view () : 0, plast, p, m_edit_grid == db::DVector () ? m_global_grid : m_edit_grid, connect ? connect_ac () : move_ac (), snap_range).snapped_point; } void @@ -473,6 +480,71 @@ Service::selection_bbox () return box; } +namespace +{ + +class MouseCursorViewObject + : public lay::ViewObject +{ +public: + MouseCursorViewObject (lay::ViewObjectWidget *widget, const db::DPoint &pt) + : lay::ViewObject (widget, false), m_pt (pt) + { } + + virtual void render (const lay::Viewport &vp, lay::ViewObjectCanvas &canvas) + { + int dither_pattern = 0; // solid + int lw = int (0.5 + 1.0 / canvas.resolution ()); + + std::vector ops; + ops.resize (1); + ops[0] = lay::ViewOp (canvas.foreground_color ().rgb (), lay::ViewOp::Copy, 0, (unsigned int) dither_pattern, 0, lay::ViewOp::Rect, lw, 0); + lay::CanvasPlane *plane = canvas.plane (ops); + + lay::Renderer &r = canvas.renderer (); + + double rad = 4.0 / canvas.resolution () / vp.trans ().mag (); + + const size_t num_pts = 16; + db::DPoint pts [num_pts]; + for (size_t i = 0; i < num_pts; ++i) { + double x = rad * cos (M_PI * 2.0 * double (i) / double (num_pts)); + double y = rad * sin (M_PI * 2.0 * double (i) / double (num_pts)); + pts [i] = m_pt + db::DVector (x, y); + } + db::DPolygon circle; + circle.assign_hull (pts, pts + num_pts); + + r.draw (circle, vp.trans (), 0, plane, 0, 0); + + r.draw (db::DEdge (m_pt + db::DVector (0, rad * 0.5), m_pt + db::DVector (0, rad * 4)), vp.trans (), 0, plane, 0, 0); + r.draw (db::DEdge (m_pt + db::DVector (rad * 0.5, 0), m_pt + db::DVector (rad * 4, 0)), vp.trans (), 0, plane, 0, 0); + r.draw (db::DEdge (m_pt + db::DVector (0, -rad * 0.5), m_pt + db::DVector (0, -rad * 4)), vp.trans (), 0, plane, 0, 0); + r.draw (db::DEdge (m_pt + db::DVector (-rad * 0.5, 0), m_pt + db::DVector (-rad * 4, 0)), vp.trans (), 0, plane, 0, 0); + } + +private: + db::DPoint m_pt; +}; + +} + +void +Service::set_mouse_cursor (const db::DPoint &pt) +{ + reset_mouse_cursor (); + m_mouse_cursor_markers.push_back (new MouseCursorViewObject (widget (), pt)); +} + +void +Service::reset_mouse_cursor () +{ + for (std::vector::iterator r = m_mouse_cursor_markers.begin (); r != m_mouse_cursor_markers.end (); ++r) { + delete *r; + } + m_mouse_cursor_markers.clear (); +} + void Service::set_edit_marker (lay::ViewObject *edit_marker) { @@ -715,6 +787,8 @@ Service::mouse_move_event (const db::DPoint &p, unsigned int buttons, bool prio) } if (m_editing) { do_mouse_move (p); + } else { + do_mouse_move_inactive (p); } m_alt_ac = lay::AC_Global; @@ -813,6 +887,8 @@ Service::activated () void Service::deactivated () { + reset_mouse_cursor (); + // make all editor option pages visible activate_service (view (), plugin_declaration (), false); diff --git a/src/edt/edt/edtService.h b/src/edt/edt/edtService.h index 997d7e102..4d96adfa7 100644 --- a/src/edt/edt/edtService.h +++ b/src/edt/edt/edtService.h @@ -460,6 +460,16 @@ protected: */ virtual void service_configuration_changed (); + /** + * @brief Sets the mouse cursor to the given point + */ + void set_mouse_cursor (const db::DPoint &pt); + + /** + * @brief Resets the mouse cursor + */ + void reset_mouse_cursor (); + /** * @brief Install a marker for representing the edited object * @@ -552,6 +562,11 @@ protected: return m_editing; } + /** + * @brief Point snapping with detailed return value + */ + lay::PointSnapToObjectResult snap2_details (const db::DPoint &p) const; + private: // The layout view that the editor service is attached to lay::LayoutView *mp_view; @@ -565,6 +580,9 @@ private: // The marker representing the object to be edited std::vector m_edit_markers; + // The marker representing the mouse cursor + std::vector m_mouse_cursor_markers; + // True, if editing is in progress. bool m_editing; diff --git a/src/edt/edt/edtServiceImpl.cc b/src/edt/edt/edtServiceImpl.cc index 59fbdd3de..51b28a90b 100644 --- a/src/edt/edt/edtServiceImpl.cc +++ b/src/edt/edt/edtServiceImpl.cc @@ -413,9 +413,19 @@ PolygonService::set_last_point (const db::DPoint &p) } } -void +void +PolygonService::do_mouse_move_inactive (const db::DPoint &p) +{ + lay::PointSnapToObjectResult snap_details = snap2_details (p); + set_mouse_cursor (snap_details.snapped_point); +} + +void PolygonService::do_mouse_move (const db::DPoint &p) { + lay::PointSnapToObjectResult snap_details = snap2_details (p); + set_mouse_cursor (snap_details.snapped_point); + set_cursor (lay::Cursor::cross); if (m_points.size () >= 2) { set_last_point (p); diff --git a/src/edt/edt/edtServiceImpl.h b/src/edt/edt/edtServiceImpl.h index 37c8cf035..15865e2d6 100644 --- a/src/edt/edt/edtServiceImpl.h +++ b/src/edt/edt/edtServiceImpl.h @@ -91,6 +91,7 @@ public: virtual lay::PropertiesPage *properties_page (db::Manager *manager, QWidget *parent); virtual void do_begin_edit (const db::DPoint &p); virtual void do_mouse_move (const db::DPoint &p); + virtual void do_mouse_move_inactive (const db::DPoint &p); virtual bool do_mouse_click (const db::DPoint &p); virtual void do_finish_edit (); virtual void do_cancel_edit (); diff --git a/src/laybasic/laybasic/laySnap.cc b/src/laybasic/laybasic/laySnap.cc index 04de10a99..841468c63 100644 --- a/src/laybasic/laybasic/laySnap.cc +++ b/src/laybasic/laybasic/laySnap.cc @@ -726,7 +726,7 @@ private: bool m_directed; }; -static std::pair +static PointSnapToObjectResult do_obj_snap (lay::LayoutView *view, const db::DPoint &pt, const db::DVector &grid, double snap_range, const std::vector &cutlines) { db::DPoint dp (pt); @@ -753,25 +753,45 @@ do_obj_snap (lay::LayoutView *view, const db::DPoint &pt, const db::DVector &gri } } - if (finder.any () && anyp) { - // if both the projection and the finder are sucessful, decide by a heuristic criterion which to take - // (the projection gets a penalty (of the snap range) to make it count less than the finder's choice) - // This avoids extreme distortions of the ruler due to projection on long edges. - if ((dp.distance (closest) + snap_range) * 5.0 < dp.distance (finder.get_found ())) { - return std::make_pair (false, closest); - } else { - return std::make_pair (true, finder.get_found ()); - } + // if both the projection and the finder are sucessful, decide by a heuristic criterion which to take + // (the projection gets a penalty (of the snap range) to make it count less than the finder's choice) + // This avoids extreme distortions of the ruler due to projection on long edges. + if (finder.any () && anyp && (dp.distance (closest) + snap_range) * 5.0 < dp.distance (finder.get_found ())) { + + PointSnapToObjectResult res; + res.snapped_point = closest; + return res; + } else if (finder.any ()) { - return std::make_pair (true, finder.get_found ()); + + PointSnapToObjectResult res; + res.snapped_point = finder.get_found (); + res.object_ref = finder.get_found_edge (); + if (finder.is_vertex ()) { + res.object_snap = PointSnapToObjectResult::ObjectVertex; + } else if (finder.has_found_edge ()) { + res.object_snap = PointSnapToObjectResult::ObjectEdge; + } else { + res.object_snap = PointSnapToObjectResult::ObjectUnspecific; + } + return res; + } else if (anyp) { - return std::make_pair (false, closest); + + PointSnapToObjectResult res; + res.snapped_point = closest; + return res; + } else { - return std::make_pair (false, dp); + + PointSnapToObjectResult res; + res.snapped_point = dp; + return res; + } } -std::pair +static TwoPointSnapToObjectResult do_obj_snap2 (lay::LayoutView *view, const db::DPoint &pt1, const db::DPoint &pt2, const db::DVector &grid, double min_search_range, double max_search_range, const std::vector &cutlines) { db::DPoint dp1 (pt1); @@ -828,15 +848,41 @@ do_obj_snap2 (lay::LayoutView *view, const db::DPoint &pt1, const db::DPoint &pt finder2.find (view, sr2); if (finder2.any_exact ()) { + db::DPoint p2 = finder2.get_found (); - return std::make_pair (true, db::DEdge (p1, p2)); + + TwoPointSnapToObjectResult res; + res.any = true; + res.first = p1; + res.second = p2; + + res.object_ref_first = finder.get_found_edge (); + if (finder.is_vertex ()) { + res.object_snap_first = TwoPointSnapToObjectResult::ObjectVertex; + } else if (finder.has_found_edge ()) { + res.object_snap_first = TwoPointSnapToObjectResult::ObjectEdge; + } else { + res.object_snap_first = TwoPointSnapToObjectResult::ObjectUnspecific; + } + + res.object_ref_second = finder2.get_found_edge (); + if (finder2.is_vertex ()) { + res.object_snap_second = TwoPointSnapToObjectResult::ObjectVertex; + } else if (finder2.has_found_edge ()) { + res.object_snap_second = TwoPointSnapToObjectResult::ObjectEdge; + } else { + res.object_snap_second = TwoPointSnapToObjectResult::ObjectUnspecific; + } + + return res; + } sr2 *= 2.0; } - return std::make_pair (false, db::DEdge ()); + return TwoPointSnapToObjectResult (); } @@ -844,7 +890,7 @@ do_obj_snap2 (lay::LayoutView *view, const db::DPoint &pt1, const db::DPoint &pt } - return std::make_pair (false, db::DEdge ()); + return TwoPointSnapToObjectResult (); } static void @@ -868,13 +914,13 @@ make_cutlines (lay::angle_constraint_type snap_mode, const db::DPoint &p1, std:: } } -std::pair +PointSnapToObjectResult obj_snap (lay::LayoutView *view, const db::DPoint &pt, const db::DVector &grid, double snap_range) { return do_obj_snap (view, pt, grid, snap_range, std::vector ()); } -std::pair +PointSnapToObjectResult obj_snap (lay::LayoutView *view, const db::DPoint &p1, const db::DPoint &p2, const db::DVector &grid, lay::angle_constraint_type snap_mode, double snap_range) { std::vector cutlines; @@ -882,19 +928,19 @@ obj_snap (lay::LayoutView *view, const db::DPoint &p1, const db::DPoint &p2, con return do_obj_snap (view, p2, grid, snap_range, cutlines); } -std::pair +TwoPointSnapToObjectResult obj_snap2 (lay::LayoutView *view, const db::DPoint &pt, const db::DVector &grid, double min_search_range, double max_search_range) { return obj_snap2 (view, pt, pt, grid, min_search_range, max_search_range); } -std::pair +TwoPointSnapToObjectResult obj_snap2 (lay::LayoutView *view, const db::DPoint &pt, const db::DVector &grid, lay::angle_constraint_type ac, double min_search_range, double max_search_range) { return obj_snap2 (view, pt, pt, grid, ac, min_search_range, max_search_range); } -std::pair +TwoPointSnapToObjectResult obj_snap2 (lay::LayoutView *view, const db::DPoint &pt1, const db::DPoint &pt2, const db::DVector &grid, double min_search_range, double max_search_range) { db::DPoint dp1 = lay::snap_xy (pt1, grid); @@ -903,7 +949,7 @@ obj_snap2 (lay::LayoutView *view, const db::DPoint &pt1, const db::DPoint &pt2, return do_obj_snap2 (view, dp1, dp2, db::DVector (), min_search_range, max_search_range, std::vector ()); } -std::pair +TwoPointSnapToObjectResult obj_snap2 (lay::LayoutView *view, const db::DPoint &pt1, const db::DPoint &pt2, const db::DVector &grid, lay::angle_constraint_type snap_mode, double min_search_range, double max_search_range) { db::DPoint dp1 = lay::snap_xy (pt1, grid); diff --git a/src/laybasic/laybasic/laySnap.h b/src/laybasic/laybasic/laySnap.h index 8ac286b24..b2a1b3645 100644 --- a/src/laybasic/laybasic/laySnap.h +++ b/src/laybasic/laybasic/laySnap.h @@ -108,6 +108,36 @@ namespace lay */ LAYBASIC_PUBLIC std::pair snap (const db::DPoint &p1, const db::DPoint &p2, db::DCoord grid); + /** + * @brief A structure describing the snap result for a point-wise snap + */ + struct LAYBASIC_PUBLIC PointSnapToObjectResult + { + enum ObjectSnap { + NoObject = 0, + ObjectVertex, + ObjectEdge, + ObjectUnspecific + }; + + PointSnapToObjectResult () : object_snap (NoObject) { } + + /** + * @brief The result of the snap + */ + db::DPoint snapped_point; + + /** + * @brief Indicates whether and how the point was snapped to an object + */ + ObjectSnap object_snap; + + /** + * @brief Indicates the edge the point was snapped against unless in NoObject mode + */ + db::DEdge object_ref; + }; + /** * @brief combined grid-, projection- and object snapping provided to implementing "magnetic features" * @@ -115,17 +145,14 @@ namespace lay * to an object edge or point. It will use a heuristics to determine * what criterion is applied if a conflict is detected. * - * The function will return a pair of the "stiffness" flag and the resulting point. The - * "stiffness" is a measure if the result point can be moved if another snap will be applied. - * It is true if the point is not intended to be moved further, i.e. because it snapped to - * a grid point or a object vertex. + * The function will return a PointSnapToObjectResult object. * * @param view The layout view used for object snapping. Can be 0 to disable object snapping * @param pt The point to snap * @param grid Either (0,0) to disable grid snapping or a (gx,gy) value for the (potentially anisotropic grid) * @param snap_range The search range for objects */ - LAYBASIC_PUBLIC std::pair obj_snap (lay::LayoutView *view, const db::DPoint &pt, const db::DVector &grid, double snap_range); + LAYBASIC_PUBLIC PointSnapToObjectResult obj_snap (lay::LayoutView *view, const db::DPoint &pt, const db::DVector &grid, double snap_range); /** * @brief combined grid-, projection- and object snapping provided to implementing "magnetic features" @@ -133,7 +160,45 @@ namespace lay * This is a convenience method that creates the projection axes from a reference point and an angle mode. * "pr" is the reference point, "pt" is the point to snap. */ - LAYBASIC_PUBLIC std::pair obj_snap (lay::LayoutView *view, const db::DPoint &pr, const db::DPoint &pt, const db::DVector &grid, lay::angle_constraint_type ac, double snap_range); + LAYBASIC_PUBLIC PointSnapToObjectResult obj_snap (lay::LayoutView *view, const db::DPoint &pr, const db::DPoint &pt, const db::DVector &grid, lay::angle_constraint_type ac, double snap_range); + + /** + * @brief A structure describing the snap result for a two-sided object snap (distance measurement) + */ + struct LAYBASIC_PUBLIC TwoPointSnapToObjectResult + { + enum ObjectSnap { + NoObject = 0, + ObjectVertex, + ObjectEdge, + ObjectUnspecific + }; + + TwoPointSnapToObjectResult () : any (false), object_snap_first (NoObject), object_snap_second (NoObject) { } + + /** + * @brief Indicates whether the two-sided snap was successful + */ + bool any; + + /** + * @brief The result of the snap + * Two values are provided for the first and second snap. + */ + db::DPoint first, second; + + /** + * @brief Indicates whether and how the point was snapped to an object + * Two values are provided for the first and second snap. + */ + ObjectSnap object_snap_first, object_snap_second; + + /** + * @brief Indicates the edge the point was snapped against unless in NoObject mode + * Two values are provided for the first and second snap. + */ + db::DEdge object_ref_first, object_ref_second; + }; /** * @brief Same than obj_snap, but delivers two points on two opposite sides of the initial point @@ -141,7 +206,7 @@ namespace lay * This method basically implements "auto measure". The first value of the returned pair * is true if such an edge could be found. Otherwise it's false. */ - LAYBASIC_PUBLIC std::pair obj_snap2 (lay::LayoutView *view, const db::DPoint &pt, const db::DVector &grid, double min_search_range, double max_search_range); + LAYBASIC_PUBLIC TwoPointSnapToObjectResult obj_snap2 (lay::LayoutView *view, const db::DPoint &pt, const db::DVector &grid, double min_search_range, double max_search_range); /** * @brief Same than obj_snap, but delivers two points on two opposite sides of the initial points @@ -151,14 +216,14 @@ namespace lay * * This version accepts two points defining different search regions for first and second edge. */ - LAYBASIC_PUBLIC std::pair obj_snap2 (lay::LayoutView *view, const db::DPoint &pt1, const db::DPoint &pt2, const db::DVector &grid, double min_search_range, double max_search_range); + LAYBASIC_PUBLIC TwoPointSnapToObjectResult obj_snap2 (lay::LayoutView *view, const db::DPoint &pt1, const db::DPoint &pt2, const db::DVector &grid, double min_search_range, double max_search_range); /** * @brief Same than the previous obj_snap2, but allows specification of an angle constraint * * Measurements will be confined to the direction specified. */ - LAYBASIC_PUBLIC std::pair obj_snap2 (lay::LayoutView *view, const db::DPoint &pt, const db::DVector &grid, lay::angle_constraint_type ac, double min_search_range, double max_search_range); + LAYBASIC_PUBLIC TwoPointSnapToObjectResult obj_snap2 (lay::LayoutView *view, const db::DPoint &pt, const db::DVector &grid, lay::angle_constraint_type ac, double min_search_range, double max_search_range); /** * @brief Same than the previous obj_snap2, but allows specification of an angle constraint @@ -167,7 +232,7 @@ namespace lay * * This version accepts two points defining different search regions for first and second edge. */ - LAYBASIC_PUBLIC std::pair obj_snap2 (lay::LayoutView *view, const db::DPoint &pt1, const db::DPoint &pt2, const db::DVector &grid, lay::angle_constraint_type ac, double min_search_range, double max_search_range); + LAYBASIC_PUBLIC TwoPointSnapToObjectResult obj_snap2 (lay::LayoutView *view, const db::DPoint &pt1, const db::DPoint &pt2, const db::DVector &grid, lay::angle_constraint_type ac, double min_search_range, double max_search_range); /** * @brief Reduce a given vector according to the angle constraint diff --git a/src/laybasic/unit_tests/laySnap.cc b/src/laybasic/unit_tests/laySnapTests.cc similarity index 55% rename from src/laybasic/unit_tests/laySnap.cc rename to src/laybasic/unit_tests/laySnapTests.cc index 39a177a1f..9b2c37d03 100644 --- a/src/laybasic/unit_tests/laySnap.cc +++ b/src/laybasic/unit_tests/laySnapTests.cc @@ -51,95 +51,101 @@ TEST(1) view.set_max_hier_levels (1); - std::pair res; + lay::PointSnapToObjectResult res; // not hit res = lay::obj_snap (&view, db::DPoint (1.505, 1.505), db::DVector (), 0.1); - EXPECT_EQ (res.first, false); - EXPECT_EQ (res.second.to_string (), "1.505,1.505"); + EXPECT_EQ (res.object_snap, lay::PointSnapToObjectResult::NoObject); + EXPECT_EQ (res.snapped_point.to_string (), "1.505,1.505"); res = lay::obj_snap (&view, db::DPoint (0.505, 0.505), db::DVector (), 0.1); - EXPECT_EQ (res.first, true); - EXPECT_EQ (res.second.to_string (), "0.5,0.5"); + EXPECT_EQ (res.object_snap, lay::PointSnapToObjectResult::ObjectEdge); + EXPECT_EQ (res.snapped_point.to_string (), "0.5,0.5"); res = lay::obj_snap (&view, db::DPoint (0.485, 0.505), db::DVector (0.01, 0.01), 0.1); - EXPECT_EQ (res.first, true); - EXPECT_EQ (res.second.to_string (), "0.49,0.51"); + EXPECT_EQ (res.object_snap, lay::PointSnapToObjectResult::ObjectEdge); + EXPECT_EQ (res.snapped_point.to_string (), "0.49,0.51"); + EXPECT_EQ (res.object_ref.to_string (), "(0,1;1,0)"); res = lay::obj_snap (&view, db::DPoint (0.205, 0.215), db::DVector (0.01, 0.025), 0.1); - EXPECT_EQ (res.first, false); - EXPECT_EQ (res.second.to_string (), "0.21,0.225"); + EXPECT_EQ (res.object_snap, lay::PointSnapToObjectResult::NoObject); + EXPECT_EQ (res.snapped_point.to_string (), "0.21,0.225"); res = lay::obj_snap (&view, db::DPoint (0.505, 1.005), db::DVector (), 0.1); - EXPECT_EQ (res.first, false); - EXPECT_EQ (res.second.to_string (), "0.505,1.005"); + EXPECT_EQ (res.object_snap, lay::PointSnapToObjectResult::NoObject); + EXPECT_EQ (res.snapped_point.to_string (), "0.505,1.005"); res = lay::obj_snap (&view, db::DPoint (0.005, 1.005), db::DVector (), 0.1); - EXPECT_EQ (res.first, true); - EXPECT_EQ (res.second.to_string (), "0,1"); + EXPECT_EQ (res.object_snap, lay::PointSnapToObjectResult::ObjectVertex); + EXPECT_EQ (res.snapped_point.to_string (), "0,1"); + + res = lay::obj_snap (&view, db::DPoint (0.0, 1.005), db::DVector (), 0.1); + EXPECT_EQ (res.object_snap, lay::PointSnapToObjectResult::ObjectVertex); + EXPECT_EQ (res.snapped_point.to_string (), "0,1"); res = lay::obj_snap (&view, db::DPoint (1.000, 0.505), db::DPoint (0.505, 0.500), db::DVector (), lay::AC_Horizontal, 0.1); - EXPECT_EQ (res.first, true); - EXPECT_EQ (res.second.to_string (), "0.495,0.505"); + EXPECT_EQ (res.object_snap, lay::PointSnapToObjectResult::ObjectEdge); + EXPECT_EQ (res.snapped_point.to_string (), "0.495,0.505"); // projected snapping res = lay::obj_snap (&view, db::DPoint (1.000, 0.505), db::DPoint (0.005, 1.005), db::DVector (), lay::AC_Horizontal, 0.1); - EXPECT_EQ (res.first, true); - EXPECT_EQ (res.second.to_string (), "0,0.505"); + EXPECT_EQ (res.object_snap, lay::PointSnapToObjectResult::ObjectUnspecific); + EXPECT_EQ (res.snapped_point.to_string (), "0,0.505"); + EXPECT_EQ (res.object_ref.to_string (), "(0,1;0,1)"); - std::pair res2; + lay::TwoPointSnapToObjectResult res2; res2 = lay::obj_snap2 (&view, db::DPoint (1.5, 1.5), db::DVector (), 0.005, 1.0); - EXPECT_EQ (res2.first, false); - EXPECT_EQ (res2.second.to_string (), "(0,0;0,0)"); + EXPECT_EQ (res2.any, false); + EXPECT_EQ (db::DEdge (res2.first, res2.second).to_string (), "(0,0;0,0)"); res2 = lay::obj_snap2 (&view, db::DPoint (0.205, 0.5), db::DVector (), 0.005, 1.0); - EXPECT_EQ (res2.first, true); - EXPECT_EQ (res2.second.to_string (), "(0.3525,0.6475;0,0.295)"); + EXPECT_EQ (res2.any, true); + EXPECT_EQ (db::DEdge (res2.first, res2.second).to_string (), "(0.3525,0.6475;0,0.295)"); res2 = lay::obj_snap2 (&view, db::DPoint (0.205, 0.5), db::DVector (), lay::AC_Horizontal, 0.005, 1.0); - EXPECT_EQ (res2.first, true); - EXPECT_EQ (res2.second.to_string (), "(0,0.5;0.5,0.5)"); + EXPECT_EQ (res2.any, true); + EXPECT_EQ (db::DEdge (res2.first, res2.second).to_string (), "(0,0.5;0.5,0.5)"); res2 = lay::obj_snap2 (&view, db::DPoint (0.205, 0.5), db::DVector (0.03, 0.03), lay::AC_Horizontal, 0.005, 1.0); - EXPECT_EQ (res2.first, true); - EXPECT_EQ (res2.second.to_string (), "(0,0.51;0.49,0.51)"); + EXPECT_EQ (res2.any, true); + EXPECT_EQ (db::DEdge (res2.first, res2.second).to_string (), "(0,0.51;0.49,0.51)"); res2 = lay::obj_snap2 (&view, db::DPoint (0.205, 0.5), db::DVector (), lay::AC_Vertical, 0.005, 1.0); - EXPECT_EQ (res2.first, true); - EXPECT_EQ (res2.second.to_string (), "(0.205,0.795;0.205,0)"); + EXPECT_EQ (res2.any, true); + EXPECT_EQ (db::DEdge (res2.first, res2.second).to_string (), "(0.205,0.795;0.205,0)"); res2 = lay::obj_snap2 (&view, db::DPoint (0.205, 0.5), db::DVector (), lay::AC_Diagonal, 0.005, 1.0); - EXPECT_EQ (res2.first, true); - EXPECT_EQ (res2.second.to_string (), "(0.3525,0.6475;0,0.295)"); + EXPECT_EQ (res2.any, true); + EXPECT_EQ (db::DEdge (res2.first, res2.second).to_string (), "(0.3525,0.6475;0,0.295)"); res2 = lay::obj_snap2 (&view, db::DPoint (0.205, 0.505), db::DVector (), lay::AC_Ortho, 0.005, 1.0); - EXPECT_EQ (res2.first, true); - EXPECT_EQ (res2.second.to_string (), "(0,0.505;0.495,0.505)"); + EXPECT_EQ (res2.any, true); + EXPECT_EQ (db::DEdge (res2.first, res2.second).to_string (), "(0,0.505;0.495,0.505)"); res2 = lay::obj_snap2 (&view, db::DPoint (0.205, 0.5), db::DVector (), lay::AC_Any, 0.005, 1.0); - EXPECT_EQ (res2.first, true); - EXPECT_EQ (res2.second.to_string (), "(0.3525,0.6475;0,0.295)"); + EXPECT_EQ (res2.any, true); + EXPECT_EQ (db::DEdge (res2.first, res2.second).to_string (), "(0.3525,0.6475;0,0.295)"); res2 = lay::obj_snap2 (&view, db::DPoint (0.205, 0.495), db::DVector (0.01, 0.01), 0.005, 1.0); - EXPECT_EQ (res2.first, true); - EXPECT_EQ (res2.second.to_string (), "(0.355,0.645;0,0.29)"); + EXPECT_EQ (res2.any, true); + EXPECT_EQ (db::DEdge (res2.first, res2.second).to_string (), "(0.355,0.645;0,0.29)"); res2 = lay::obj_snap2 (&view, db::DPoint (0.5, 0.5), db::DVector (), 0.005, 1.0); - EXPECT_EQ (res2.first, false); - EXPECT_EQ (res2.second.to_string (), "(0,0;0,0)"); + EXPECT_EQ (res2.any, false); + EXPECT_EQ (db::DEdge (res2.first, res2.second).to_string (), "(0,0;0,0)"); res2 = lay::obj_snap2 (&view, db::DPoint (0.005, 0.5), db::DVector (), 0.005, 1.0); - EXPECT_EQ (res2.first, true); - EXPECT_EQ (res2.second.to_string (), "(0,0.5;0.5,0.5)"); + EXPECT_EQ (res2.any, true); + EXPECT_EQ (db::DEdge (res2.first, res2.second).to_string (), "(0,0.5;0.5,0.5)"); res2 = lay::obj_snap2 (&view, db::DPoint (0.0, 0.5), db::DVector (), 0.005, 1.0); - EXPECT_EQ (res2.first, false); - EXPECT_EQ (res2.second.to_string (), "(0,0;0,0)"); + EXPECT_EQ (res2.any, false); + EXPECT_EQ (db::DEdge (res2.first, res2.second).to_string (), "(0,0;0,0)"); res2 = lay::obj_snap2 (&view, db::DPoint (-0.2, 0.5), db::DVector (), 0.005, 1.0); - EXPECT_EQ (res2.first, false); - EXPECT_EQ (res2.second.to_string (), "(0,0;0,0)"); + EXPECT_EQ (res2.any, false); + EXPECT_EQ (db::DEdge (res2.first, res2.second).to_string (), "(0,0;0,0)"); } diff --git a/src/laybasic/unit_tests/unit_tests.pro b/src/laybasic/unit_tests/unit_tests.pro index 0aeab4b3d..d948a1d87 100644 --- a/src/laybasic/unit_tests/unit_tests.pro +++ b/src/laybasic/unit_tests/unit_tests.pro @@ -13,10 +13,10 @@ SOURCES = \ layLayerProperties.cc \ layParsedLayerSource.cc \ layRenderer.cc \ - laySnap.cc \ layNetlistBrowserModelTests.cc \ layNetlistBrowserTreeModelTests.cc \ - layAbstractMenuTests.cc + layAbstractMenuTests.cc \ + laySnapTests.cc INCLUDEPATH += $$TL_INC $$LAYBASIC_INC $$DB_INC $$GSI_INC $$OUT_PWD/../laybasic DEPENDPATH += $$TL_INC $$LAYBASIC_INC $$DB_INC $$GSI_INC $$OUT_PWD/../laybasic