X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fviews%2Ftrace%2Fview.cpp;h=47cb96b2da3ce6c2125a39472928e8e1a63cb1b0;hp=6a9c01af731180378de18a45c9c3e2affe34286d;hb=4640a84e926ac4b82e2a1b6ef9fc80ef44c2bd3c;hpb=d0c0573b3ee694827a747727f862c5f91736ca05 diff --git a/pv/views/trace/view.cpp b/pv/views/trace/view.cpp index 6a9c01af..47cb96b2 100644 --- a/pv/views/trace/view.cpp +++ b/pv/views/trace/view.cpp @@ -29,42 +29,43 @@ #include #include #include -#include - -#include -#include -#include #include +#include #include #include +#include #include #include #include #include -#include "analogsignal.hpp" -#include "header.hpp" -#include "logicsignal.hpp" -#include "ruler.hpp" -#include "signal.hpp" -#include "tracegroup.hpp" -#include "triggermarker.hpp" #include "view.hpp" -#include "viewport.hpp" -#include "pv/data/logic.hpp" -#include "pv/data/logicsegment.hpp" -#include "pv/devices/device.hpp" #include "pv/globalsettings.hpp" +#include "pv/metadata_obj.hpp" #include "pv/session.hpp" #include "pv/util.hpp" +#include "pv/data/logic.hpp" +#include "pv/data/logicsegment.hpp" +#include "pv/data/signalbase.hpp" +#include "pv/devices/device.hpp" +#include "pv/views/trace/mathsignal.hpp" +#include "pv/views/trace/analogsignal.hpp" +#include "pv/views/trace/header.hpp" +#include "pv/views/trace/logicsignal.hpp" +#include "pv/views/trace/ruler.hpp" +#include "pv/views/trace/signal.hpp" +#include "pv/views/trace/tracegroup.hpp" +#include "pv/views/trace/triggermarker.hpp" +#include "pv/views/trace/viewport.hpp" #ifdef ENABLE_DECODE -#include "decodetrace.hpp" +#include "pv/views/trace/decodetrace.hpp" #endif +using pv::data::SignalBase; using pv::data::SignalData; using pv::data::Segment; using pv::util::TimeUnit; @@ -74,18 +75,16 @@ using std::back_inserter; using std::copy_if; using std::count_if; using std::inserter; +using std::lock_guard; using std::max; using std::make_pair; using std::make_shared; using std::min; +using std::numeric_limits; using std::pair; -using std::placeholders::_1; using std::set; using std::set_difference; using std::shared_ptr; -using std::stringstream; -using std::unordered_map; -using std::unordered_set; using std::vector; namespace pv { @@ -97,8 +96,10 @@ const Timestamp View::MinScale("1e-12"); const int View::MaxScrollValue = INT_MAX / 2; -const int View::ScaleUnits[3] = {1, 2, 5}; +/* Area at the top and bottom of the view that can't be scrolled out of sight */ +const int View::ViewScrollMargin = 50; +const int View::ScaleUnits[3] = {1, 2, 5}; CustomScrollArea::CustomScrollArea(QWidget *parent) : QAbstractScrollArea(parent) @@ -123,33 +124,14 @@ bool CustomScrollArea::viewportEvent(QEvent *event) } } -View::View(Session &session, bool is_main_view, QWidget *parent) : +View::View(Session &session, bool is_main_view, QMainWindow *parent) : ViewBase(session, is_main_view, parent), + + // Note: Place defaults in View::reset_view_state(), not here splitter_(new QSplitter()), - segment_display_mode_(Trace::ShowLastSegmentOnly), - segment_selectable_(false), - scale_(1e-3), - offset_(0), - ruler_offset_(0), - updating_scroll_(false), - settings_restored_(false), - header_was_shrunk_(false), - sticky_scrolling_(false), // Default setting is set in MainWindow::setup_ui() - always_zoom_to_fit_(false), - tick_period_(0), - tick_prefix_(pv::util::SIPrefix::yocto), - tick_precision_(0), - time_unit_(util::TimeUnit::Time), - show_cursors_(false), - cursors_(new CursorPair(*this)), - next_flag_text_('A'), - trigger_markers_(), - hover_point_(-1, -1), - scroll_needs_defaults_(true), - saved_v_offset_(0), - scale_at_acq_start_(0), - offset_at_acq_start_(0), - suppress_zoom_to_fit_after_acq_(false) + header_was_shrunk_(false), // The splitter remains unchanged after a reset, so this goes here + sticky_scrolling_(false), // Default setting is set in MainWindow::setup_ui() + scroll_needs_defaults_(true) { QVBoxLayout *root_layout = new QVBoxLayout(this); root_layout->setContentsMargins(0, 0, 0, 0); @@ -197,10 +179,18 @@ View::View(Session &session, bool is_main_view, QWidget *parent) : // Set up settings and event handlers GlobalSettings settings; - coloured_bg_ = settings.value(GlobalSettings::Key_View_ColouredBG).toBool(); + colored_bg_ = settings.value(GlobalSettings::Key_View_ColoredBG).toBool(); + snap_distance_ = settings.value(GlobalSettings::Key_View_SnapDistance).toInt(); GlobalSettings::add_change_handler(this); + // Set up metadata objects and event handlers + if (is_main_view) { + session_.metadata_obj_manager()->create_object(MetadataObjMainViewRange); + session_.metadata_obj_manager()->create_object(MetadataObjMousePos); + } + + // Set up UI event handlers connect(scrollarea_->horizontalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(h_scroll_value_changed(int))); connect(scrollarea_->verticalScrollBar(), SIGNAL(valueChanged(int)), @@ -222,25 +212,109 @@ View::View(Session &session, bool is_main_view, QWidget *parent) : connect(&lazy_event_handler_, SIGNAL(timeout()), this, SLOT(process_sticky_events())); lazy_event_handler_.setSingleShot(true); + lazy_event_handler_.setInterval(1000 / ViewBase::MaxViewAutoUpdateRate); + + // Set up local keyboard shortcuts + zoom_in_shortcut_ = new QShortcut(QKeySequence(Qt::Key_Plus), this, + SLOT(on_zoom_in_shortcut_triggered()), nullptr, Qt::WidgetWithChildrenShortcut); + zoom_in_shortcut_->setAutoRepeat(false); + + zoom_out_shortcut_ = new QShortcut(QKeySequence(Qt::Key_Minus), this, + SLOT(on_zoom_out_shortcut_triggered()), nullptr, Qt::WidgetWithChildrenShortcut); + zoom_out_shortcut_->setAutoRepeat(false); + + zoom_in_shortcut_2_ = new QShortcut(QKeySequence(Qt::Key_Up), this, + SLOT(on_zoom_in_shortcut_triggered()), nullptr, Qt::WidgetWithChildrenShortcut); + zoom_out_shortcut_2_ = new QShortcut(QKeySequence(Qt::Key_Down), this, + SLOT(on_zoom_out_shortcut_triggered()), nullptr, Qt::WidgetWithChildrenShortcut); + + home_shortcut_ = new QShortcut(QKeySequence(Qt::Key_Home), this, + SLOT(on_scroll_to_start_shortcut_triggered()), nullptr, Qt::WidgetWithChildrenShortcut); + home_shortcut_->setAutoRepeat(false); + + end_shortcut_ = new QShortcut(QKeySequence(Qt::Key_End), this, + SLOT(on_scroll_to_end_shortcut_triggered()), nullptr, Qt::WidgetWithChildrenShortcut); + end_shortcut_->setAutoRepeat(false); + + grab_ruler_left_shortcut_ = new QShortcut(QKeySequence(Qt::Key_1), this, + nullptr, nullptr, Qt::WidgetWithChildrenShortcut); + connect(grab_ruler_left_shortcut_, &QShortcut::activated, + this, [=]{on_grab_ruler(1);}); + grab_ruler_left_shortcut_->setAutoRepeat(false); + + grab_ruler_right_shortcut_ = new QShortcut(QKeySequence(Qt::Key_2), this, + nullptr, nullptr, Qt::WidgetWithChildrenShortcut); + connect(grab_ruler_right_shortcut_, &QShortcut::activated, + this, [=]{on_grab_ruler(2);}); + grab_ruler_right_shortcut_->setAutoRepeat(false); + + cancel_grab_shortcut_ = new QShortcut(QKeySequence(Qt::Key_Escape), this, + nullptr, nullptr, Qt::WidgetWithChildrenShortcut); + connect(cancel_grab_shortcut_, &QShortcut::activated, + this, [=]{grabbed_widget_ = nullptr;}); + cancel_grab_shortcut_->setAutoRepeat(false); // Trigger the initial event manually. The default device has signals // which were created before this object came into being signals_changed(); - // make sure the transparent widgets are on the top + // Make sure the transparent widgets are on the top ruler_->raise(); header_->raise(); + reset_view_state(); +} + +View::~View() +{ + GlobalSettings::remove_change_handler(this); +} + +ViewType View::get_type() const +{ + return ViewTypeTrace; +} + +void View::reset_view_state() +{ + ViewBase::reset_view_state(); + + segment_display_mode_ = Trace::ShowLastSegmentOnly; + segment_selectable_ = false; + scale_ = 1e-3; + offset_ = 0; + ruler_offset_ = 0; + zero_offset_ = 0; + custom_zero_offset_set_ = false; + updating_scroll_ = false; + restoring_state_ = false; + always_zoom_to_fit_ = false; + tick_period_ = 0; + tick_prefix_ = pv::util::SIPrefix::yocto; + tick_precision_ = 0; + time_unit_ = util::TimeUnit::Time; + show_cursors_ = false; + cursors_ = make_shared(*this); + next_flag_text_ = 'A'; + trigger_markers_.clear(); + hover_widget_ = nullptr; + grabbed_widget_ = nullptr; + hover_point_ = QPoint(-1, -1); + scroll_needs_defaults_ = true; + scale_at_acq_start_ = 0; + offset_at_acq_start_ = 0; + + show_cursors_ = false; + cursor_state_changed(show_cursors_); + flags_.clear(); + // Update the zoom state calculate_tick_spacing(); // Make sure the standard bar's segment selector is in sync set_segment_display_mode(segment_display_mode_); -} -View::~View() -{ - GlobalSettings::remove_change_handler(this); + scrollarea_->verticalScrollBar()->setRange(-100000000, 100000000); } Session& View::session() @@ -253,37 +327,93 @@ const Session& View::session() const return session_; } -unordered_set< shared_ptr > View::signals() const +vector< shared_ptr > View::signals() const { return signals_; } -void View::clear_signals() +shared_ptr View::get_signal_by_signalbase(shared_ptr base) const +{ + shared_ptr ret_val; + + for (const shared_ptr& s : signals_) + if (s->base() == base) { + ret_val = s; + break; + } + + return ret_val; +} + +void View::clear_signalbases() { ViewBase::clear_signalbases(); signals_.clear(); } -void View::add_signal(const shared_ptr signal) +void View::add_signalbase(const shared_ptr signalbase) { - ViewBase::add_signalbase(signal->base()); - signals_.insert(signal); + ViewBase::add_signalbase(signalbase); + + shared_ptr signal; + + switch (signalbase->type()) { + case SignalBase::LogicChannel: + signal = shared_ptr(new LogicSignal(session_, session_.device(), signalbase)); + break; + + case SignalBase::AnalogChannel: + signal = shared_ptr(new AnalogSignal(session_, signalbase)); + break; + + case SignalBase::MathChannel: + signal = shared_ptr(new MathSignal(session_, signalbase)); + break; + + default: + qDebug() << "Unknown signalbase type:" << signalbase->type(); + assert(false); + break; + } + + signals_.push_back(signal); signal->set_segment_display_mode(segment_display_mode_); signal->set_current_segment(current_segment_); + // Secondary views use the signal's settings in the main view + if (!is_main_view()) { + shared_ptr main_tv = dynamic_pointer_cast(session_.main_view()); + shared_ptr main_signal = main_tv->get_signal_by_signalbase(signalbase); + if (main_signal) + signal->restore_settings(main_signal->save_settings()); + } + connect(signal->base().get(), SIGNAL(name_changed(const QString&)), this, SLOT(on_signal_name_changed())); } +void View::remove_signalbase(const shared_ptr signalbase) +{ + ViewBase::remove_signalbase(signalbase); + + shared_ptr signal = get_signal_by_signalbase(signalbase); + + if (signal) + remove_trace(signal); +} + #ifdef ENABLE_DECODE void View::clear_decode_signals() { + ViewBase::clear_decode_signals(); decode_traces_.clear(); } void View::add_decode_signal(shared_ptr signal) { + ViewBase::add_decode_signal(signal); + shared_ptr d( new DecodeTrace(session_, signal, decode_traces_.size())); decode_traces_.push_back(d); @@ -300,12 +430,39 @@ void View::remove_decode_signal(shared_ptr signal) for (auto i = decode_traces_.begin(); i != decode_traces_.end(); i++) if ((*i)->base() == signal) { decode_traces_.erase(i); - signals_changed(); - return; + break; } + + ViewBase::remove_decode_signal(signal); } #endif +void View::remove_trace(shared_ptr trace) +{ + TraceTreeItemOwner *const owner = trace->owner(); + assert(owner); + owner->remove_child_item(trace); + + for (auto i = signals_.begin(); i != signals_.end(); i++) + if ((*i) == trace) { + signals_.erase(i); + break; + } + + if (!header_was_shrunk_) + resize_header_to_fit(); + + update_layout(); + + header_->update(); + viewport_->update(); +} + +shared_ptr View::get_signal_under_mouse_cursor() const +{ + return signal_under_mouse_cursor_; +} + View* View::view() { return this; @@ -326,6 +483,16 @@ const Viewport* View::viewport() const return viewport_; } +QAbstractScrollArea* View::scrollarea() const +{ + return scrollarea_; +} + +const Ruler* View::ruler() const +{ + return ruler_; +} + void View::save_settings(QSettings &settings) const { settings.setValue("scale", scale_); @@ -335,20 +502,14 @@ void View::save_settings(QSettings &settings) const settings.setValue("splitter_state", splitter_->saveState()); settings.setValue("segment_display_mode", segment_display_mode_); - { - stringstream ss; - boost::archive::text_oarchive oa(ss); - oa << boost::serialization::make_nvp("ruler_shift", ruler_shift_); - settings.setValue("ruler_shift", QString::fromStdString(ss.str())); - } - { - stringstream ss; - boost::archive::text_oarchive oa(ss); - oa << boost::serialization::make_nvp("offset", offset_); - settings.setValue("offset", QString::fromStdString(ss.str())); - } + GlobalSettings::store_timestamp(settings, "offset", offset_); - for (shared_ptr signal : signals_) { + if (custom_zero_offset_set_) + GlobalSettings::store_timestamp(settings, "zero_offset", -zero_offset_); + else + settings.remove("zero_offset"); + + for (const shared_ptr& signal : signals_) { settings.beginGroup(signal->base()->internal_name()); signal->save_settings(settings); settings.endGroup(); @@ -363,29 +524,14 @@ void View::restore_settings(QSettings &settings) if (settings.contains("scale")) set_scale(settings.value("scale").toDouble()); - if (settings.contains("ruler_shift")) { - util::Timestamp shift; - stringstream ss; - ss << settings.value("ruler_shift").toString().toStdString(); - - boost::archive::text_iarchive ia(ss); - ia >> boost::serialization::make_nvp("ruler_shift", shift); - - ruler_shift_ = shift; - } - if (settings.contains("offset")) { - util::Timestamp offset; - stringstream ss; - ss << settings.value("offset").toString().toStdString(); - - boost::archive::text_iarchive ia(ss); - ia >> boost::serialization::make_nvp("offset", offset); - // This also updates ruler_offset_ - set_offset(offset); + set_offset(GlobalSettings::restore_timestamp(settings, "offset")); } + if (settings.contains("zero_offset")) + set_zero_position(GlobalSettings::restore_timestamp(settings, "zero_offset")); + if (settings.contains("splitter_state")) splitter_->restoreState(settings.value("splitter_state").toByteArray()); @@ -400,14 +546,12 @@ void View::restore_settings(QSettings &settings) } if (settings.contains("v_offset")) { + // Note: see eventFilter() for additional information saved_v_offset_ = settings.value("v_offset").toInt(); - set_v_offset(saved_v_offset_); scroll_needs_defaults_ = false; - // Note: see eventFilter() for additional information } - settings_restored_ = true; - suppress_zoom_to_fit_after_acq_ = true; + restoring_state_ = true; // Update the ruler so that it uses the new scale calculate_tick_spacing(); @@ -417,11 +561,14 @@ vector< shared_ptr > View::time_items() const { const vector> f(flags()); vector> items(f.begin(), f.end()); - items.push_back(cursors_); - items.push_back(cursors_->first()); - items.push_back(cursors_->second()); - for (auto trigger_marker : trigger_markers_) + if (cursors_) { + items.push_back(cursors_); + items.push_back(cursors_->first()); + items.push_back(cursors_->second()); + } + + for (auto& trigger_marker : trigger_markers_) items.push_back(trigger_marker); return items; @@ -436,6 +583,9 @@ void View::set_scale(double scale) { if (scale_ != scale) { scale_ = scale; + + update_view_range_metaobject(); + scale_changed(); } } @@ -444,7 +594,10 @@ void View::set_offset(const pv::util::Timestamp& offset, bool force_update) { if ((offset_ != offset) || force_update) { offset_ = offset; - ruler_offset_ = offset_ + ruler_shift_; + ruler_offset_ = offset_ + zero_offset_; + + update_view_range_metaobject(); + offset_changed(); } } @@ -459,9 +612,10 @@ const Timestamp& View::ruler_offset() const return ruler_offset_; } -void View::set_zero_position(pv::util::Timestamp& position) +void View::set_zero_position(const pv::util::Timestamp& position) { - ruler_shift_ = -position; + zero_offset_ = -position; + custom_zero_offset_set_ = true; // Force an immediate update of the offsets set_offset(offset_, true); @@ -470,13 +624,31 @@ void View::set_zero_position(pv::util::Timestamp& position) void View::reset_zero_position() { - ruler_shift_ = 0; + zero_offset_ = 0; + + // When enabled, the first trigger for this segment is used as the zero position + GlobalSettings settings; + bool trigger_is_zero_time = settings.value(GlobalSettings::Key_View_TriggerIsZeroTime).toBool(); + + if (trigger_is_zero_time) { + vector triggers = session_.get_triggers(current_segment_); + + if (triggers.size() > 0) + zero_offset_ = triggers.front(); + } + + custom_zero_offset_set_ = false; // Force an immediate update of the offsets set_offset(offset_, true); ruler_->update(); } +pv::util::Timestamp View::zero_offset() const +{ + return zero_offset_; +} + int View::owner_visual_v_offset() const { return -scrollarea_->verticalScrollBar()->sliderPosition(); @@ -489,6 +661,18 @@ void View::set_v_offset(int offset) viewport_->update(); } +void View::set_h_offset(int offset) +{ + scrollarea_->horizontalScrollBar()->setSliderPosition(offset); + header_->update(); + viewport_->update(); +} + +int View::get_h_scrollbar_maximum() const +{ + return scrollarea_->horizontalScrollBar()->maximum(); +} + unsigned int View::depth() const { return 0; @@ -560,10 +744,12 @@ void View::set_current_segment(uint32_t segment_id) { current_segment_ = segment_id; - for (shared_ptr signal : signals_) + for (const shared_ptr& signal : signals_) signal->set_current_segment(current_segment_); - for (shared_ptr dt : decode_traces_) +#ifdef ENABLE_DECODE + for (shared_ptr& dt : decode_traces_) dt->set_current_segment(current_segment_); +#endif vector triggers = session_.get_triggers(current_segment_); @@ -571,12 +757,8 @@ void View::set_current_segment(uint32_t segment_id) for (util::Timestamp timestamp : triggers) trigger_markers_.push_back(make_shared(*this, timestamp)); - // When enabled, the first trigger for this segment is used as the zero position - GlobalSettings settings; - bool trigger_is_zero_time = settings.value(GlobalSettings::Key_View_TriggerIsZeroTime).toBool(); - - if (trigger_is_zero_time && (triggers.size() > 0)) - set_zero_position(triggers.front()); + if (!custom_zero_offset_set_) + reset_zero_position(); viewport_->update(); @@ -595,14 +777,12 @@ Trace::SegmentDisplayMode View::segment_display_mode() const void View::set_segment_display_mode(Trace::SegmentDisplayMode mode) { - trigger_markers_.clear(); - segment_display_mode_ = mode; - for (shared_ptr signal : signals_) + for (const shared_ptr& signal : signals_) signal->set_segment_display_mode(mode); - uint32_t last_segment = session_.get_segment_count() - 1; + uint32_t last_segment = session_.get_highest_segment_id(); switch (mode) { case Trace::ShowLastSegmentOnly: @@ -676,21 +856,34 @@ void View::zoom_fit(bool gui_state) set_scale_offset(scale.convert_to(), extents.first); } -void View::zoom_one_to_one() +void View::focus_on_range(uint64_t start_sample, uint64_t end_sample) { - using pv::data::SignalData; - - // Make a set of all the visible data objects - set< shared_ptr > visible_data = get_visible_data(); - if (visible_data.empty()) - return; - assert(viewport_); - const int w = viewport_->width(); + const uint64_t w = viewport_->width(); if (w <= 0) return; - set_zoom(1.0 / session_.get_samplerate(), w / 2); + const double samplerate = session_.get_samplerate(); + const double samples_per_pixel = samplerate * scale_; + const uint64_t viewport_samples = w * samples_per_pixel; + + const uint64_t sample_delta = (end_sample - start_sample); + + // Note: We add 20% margin on the left and 5% on the right + const uint64_t ext_sample_delta = sample_delta * 1.25; + + // Check if we can keep the zoom level and just center the supplied range + if (viewport_samples >= ext_sample_delta) { + // Note: offset is the left edge of the view so to center, we subtract half the view width + const int64_t sample_offset = (start_sample + (sample_delta / 2) - (viewport_samples / 2)); + const Timestamp offset = sample_offset / samplerate; + set_scale_offset(scale_, offset); + } else { + const Timestamp offset = (start_sample - sample_delta * 0.20) / samplerate; + const Timestamp delta = ext_sample_delta / samplerate; + const Timestamp scale = max(min(delta / w, MaxScale), MinScale); + set_scale_offset(scale.convert_to(), offset); + } } void View::set_scale_offset(double scale, const Timestamp& offset) @@ -698,7 +891,7 @@ void View::set_scale_offset(double scale, const Timestamp& offset) // Disable sticky scrolling / always zoom to fit when acquisition runs // and user drags the viewport if ((scale_ == scale) && (offset_ != offset) && - (session_.get_capture_state() == Session::Running)) { + (session_.get_capture_state() == Session::Running)) { if (sticky_scrolling_) { sticky_scrolling_ = false; @@ -721,13 +914,13 @@ void View::set_scale_offset(double scale, const Timestamp& offset) viewport_->update(); } -set< shared_ptr > View::get_visible_data() const +vector< shared_ptr > View::get_visible_data() const { // Make a set of all the visible data objects - set< shared_ptr > visible_data; - for (const shared_ptr sig : signals_) + vector< shared_ptr > visible_data; + for (const shared_ptr& sig : signals_) if (sig->enabled()) - visible_data.insert(sig->data()); + visible_data.push_back(sig->data()); return visible_data; } @@ -735,10 +928,18 @@ set< shared_ptr > View::get_visible_data() const pair View::get_time_extents() const { boost::optional left_time, right_time; - const set< shared_ptr > visible_data = get_visible_data(); - for (const shared_ptr d : visible_data) { + + vector< shared_ptr > data; + if (signals_.size() == 0) + return make_pair(0, 0); + + for (shared_ptr s : signals_) + if (s->data() && (s->data()->segments().size() > 0)) + data.push_back(s->data()); + + for (const shared_ptr& d : data) { const vector< shared_ptr > segments = d->segments(); - for (const shared_ptr &s : segments) { + for (const shared_ptr& s : segments) { double samplerate = s->samplerate(); samplerate = (samplerate <= 0.0) ? 1.0 : samplerate; @@ -755,52 +956,50 @@ pair View::get_time_extents() const if (!left_time || !right_time) return make_pair(0, 0); - assert(*left_time < *right_time); + assert(*left_time <= *right_time); return make_pair(*left_time, *right_time); } -void View::enable_show_sampling_points(bool state) +bool View::colored_bg() const { - (void)state; - - viewport_->update(); + return colored_bg_; } -void View::enable_show_analog_minor_grid(bool state) +bool View::cursors_shown() const { - (void)state; - - viewport_->update(); + return show_cursors_; } -void View::enable_coloured_bg(bool state) +void View::show_cursors(bool show) { - coloured_bg_ = state; - viewport_->update(); -} + if (show_cursors_ != show) { + show_cursors_ = show; -bool View::coloured_bg() const -{ - return coloured_bg_; + cursor_state_changed(show); + ruler_->update(); + viewport_->update(); + } } -bool View::cursors_shown() const +void View::set_cursors(pv::util::Timestamp& first, pv::util::Timestamp& second) { - return show_cursors_; -} + assert(cursors_); + + cursors_->first()->set_time(first); + cursors_->second()->set_time(second); -void View::show_cursors(bool show) -{ - show_cursors_ = show; ruler_->update(); viewport_->update(); } -void View::centre_cursors() +void View::center_cursors() { + assert(cursors_); + const double time_width = scale_ * viewport_->width(); cursors_->first()->set_time(offset_ + time_width * 0.4); cursors_->second()->set_time(offset_ + time_width * 0.6); + ruler_->update(); viewport_->update(); } @@ -810,15 +1009,17 @@ shared_ptr View::cursors() const return cursors_; } -void View::add_flag(const Timestamp& time) +shared_ptr View::add_flag(const Timestamp& time) { - flags_.push_back(make_shared(*this, time, - QString("%1").arg(next_flag_text_))); + shared_ptr flag = + make_shared(*this, time, QString("%1").arg(next_flag_text_)); + flags_.push_back(flag); next_flag_text_ = (next_flag_text_ >= 'Z') ? 'A' : (next_flag_text_ + 1); time_item_appearance_changed(true, true); + return flag; } void View::remove_flag(shared_ptr flag) @@ -843,6 +1044,112 @@ const QPoint& View::hover_point() const return hover_point_; } +const QWidget* View::hover_widget() const +{ + return hover_widget_; +} + +int64_t View::get_nearest_level_change(const QPoint &p) +{ + // Is snapping disabled? + if (snap_distance_ == 0) + return -1; + + struct entry_t { + entry_t(shared_ptr s) : + signal(s), delta(numeric_limits::max()), sample(-1), is_dense(false) {} + shared_ptr signal; + int64_t delta; + int64_t sample; + bool is_dense; + }; + + vector list; + + // Create list of signals to consider + if (signal_under_mouse_cursor_) + list.emplace_back(signal_under_mouse_cursor_); + else + for (shared_ptr s : signals_) { + if (!s->enabled()) + continue; + + list.emplace_back(s); + } + + // Get data for listed signals + for (entry_t &e : list) { + // Calculate sample number from cursor position + const double samples_per_pixel = e.signal->base()->get_samplerate() * scale(); + const int64_t x_offset = offset().convert_to() / scale(); + const int64_t sample_num = max(((x_offset + p.x()) * samples_per_pixel), 0.0); + + vector edges = + e.signal->get_nearest_level_changes(sample_num); + + if (edges.empty()) + continue; + + // Check first edge + const int64_t first_sample_delta = abs(sample_num - edges.front().first); + const int64_t first_delta = first_sample_delta / samples_per_pixel; + e.delta = first_delta; + e.sample = edges.front().first; + + // Check second edge if available + if (edges.size() == 2) { + // Note: -1 because this is usually the right edge and sample points are left-aligned + const int64_t second_sample_delta = abs(sample_num - edges.back().first - 1); + const int64_t second_delta = second_sample_delta / samples_per_pixel; + + // If both edges are too close, we mark this signal as being dense + if ((first_delta + second_delta) <= snap_distance_) + e.is_dense = true; + + if (second_delta < first_delta) { + e.delta = second_delta; + e.sample = edges.back().first; + } + } + } + + // Look for the best match: non-dense first, then dense + entry_t *match = nullptr; + + for (entry_t &e : list) { + if (e.delta > snap_distance_ || e.is_dense) + continue; + + if (match) { + if (e.delta < match->delta) + match = &e; + } else + match = &e; + } + + if (!match) { + for (entry_t &e : list) { + if (!e.is_dense) + continue; + + if (match) { + if (e.delta < match->delta) + match = &e; + } else + match = &e; + } + } + + if (match) { + // Somewhat ugly hack to make TimeItem::drag_by() work + signal_under_mouse_cursor_ = match->signal; + + return match->sample; + } + + return -1; +} + void View::restack_all_trace_tree_items() { // Make a list of owners that is sorted from deepest first @@ -865,10 +1172,29 @@ void View::restack_all_trace_tree_items() i->animate_to_layout_v_offset(); } +int View::header_width() const +{ + return header_->extended_size_hint().width(); +} + void View::on_setting_changed(const QString &key, const QVariant &value) { + GlobalSettings settings; + + if (key == GlobalSettings::Key_View_ColoredBG) { + colored_bg_ = settings.value(GlobalSettings::Key_View_ColoredBG).toBool(); + viewport_->update(); + } + + if ((key == GlobalSettings::Key_View_ShowSamplingPoints) || + (key == GlobalSettings::Key_View_ShowAnalogMinorGrid)) + viewport_->update(); + if (key == GlobalSettings::Key_View_TriggerIsZeroTime) on_settingViewTriggerIsZeroTime_changed(value); + + if (key == GlobalSettings::Key_View_SnapDistance) + snap_distance_ = settings.value(GlobalSettings::Key_View_SnapDistance).toInt(); } void View::trigger_event(int segment_id, util::Timestamp location) @@ -877,15 +1203,8 @@ void View::trigger_event(int segment_id, util::Timestamp location) if ((uint32_t)segment_id != current_segment_) return; - // Set zero location if the Key_View_TriggerIsZeroTime setting is set and - // if this is the first trigger for this segment. - GlobalSettings settings; - bool trigger_is_zero_time = settings.value(GlobalSettings::Key_View_TriggerIsZeroTime).toBool(); - - size_t trigger_count = session_.get_triggers(current_segment_).size(); - - if (trigger_is_zero_time && trigger_count == 1) - set_zero_position(location); + if (!custom_zero_offset_set_) + reset_zero_position(); trigger_markers_.push_back(make_shared(*this, location)); } @@ -951,7 +1270,7 @@ void View::calculate_tick_spacing() (ScaleUnits[unit++] + tp_margin); } while (tp_with_margin < min_period && unit < countof(ScaleUnits)); - minor_tick_count_ = (unit == 2) ? (4) : (5); + minor_tick_count_ = (unit == 2) ? 4 : 5; tick_period = order_decimal * ScaleUnits[unit - 1]; tick_prefix = static_cast( (order - pv::util::exponent(pv::util::SIPrefix::yocto)) / 3); @@ -1040,12 +1359,18 @@ void View::update_scroll() const pair extents = v_extents(); // Don't change the scrollbar range if there are no traces - if (extents.first != extents.second) - vscrollbar->setRange(extents.first - areaSize.height(), - extents.second); + if (extents.first != extents.second) { + int top_margin = ViewScrollMargin; + int btm_margin = ViewScrollMargin; + + vscrollbar->setRange(extents.first - areaSize.height() + top_margin, + extents.second - btm_margin); + } - if (scroll_needs_defaults_) + if (scroll_needs_defaults_) { set_scroll_default(); + scroll_needs_defaults_ = false; + } } void View::reset_scroll() @@ -1074,13 +1399,13 @@ void View::set_scroll_default() void View::determine_if_header_was_shrunk() { - const int header_pane_width = splitter_->sizes().front(); - const int header_width = header_->extended_size_hint().width(); + const int header_pane_width = + splitter_->sizes().front(); // clazy:exclude=detaching-temporary // Allow for a slight margin of error so that we also accept // slight differences when e.g. a label name change increased // the overall width - header_was_shrunk_ = (header_pane_width < (header_width - 10)); + header_was_shrunk_ = (header_pane_width < (header_width() - 10)); } void View::resize_header_to_fit() @@ -1094,7 +1419,7 @@ void View::resize_header_to_fit() // splitter to the maximum allowed position. int splitter_area_width = 0; - for (int w : splitter_->sizes()) + for (int w : splitter_->sizes()) // clazy:exclude=range-loop splitter_area_width += w; // Make sure the header has enough horizontal space to show all labels fully @@ -1107,21 +1432,22 @@ void View::resize_header_to_fit() void View::update_layout() { update_scroll(); + + update_view_range_metaobject(); } TraceTreeItemOwner* View::find_prevalent_trace_group( const shared_ptr &group, - const unordered_map, shared_ptr > - &signal_map) + const map, shared_ptr > &signal_map) { assert(group); - unordered_set owners; + set owners; vector owner_list; // Make a set and a list of all the owners - for (const auto &channel : group->channels()) { - for (auto entry : signal_map) { + for (const auto& channel : group->channels()) { + for (auto& entry : signal_map) { if (entry.first->channel() == channel) { TraceTreeItemOwner *const o = (entry.second)->owner(); owner_list.push_back(o); @@ -1148,14 +1474,13 @@ TraceTreeItemOwner* View::find_prevalent_trace_group( vector< shared_ptr > View::extract_new_traces_for_channels( const vector< shared_ptr > &channels, - const unordered_map, shared_ptr > - &signal_map, + const map, shared_ptr > &signal_map, set< shared_ptr > &add_list) { vector< shared_ptr > filtered_traces; - for (const auto &channel : channels) { - for (auto entry : signal_map) { + for (const auto& channel : channels) { + for (auto& entry : signal_map) { if (entry.first->channel() == channel) { shared_ptr trace = entry.second; const auto list_iter = add_list.find(trace); @@ -1176,7 +1501,7 @@ void View::determine_time_unit() // Check whether we know the sample rate and hence can use time as the unit if (time_unit_ == util::TimeUnit::Samples) { // Check all signals but... - for (const shared_ptr signal : signals_) { + for (const shared_ptr& signal : signals_) { const shared_ptr data = signal->data(); // ...only check first segment of each @@ -1193,13 +1518,17 @@ void View::determine_time_unit() bool View::eventFilter(QObject *object, QEvent *event) { const QEvent::Type type = event->type(); + if (type == QEvent::MouseMove) { + if (object) + hover_widget_ = qobject_cast(object); + const QMouseEvent *const mouse_event = (QMouseEvent*)event; if (object == viewport_) hover_point_ = mouse_event->pos(); else if (object == ruler_) - hover_point_ = QPoint(mouse_event->x(), 0); + hover_point_ = mouse_event->pos(); else if (object == header_) hover_point_ = QPoint(0, mouse_event->y()); else @@ -1207,6 +1536,28 @@ bool View::eventFilter(QObject *object, QEvent *event) update_hover_point(); + if (grabbed_widget_) { + int64_t nearest = get_nearest_level_change(hover_point_); + pv::util::Timestamp mouse_time = offset_ + hover_point_.x() * scale_; + + if (nearest == -1) { + grabbed_widget_->set_time(mouse_time); + } else { + grabbed_widget_->set_time(nearest / get_signal_under_mouse_cursor()->base()->get_samplerate()); + } + } + + } else if (type == QEvent::MouseButtonPress) { + grabbed_widget_ = nullptr; + + const QMouseEvent *const mouse_event = (QMouseEvent*)event; + if ((object == viewport_) && (mouse_event->button() & Qt::LeftButton)) { + // Send event to all trace tree items + const vector> trace_tree_items( + list_by_type()); + for (const shared_ptr& r : trace_tree_items) + r->mouse_left_press_event(mouse_event); + } } else if (type == QEvent::Leave) { hover_point_ = QPoint(-1, -1); update_hover_point(); @@ -1221,7 +1572,7 @@ bool View::eventFilter(QObject *object, QEvent *event) // resized to their final sizes. update_layout(); - if (settings_restored_) + if (restoring_state_) determine_if_header_was_shrunk(); else resize_header_to_fit(); @@ -1231,15 +1582,26 @@ bool View::eventFilter(QObject *object, QEvent *event) scroll_needs_defaults_ = false; } - if (saved_v_offset_) { + if (restoring_state_) set_v_offset(saved_v_offset_); - saved_v_offset_ = 0; - } } return QObject::eventFilter(object, event); } +void View::contextMenuEvent(QContextMenuEvent *event) +{ + QPoint pos = event->pos() - QPoint(0, ruler_->sizeHint().height()); + + const shared_ptr r = viewport_->get_mouse_over_item(pos); + if (!r) + return; + + QMenu *menu = r->create_view_context_menu(this, pos); + if (menu) + menu->popup(event->globalPos()); +} + void View::resizeEvent(QResizeEvent* event) { // Only adjust the top margin if we shrunk vertically @@ -1249,14 +1611,65 @@ void View::resizeEvent(QResizeEvent* event) update_layout(); } +void View::update_view_range_metaobject() const +{ + const int w = viewport_->width(); + if (w > 0) { + const double samplerate = session_.get_samplerate(); + // Note: sample_num = time * samplerate + // Note: samples_per_pixel = samplerate * scale + const int64_t start_sample = (offset_ * samplerate).convert_to(); + const int64_t end_sample = (offset_ * samplerate).convert_to() + + (w * session_.get_samplerate() * scale_); + + MetadataObject* md_obj = + session_.metadata_obj_manager()->find_object_by_type(MetadataObjMainViewRange); + + const int64_t old_start_sample = md_obj->value(MetadataValueStartSample).toLongLong(); + const int64_t old_end_sample = md_obj->value(MetadataValueEndSample).toLongLong(); + + if (start_sample != old_start_sample) + md_obj->set_value(MetadataValueStartSample, QVariant((qlonglong)start_sample)); + + if (end_sample != old_end_sample) + md_obj->set_value(MetadataValueEndSample, QVariant((qlonglong)end_sample)); + } +} + void View::update_hover_point() { + // Determine signal that the mouse cursor is hovering over + signal_under_mouse_cursor_.reset(); + if (hover_widget_ == this) { + for (const shared_ptr& s : signals_) { + const pair 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> trace_tree_items( list_by_type()); - for (shared_ptr r : trace_tree_items) + for (const shared_ptr& r : trace_tree_items) r->hover_point_changed(hover_point_); - hover_point_changed(hover_point_); + // Notify this view's listeners + hover_point_changed(hover_widget_, hover_point_); + + // Hover point is -1 when invalid and 0 for the header + if (hover_point_.x() > 0) { + // Notify global listeners + pv::util::Timestamp mouse_time = offset_ + hover_point_.x() * scale_; + int64_t sample_num = (mouse_time * session_.get_samplerate()).convert_to(); + + MetadataObject* md_obj = + session_.metadata_obj_manager()->find_object_by_type(MetadataObjMousePos); + md_obj->set_value(MetadataValueStartSample, QVariant((qlonglong)sample_num)); + } } void View::row_item_appearance_changed(bool label, bool content) @@ -1286,7 +1699,8 @@ void View::extents_changed(bool horz, bool vert) (horz ? TraceTreeItemHExtentsChanged : 0) | (vert ? TraceTreeItemVExtentsChanged : 0); - lazy_event_handler_.start(); + if (!lazy_event_handler_.isActive()) + lazy_event_handler_.start(); } void View::on_signal_name_changed() @@ -1304,6 +1718,26 @@ void View::on_splitter_moved() resize_header_to_fit(); } +void View::on_zoom_in_shortcut_triggered() +{ + zoom(1); +} + +void View::on_zoom_out_shortcut_triggered() +{ + zoom(-1); +} + +void View::on_scroll_to_start_shortcut_triggered() +{ + set_h_offset(0); +} + +void View::on_scroll_to_end_shortcut_triggered() +{ + set_h_offset(get_h_scrollbar_maximum()); +} + void View::h_scroll_value_changed(int value) { if (updating_scroll_) @@ -1336,10 +1770,32 @@ void View::v_scroll_value_changed() viewport_->update(); } +void View::on_grab_ruler(int ruler_id) +{ + if (!cursors_shown()) { + center_cursors(); + show_cursors(); + } + + // Release the grabbed widget if its trigger hotkey was pressed twice + if (ruler_id == 1) + grabbed_widget_ = (grabbed_widget_ == cursors_->first().get()) ? + nullptr : cursors_->first().get(); + else + grabbed_widget_ = (grabbed_widget_ == cursors_->second().get()) ? + nullptr : cursors_->second().get(); + + if (grabbed_widget_) + grabbed_widget_->set_time(ruler_->get_absolute_time_from_x_pos( + mapFromGlobal(QCursor::pos()).x() - header_width())); +} + void View::signals_changed() { using sigrok::Channel; + lock_guard lock(signal_mutex_); + vector< shared_ptr > channels; shared_ptr sr_dev; bool signals_added_or_removed = false; @@ -1362,7 +1818,9 @@ void View::signals_changed() vector< shared_ptr > new_top_level_items; // Make a list of traces that are being added, and a list of traces - // that are being removed + // that are being removed. The set_difference() algorithms require + // both sets to be in the exact same order, which means that PD signals + // must always be last as they interrupt the sort order otherwise const vector> prev_trace_list = list_by_type(); const set> prev_traces( prev_trace_list.begin(), prev_trace_list.end()); @@ -1372,7 +1830,6 @@ void View::signals_changed() #ifdef ENABLE_DECODE traces.insert(decode_traces_.begin(), decode_traces_.end()); #endif - set< shared_ptr > add_traces; set_difference(traces.begin(), traces.end(), prev_traces.begin(), prev_traces.end(), @@ -1384,14 +1841,13 @@ void View::signals_changed() inserter(remove_traces, remove_traces.begin())); // Make a look-up table of sigrok Channels to pulseview Signals - unordered_map, shared_ptr > - signal_map; - for (const shared_ptr &sig : signals_) + map, shared_ptr > signal_map; + for (const shared_ptr& sig : signals_) signal_map[sig->base()] = sig; // Populate channel groups if (sr_dev) - for (auto entry : sr_dev->channel_groups()) { + for (auto& entry : sr_dev->channel_groups()) { const shared_ptr &group = entry.second; if (group->channels().size() <= 1) @@ -1417,7 +1873,7 @@ void View::signals_changed() // Add the traces to the group const pair prev_v_extents = owner->v_extents(); int offset = prev_v_extents.second - prev_v_extents.first; - for (shared_ptr trace : new_traces_in_group) { + for (const shared_ptr& trace : new_traces_in_group) { assert(trace); owner->add_child_item(trace); @@ -1452,7 +1908,7 @@ void View::signals_changed() if (non_grouped_logic_signals.size() > 0) { const shared_ptr non_grouped_trace_group( make_shared()); - for (shared_ptr trace : non_grouped_logic_signals) + for (const shared_ptr& trace : non_grouped_logic_signals) non_grouped_trace_group->add_child_item(trace); non_grouped_trace_group->restack_items(); @@ -1470,7 +1926,7 @@ void View::signals_changed() add_traces.begin(), add_traces.end()); // Remove any removed traces - for (shared_ptr trace : remove_traces) { + for (const shared_ptr& trace : remove_traces) { TraceTreeItemOwner *const owner = trace->owner(); assert(owner); owner->remove_child_item(trace); @@ -1486,7 +1942,11 @@ void View::signals_changed() // Add and position the pending top levels items int offset = v_extents().second; - for (auto item : new_top_level_items) { + for (shared_ptr item : new_top_level_items) { + // items may already have gained an owner when they were added to a group above + if (item->owner()) + continue; + add_child_item(item); // Position the item after the last item or at the top if there is none @@ -1523,6 +1983,8 @@ void View::capture_state_updated(int state) set_time_unit(util::TimeUnit::Samples); trigger_markers_.clear(); + if (!custom_zero_offset_set_) + set_zero_position(0); scale_at_acq_start_ = scale_; offset_at_acq_start_ = offset_; @@ -1531,13 +1993,14 @@ void View::capture_state_updated(int state) // the main view of this session (other trace views may be used for // zooming and we don't want to mess them up) bool state = settings.value(GlobalSettings::Key_View_ZoomToFitDuringAcq).toBool(); - if (is_main_view_ && state) { + if (is_main_view_ && state && !restoring_state_) { always_zoom_to_fit_ = true; always_zoom_to_fit_changed(always_zoom_to_fit_); } // Enable sticky scrolling if the setting is enabled - sticky_scrolling_ = settings.value(GlobalSettings::Key_View_StickyScrolling).toBool(); + sticky_scrolling_ = !restoring_state_ && + settings.value(GlobalSettings::Key_View_StickyScrolling).toBool(); // Reset all traces to segment 0 current_segment_ = 0; @@ -1563,12 +2026,13 @@ void View::capture_state_updated(int state) // Only perform zoom-to-fit if the user hasn't altered the viewport and // we didn't restore settings in the meanwhile if (zoom_to_fit_after_acq && - !suppress_zoom_to_fit_after_acq_ && + !restoring_state_ && (scale_ == scale_at_acq_start_) && - (offset_ == offset_at_acq_start_)) + (sticky_scrolling_ || (offset_ == offset_at_acq_start_))) { zoom_fit(false); // We're stopped, so the GUI state doesn't matter + } - suppress_zoom_to_fit_after_acq_ = false; + restoring_state_ = false; } } @@ -1605,12 +2069,9 @@ void View::on_segment_changed(int segment) void View::on_settingViewTriggerIsZeroTime_changed(const QVariant new_value) { - if (new_value.toBool()) { - // The first trigger for this segment is used as the zero position - vector triggers = session_.get_triggers(current_segment_); - if (triggers.size() > 0) - set_zero_position(triggers.front()); - } else + (void)new_value; + + if (!custom_zero_offset_set_) reset_zero_position(); }