#include <iterator>
#include <unordered_set>
-#include <boost/archive/text_iarchive.hpp>
-#include <boost/archive/text_oarchive.hpp>
-#include <boost/serialization/serialization.hpp>
-
#include <QApplication>
+#include <QDebug>
#include <QEvent>
#include <QFontMetrics>
+#include <QMenu>
#include <QMouseEvent>
#include <QScrollBar>
#include <QVBoxLayout>
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;
using std::shared_ptr;
-using std::stringstream;
using std::unordered_map;
using std::unordered_set;
using std::vector;
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)
}
}
-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),
- 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);
// 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);
connect(scrollarea_->horizontalScrollBar(), SIGNAL(valueChanged(int)),
this, SLOT(h_scroll_value_changed(int)));
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;
+ settings_restored_ = 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<CursorPair>(*this);
+ next_flag_text_ = 'A';
+ trigger_markers_.clear();
+ hover_widget_ = nullptr;
+ grabbed_widget_ = nullptr;
+ hover_point_ = QPoint(-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;
+
+ 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_);
}
Session& View::session()
return session_;
}
-unordered_set< shared_ptr<Signal> > View::signals() const
+vector< shared_ptr<Signal> > View::signals() const
{
return signals_;
}
+shared_ptr<Signal> View::get_signal_by_signalbase(shared_ptr<data::SignalBase> base) const
+{
+ shared_ptr<Signal> ret_val;
+
+ for (const shared_ptr<Signal>& s : signals_)
+ if (s->base() == base) {
+ ret_val = s;
+ break;
+ }
+
+ return ret_val;
+}
+
void View::clear_signals()
{
- ViewBase::clear_signalbases();
+ ViewBase::clear_signals();
signals_.clear();
}
void View::add_signal(const shared_ptr<Signal> signal)
{
ViewBase::add_signalbase(signal->base());
- signals_.insert(signal);
+ signals_.push_back(signal);
signal->set_segment_display_mode(segment_display_mode_);
+ signal->set_current_segment(current_segment_);
connect(signal->base().get(), SIGNAL(name_changed(const QString&)),
this, SLOT(on_signal_name_changed()));
#ifdef ENABLE_DECODE
void View::clear_decode_signals()
{
+ ViewBase::clear_decode_signals();
decode_traces_.clear();
}
void View::add_decode_signal(shared_ptr<data::DecodeSignal> signal)
{
+ ViewBase::add_decode_signal(signal);
+
shared_ptr<DecodeTrace> d(
new DecodeTrace(session_, signal, decode_traces_.size()));
decode_traces_.push_back(d);
d->set_segment_display_mode(segment_display_mode_);
+ d->set_current_segment(current_segment_);
connect(signal.get(), SIGNAL(name_changed(const QString&)),
this, SLOT(on_signal_name_changed()));
signals_changed();
return;
}
+
+ ViewBase::remove_decode_signal(signal);
}
#endif
+shared_ptr<Signal> View::get_signal_under_mouse_cursor() const
+{
+ return signal_under_mouse_cursor_;
+}
+
View* View::view()
{
return this;
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_);
scrollarea_->verticalScrollBar()->sliderPosition());
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("offset", offset_);
- settings.setValue("offset", QString::fromStdString(ss.str()));
+ GlobalSettings::store_timestamp(settings, "offset", offset_);
- for (shared_ptr<Signal> 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>& signal : signals_) {
settings.beginGroup(signal->base()->internal_name());
signal->save_settings(settings);
settings.endGroup();
set_scale(settings.value("scale").toDouble());
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);
-
- set_offset(offset);
+ // This also updates ruler_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());
+ if (settings.contains("segment_display_mode"))
+ set_segment_display_mode(
+ (Trace::SegmentDisplayMode)(settings.value("segment_display_mode").toInt()));
+
for (shared_ptr<Signal> signal : signals_) {
settings.beginGroup(signal->base()->internal_name());
signal->restore_settings(settings);
{
const vector<shared_ptr<Flag>> f(flags());
vector<shared_ptr<TimeItem>> 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;
}
}
+void View::set_offset(const pv::util::Timestamp& offset, bool force_update)
+{
+ if ((offset_ != offset) || force_update) {
+ offset_ = offset;
+ ruler_offset_ = offset_ + zero_offset_;
+ offset_changed();
+ }
+}
+
const Timestamp& View::offset() const
{
return offset_;
}
-void View::set_offset(const pv::util::Timestamp& offset)
+const Timestamp& View::ruler_offset() const
{
- if (offset_ != offset) {
- offset_ = offset;
- offset_changed();
+ return ruler_offset_;
+}
+
+void View::set_zero_position(const pv::util::Timestamp& position)
+{
+ zero_offset_ = -position;
+ custom_zero_offset_set_ = true;
+
+ // Force an immediate update of the offsets
+ set_offset(offset_, true);
+ ruler_->update();
+}
+
+void View::reset_zero_position()
+{
+ 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<util::Timestamp> 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
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;
}
+uint32_t View::current_segment() const
+{
+ return current_segment_;
+}
+
pv::util::SIPrefix View::tick_prefix() const
{
return tick_prefix_;
return tick_period_;
}
+unsigned int View::minor_tick_count() const
+{
+ return minor_tick_count_;
+}
+
void View::set_tick_period(const pv::util::Timestamp& tick_period)
{
if (tick_period_ != tick_period) {
}
}
+void View::set_current_segment(uint32_t segment_id)
+{
+ current_segment_ = segment_id;
+
+ for (const shared_ptr<Signal>& signal : signals_)
+ signal->set_current_segment(current_segment_);
+#ifdef ENABLE_DECODE
+ for (shared_ptr<DecodeTrace>& dt : decode_traces_)
+ dt->set_current_segment(current_segment_);
+#endif
+
+ vector<util::Timestamp> triggers = session_.get_triggers(current_segment_);
+
+ trigger_markers_.clear();
+ for (util::Timestamp timestamp : triggers)
+ trigger_markers_.push_back(make_shared<TriggerMarker>(*this, timestamp));
+
+ if (!custom_zero_offset_set_)
+ reset_zero_position();
+
+ viewport_->update();
+
+ segment_changed(segment_id);
+}
+
bool View::segment_is_selectable() const
{
return segment_selectable_;
}
+Trace::SegmentDisplayMode View::segment_display_mode() const
+{
+ return segment_display_mode_;
+}
+
void View::set_segment_display_mode(Trace::SegmentDisplayMode mode)
{
- for (shared_ptr<Signal> signal : signals_)
+ segment_display_mode_ = mode;
+
+ for (const shared_ptr<Signal>& signal : signals_)
signal->set_segment_display_mode(mode);
- viewport_->update();
+ uint32_t last_segment = session_.get_segment_count() - 1;
+
+ switch (mode) {
+ case Trace::ShowLastSegmentOnly:
+ if (current_segment_ != last_segment)
+ set_current_segment(last_segment);
+ break;
+
+ case Trace::ShowLastCompleteSegmentOnly:
+ // Do nothing if we only have one segment so far
+ if (last_segment > 0) {
+ // If the last segment isn't complete, the previous one must be
+ uint32_t segment_id =
+ (session_.all_segments_complete(last_segment)) ?
+ last_segment : last_segment - 1;
+
+ if (current_segment_ != segment_id)
+ set_current_segment(segment_id);
+ }
+ break;
+
+ case Trace::ShowSingleSegmentOnly:
+ case Trace::ShowAllSegments:
+ case Trace::ShowAccumulatedIntensity:
+ default:
+ // Current segment remains as-is
+ break;
+ }
segment_selectable_ = true;
- if (mode == Trace::ShowSingleSegmentOnly)
+ if ((mode == Trace::ShowAllSegments) || (mode == Trace::ShowAccumulatedIntensity))
segment_selectable_ = false;
- segment_display_mode_changed(segment_selectable_);
+ viewport_->update();
+
+ segment_display_mode_changed((int)mode, segment_selectable_);
}
void View::zoom(double steps)
set_scale_offset(scale.convert_to<double>(), 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<SignalData> > visible_data = get_visible_data();
- if (visible_data.empty())
- return;
-
assert(viewport_);
const int w = viewport_->width();
if (w <= 0)
return;
- set_zoom(1.0 / session_.get_samplerate(), w / 2);
+ const double samplerate = session_.get_samplerate();
+
+ const uint64_t sample_delta = (end_sample - start_sample);
+
+ // Note: We add 20% margin on the left and 5% on the right
+ const Timestamp delta = (sample_delta * 1.25) / samplerate;
+
+ const Timestamp scale = max(min(delta / w, MaxScale), MinScale);
+ const Timestamp offset = (start_sample - sample_delta * 0.20) / samplerate;
+
+ set_scale_offset(scale.convert_to<double>(), offset);
}
void View::set_scale_offset(double scale, const Timestamp& offset)
viewport_->update();
}
-set< shared_ptr<SignalData> > View::get_visible_data() const
+vector< shared_ptr<SignalData> > View::get_visible_data() const
{
// Make a set of all the visible data objects
- set< shared_ptr<SignalData> > visible_data;
- for (const shared_ptr<Signal> sig : signals_)
+ vector< shared_ptr<SignalData> > visible_data;
+ for (const shared_ptr<Signal>& sig : signals_)
if (sig->enabled())
- visible_data.insert(sig->data());
+ visible_data.push_back(sig->data());
return visible_data;
}
pair<Timestamp, Timestamp> View::get_time_extents() const
{
boost::optional<Timestamp> left_time, right_time;
- const set< shared_ptr<SignalData> > visible_data = get_visible_data();
- for (const shared_ptr<SignalData> d : visible_data) {
+
+ vector< shared_ptr<SignalData> > data;
+ if (signals_.size() == 0)
+ return make_pair(0, 0);
+
+ data.push_back(signals_.front()->data());
+
+ for (const shared_ptr<SignalData>& d : data) {
const vector< shared_ptr<Segment> > segments = d->segments();
- for (const shared_ptr<Segment> &s : segments) {
+ for (const shared_ptr<Segment>& s : segments) {
double samplerate = s->samplerate();
samplerate = (samplerate <= 0.0) ? 1.0 : samplerate;
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();
}
return cursors_;
}
-void View::add_flag(const Timestamp& time)
+shared_ptr<Flag> View::add_flag(const Timestamp& time)
{
- flags_.push_back(make_shared<Flag>(*this, time,
- QString("%1").arg(next_flag_text_)));
+ shared_ptr<Flag> flag =
+ make_shared<Flag>(*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> flag)
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<Signal> s) :
+ signal(s), delta(numeric_limits<int64_t>::max()), sample(-1), is_dense(false) {}
+ shared_ptr<Signal> signal;
+ int64_t delta;
+ int64_t sample;
+ bool is_dense;
+ };
+
+ vector<entry_t> list;
+
+ // Create list of signals to consider
+ if (signal_under_mouse_cursor_)
+ list.emplace_back(signal_under_mouse_cursor_);
+ else
+ for (shared_ptr<Signal> 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<double>() / scale();
+ const int64_t sample_num = max(((x_offset + p.x()) * samples_per_pixel), 0.0);
+
+ vector<data::LogicSegment::EdgePair> 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
i->animate_to_layout_v_offset();
}
-void View::trigger_event(util::Timestamp location)
+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)
{
+ // TODO This doesn't work if we're showing multiple segments at once
+ if ((uint32_t)segment_id != current_segment_)
+ return;
+
+ if (!custom_zero_offset_set_)
+ reset_zero_position();
+
trigger_markers_.push_back(make_shared<TriggerMarker>(*this, location));
}
(ScaleUnits[unit++] + tp_margin);
} while (tp_with_margin < min_period && unit < countof(ScaleUnits));
+ minor_tick_count_ = (unit == 2) ? 4 : 5;
tick_period = order_decimal * ScaleUnits[unit - 1];
tick_prefix = static_cast<pv::util::SIPrefix>(
(order - pv::util::exponent(pv::util::SIPrefix::yocto)) / 3);
const pair<int, int> 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()
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()
// 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
vector<TraceTreeItemOwner*> 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);
{
vector< shared_ptr<Trace> > 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> trace = entry.second;
const auto list_iter = add_list.find(trace);
// 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> signal : signals_) {
+ for (const shared_ptr<Signal>& signal : signals_) {
const shared_ptr<SignalData> data = signal->data();
// ...only check first segment of each
bool View::eventFilter(QObject *object, QEvent *event)
{
const QEvent::Type type = event->type();
+
if (type == QEvent::MouseMove) {
+ if (object)
+ hover_widget_ = qobject_cast<QWidget*>(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
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<shared_ptr<TraceTreeItem>> trace_tree_items(
+ list_by_type<TraceTreeItem>());
+ for (const shared_ptr<TraceTreeItem>& r : trace_tree_items)
+ r->mouse_left_press_event(mouse_event);
+ }
} else if (type == QEvent::Leave) {
hover_point_ = QPoint(-1, -1);
update_hover_point();
return QObject::eventFilter(object, event);
}
+void View::contextMenuEvent(QContextMenuEvent *event)
+{
+ QPoint pos = event->pos() - QPoint(0, ruler_->sizeHint().height());
+
+ const shared_ptr<ViewItem> 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
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<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)
+ for (const shared_ptr<TraceTreeItem>& r : trace_tree_items)
r->hover_point_changed(hover_point_);
- hover_point_changed(hover_point_);
+ // Notify any other listeners
+ hover_point_changed(hover_widget_, hover_point_);
}
void View::row_item_appearance_changed(bool label, bool content)
(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()
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_)
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;
// Make a look-up table of sigrok Channels to pulseview Signals
unordered_map<shared_ptr<data::SignalBase>, shared_ptr<Signal> >
signal_map;
- for (const shared_ptr<Signal> &sig : signals_)
+ for (const shared_ptr<Signal>& 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<sigrok::ChannelGroup> &group = entry.second;
if (group->channels().size() <= 1)
// Add the traces to the group
const pair<int, int> prev_v_extents = owner->v_extents();
int offset = prev_v_extents.second - prev_v_extents.first;
- for (shared_ptr<Trace> trace : new_traces_in_group) {
+ for (const shared_ptr<Trace>& trace : new_traces_in_group) {
assert(trace);
owner->add_child_item(trace);
if (non_grouped_logic_signals.size() > 0) {
const shared_ptr<TraceGroup> non_grouped_trace_group(
make_shared<TraceGroup>());
- for (shared_ptr<Trace> trace : non_grouped_logic_signals)
+ for (const shared_ptr<Trace>& trace : non_grouped_logic_signals)
non_grouped_trace_group->add_child_item(trace);
non_grouped_trace_group->restack_items();
add_traces.begin(), add_traces.end());
// Remove any removed traces
- for (shared_ptr<Trace> trace : remove_traces) {
+ for (const shared_ptr<Trace>& trace : remove_traces) {
TraceTreeItemOwner *const owner = trace->owner();
assert(owner);
owner->remove_child_item(trace);
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_;
// Enable sticky scrolling if the setting is enabled
sticky_scrolling_ = settings.value(GlobalSettings::Key_View_StickyScrolling).toBool();
+
+ // Reset all traces to segment 0
+ current_segment_ = 0;
+ set_current_segment(current_segment_);
}
if (state == Session::Stopped) {
void View::on_new_segment(int new_segment_id)
{
on_segment_changed(new_segment_id);
- segment_changed(new_segment_id);
+}
+
+void View::on_segment_completed(int segment_id)
+{
+ on_segment_changed(segment_id);
}
void View::on_segment_changed(int segment)
switch (segment_display_mode_) {
case Trace::ShowLastSegmentOnly:
case Trace::ShowSingleSegmentOnly:
- current_segment_ = segment;
- for (shared_ptr<Signal> signal : signals_)
- signal->set_current_segment(current_segment_);
- viewport_->update();
+ set_current_segment(segment);
+ break;
+
+ case Trace::ShowLastCompleteSegmentOnly:
+ // Only update if all segments are complete
+ if (session_.all_segments_complete(segment))
+ set_current_segment(segment);
break;
case Trace::ShowAllSegments:
}
}
+void View::on_settingViewTriggerIsZeroTime_changed(const QVariant new_value)
+{
+ (void)new_value;
+
+ if (!custom_zero_offset_set_)
+ reset_zero_position();
+}
+
void View::perform_delayed_view_update()
{
if (always_zoom_to_fit_) {