View: Fix snap-to-edge when using all signals

[pulseview.git] / pv / views / trace / view.cpp

diff --git a/pv/views/trace/view.cpp b/pv/views/trace/view.cpp
index 65b06aea82cba76279f185f40b4af933578a18dd..e68c16a8dc6013634e2add3f90025a4d25e84dda 100644 (file)
--- a/pv/views/trace/view.cpp
+++ b/pv/views/trace/view.cpp
@@ -79,6 +79,7 @@ using std::max;
 using std::make_pair;
 using std::make_shared;
 using std::min;
+using std::numeric_limits;
 using std::pair;
 using std::set;
 using std::set_difference;
@@ -178,6 +179,7 @@ View::View(Session &session, bool is_main_view, QWidget *parent) :
        // Set up settings and event handlers
        GlobalSettings settings;
        colored_bg_ = settings.value(GlobalSettings::Key_View_ColoredBG).toBool();
+       snap_distance_ = settings.value(GlobalSettings::Key_View_SnapDistance).toInt();
 
        GlobalSettings::add_change_handler(this);
 
@@ -320,6 +322,11 @@ void View::remove_decode_signal(shared_ptr<data::DecodeSignal> signal)
 }
 #endif
 
+shared_ptr<Signal> View::get_signal_under_mouse_cursor() const
+{
+       return signal_under_mouse_cursor_;
+}
+
 View* View::view()
 {
        return this;
@@ -853,6 +860,83 @@ const QPoint& View::hover_point() const
        return hover_point_;
 }
 
+int64_t View::get_nearest_level_change(const QPoint &p)
+{
+       if (snap_distance_ == 0)
+               return -1;
+
+       shared_ptr<Signal> signal = signal_under_mouse_cursor_;
+
+       vector<data::LogicSegment::EdgePair> nearest_edges;
+       int64_t nearest_sample = -1;
+
+       if (signal) {
+               // Determine nearest edge from specific signal
+
+               // Calculate sample number from cursor position
+               const double samples_per_pixel = signal->base()->get_samplerate() * scale();
+               const int64_t x_offset = offset().convert_to<double>() / scale();
+               const int64_t sample_num = max(((x_offset + p.x()) * samples_per_pixel), 0.0);
+
+               nearest_edges = signal->get_nearest_level_changes(sample_num);
+
+               if (nearest_edges.size() != 2)
+                       return -1;
+
+               // We received absolute sample numbers, make them relative
+               const int64_t left_sample_delta = sample_num - nearest_edges.front().first;
+               const int64_t right_sample_delta = nearest_edges.back().first - sample_num - 1;
+
+               const int64_t left_delta = left_sample_delta / samples_per_pixel;
+               const int64_t right_delta = right_sample_delta / samples_per_pixel;
+
+               // Only use closest left or right edge if they're close to the cursor
+               if ((left_delta < right_delta) && (left_delta <= snap_distance_))
+                       nearest_sample = nearest_edges.front().first;
+               if ((left_delta >= right_delta) && (right_delta <= snap_distance_))
+                       nearest_sample = nearest_edges.back().first;
+       } else {
+               // Determine nearest edge from all signals
+
+               int64_t nearest_delta = numeric_limits<int64_t>::max();
+               for (shared_ptr<Signal> s : signals_) {
+                       if (!s->enabled())
+                               continue;
+
+                       // Calculate sample number from cursor position
+                       const double samples_per_pixel = s->base()->get_samplerate() * scale();
+                       const int64_t x_offset = offset().convert_to<double>() / scale();
+                       const int64_t sample_num = max(((x_offset + p.x()) * samples_per_pixel), 0.0);
+
+                       vector<data::LogicSegment::EdgePair> edges =
+                               s->get_nearest_level_changes(sample_num);
+
+                       if (edges.size() != 2)
+                               continue;
+
+                       // We received absolute sample numbers, make them relative
+                       const int64_t left_sample_delta = sample_num - edges.front().first;
+                       const int64_t right_sample_delta = edges.back().first - sample_num - 1;
+
+                       const int64_t left_delta = left_sample_delta / samples_per_pixel;
+                       const int64_t right_delta = right_sample_delta / samples_per_pixel;
+
+                       if ((left_delta < nearest_delta) || (right_delta < nearest_delta)) {
+                               nearest_delta = min(left_delta, right_delta);
+
+                               if (nearest_delta <= snap_distance_)
+                                       nearest_sample = (nearest_delta == left_delta) ?
+                                               edges.front().first : edges.back().first;
+
+                               // Somewhat ugly hack to make TimeItem::drag_by() work
+                               signal_under_mouse_cursor_ = s;
+                       }
+               }
+       }
+
+       return nearest_sample;
+}
+
 void View::restack_all_trace_tree_items()
 {
        // Make a list of owners that is sorted from deepest first
@@ -884,6 +968,11 @@ void View::on_setting_changed(const QString &key, const QVariant &value)
 {
        if (key == GlobalSettings::Key_View_TriggerIsZeroTime)
                on_settingViewTriggerIsZeroTime_changed(value);
+
+       if (key == GlobalSettings::Key_View_SnapDistance) {
+               GlobalSettings settings;
+               snap_distance_ = settings.value(GlobalSettings::Key_View_SnapDistance).toInt();
+       }
 }
 
 void View::trigger_event(int segment_id, util::Timestamp location)
@@ -1215,7 +1304,10 @@ bool View::eventFilter(QObject *object, QEvent *event)
                if (object == viewport_)
                        hover_point_ = mouse_event->pos();
                else if (object == ruler_)
-                       hover_point_ = QPoint(mouse_event->x(), 0);
+                       // Adjust the hover point's y coordinate so that it's relative to
+                       // the top of the viewport. The result may be negative.
+                       hover_point_ = QPoint(mouse_event->pos().x(),
+                               mouse_event->pos().y() - ruler_->sizeHint().height());
                else if (object == header_)
                        hover_point_ = QPoint(0, mouse_event->y());
                else
@@ -1280,11 +1372,24 @@ void View::resizeEvent(QResizeEvent* event)
 
 void View::update_hover_point()
 {
+       // Determine signal that the mouse cursor is hovering over
+       signal_under_mouse_cursor_.reset();
+       for (shared_ptr<Signal> s : signals_) {
+               const pair<int, int> extents = s->v_extents();
+               const int top = s->get_visual_y() + extents.first;
+               const int btm = s->get_visual_y() + extents.second;
+               if ((hover_point_.y() >= top) && (hover_point_.y() <= btm)
+                       && s->base()->enabled())
+                       signal_under_mouse_cursor_ = s;
+       }
+
+       // Update all trace tree items
        const vector<shared_ptr<TraceTreeItem>> trace_tree_items(
                list_by_type<TraceTreeItem>());
        for (shared_ptr<TraceTreeItem> r : trace_tree_items)
                r->hover_point_changed(hover_point_);
 
+       // Notify any other listeners
        hover_point_changed(hover_point_);
 }