#include <cmath>
#include <iostream>
#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 <libsigrokcxx/libsigrokcxx.hpp>
-#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;
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::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 {
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()),
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()
+ 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);
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)),
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();
GlobalSettings::remove_change_handler(this);
}
+ViewType View::get_type() const
+{
+ return ViewTypeTrace;
+}
+
void View::reset_view_state()
{
ViewBase::reset_view_state();
scale_ = 1e-3;
offset_ = 0;
ruler_offset_ = 0;
+ zero_offset_ = 0;
+ custom_zero_offset_set_ = false;
updating_scroll_ = false;
- settings_restored_ = false;
+ restoring_state_ = false;
always_zoom_to_fit_ = false;
tick_period_ = 0;
tick_prefix_ = pv::util::SIPrefix::yocto;
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_);
// Make sure the standard bar's segment selector is in sync
set_segment_display_mode(segment_display_mode_);
+
+ scrollarea_->verticalScrollBar()->setRange(-100000000, 100000000);
}
Session& View::session()
return session_;
}
-unordered_set< shared_ptr<Signal> > View::signals() const
+vector< shared_ptr<Signal> > View::signals() const
{
return signals_;
}
-void View::clear_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_signalbases()
{
ViewBase::clear_signalbases();
signals_.clear();
}
-void View::add_signal(const shared_ptr<Signal> signal)
+void View::add_signalbase(const shared_ptr<data::SignalBase> signalbase)
{
- ViewBase::add_signalbase(signal->base());
- signals_.insert(signal);
+ ViewBase::add_signalbase(signalbase);
+
+ shared_ptr<Signal> signal;
+
+ switch (signalbase->type()) {
+ case SignalBase::LogicChannel:
+ signal = shared_ptr<Signal>(new LogicSignal(session_, session_.device(), signalbase));
+ break;
+
+ case SignalBase::AnalogChannel:
+ signal = shared_ptr<Signal>(new AnalogSignal(session_, signalbase));
+ break;
+
+ case SignalBase::MathChannel:
+ signal = shared_ptr<Signal>(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<View> main_tv = dynamic_pointer_cast<View>(session_.main_view());
+ shared_ptr<Signal> 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<data::SignalBase> signalbase)
+{
+ ViewBase::remove_signalbase(signalbase);
+
+ shared_ptr<Signal> 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<data::DecodeSignal> signal)
{
+ ViewBase::add_decode_signal(signal);
+
shared_ptr<DecodeTrace> d(
new DecodeTrace(session_, signal, decode_traces_.size()));
decode_traces_.push_back(d);
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> 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<Signal> View::get_signal_under_mouse_cursor() const
{
return signal_under_mouse_cursor_;
return viewport_;
}
+QAbstractScrollArea* View::scrollarea() const
+{
+ return scrollarea_;
+}
+
const Ruler* View::ruler() const
{
return ruler_;
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_);
+
+ 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());
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();
-
- try {
- boost::archive::text_iarchive ia(ss);
- ia >> boost::serialization::make_nvp("ruler_shift", shift);
- ruler_shift_ = shift;
- } catch (boost::archive::archive_exception&) {
- qDebug() << "Could not restore the view ruler shift";
- }
- }
-
if (settings.contains("offset")) {
- util::Timestamp offset;
- stringstream ss;
- ss << settings.value("offset").toString().toStdString();
-
- try {
- boost::archive::text_iarchive ia(ss);
- ia >> boost::serialization::make_nvp("offset", offset);
- // This also updates ruler_offset_
- set_offset(offset);
- } catch (boost::archive::archive_exception&) {
- qDebug() << "Could not restore the view 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("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();
{
if (scale_ != scale) {
scale_ = scale;
+
+ update_view_range_metaobject();
+
scale_changed();
}
}
{
if ((offset_ != offset) || force_update) {
offset_ = offset;
- ruler_offset_ = offset_ + ruler_shift_;
+ ruler_offset_ = offset_ + zero_offset_;
+
+ update_view_range_metaobject();
+
offset_changed();
}
}
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);
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<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
{
return -scrollarea_->verticalScrollBar()->sliderPosition();
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;
for (util::Timestamp timestamp : triggers)
trigger_markers_.push_back(make_shared<TriggerMarker>(*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();
for (const shared_ptr<Signal>& 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:
set_scale_offset(scale.convert_to<double>(), extents.first);
}
+void View::focus_on_range(uint64_t start_sample, uint64_t end_sample)
+{
+ assert(viewport_);
+ const uint64_t w = viewport_->width();
+ if (w <= 0)
+ return;
+
+ 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<double>(), offset);
+ }
+}
+
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;
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;
+ 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);
+
+ for (shared_ptr<Signal> s : signals_)
+ if (s->data() && (s->data()->segments().size() > 0))
+ data.push_back(s->data());
+
+ for (const shared_ptr<SignalData>& d : data) {
const vector< shared_ptr<Segment> > segments = d->segments();
for (const shared_ptr<Segment>& s : segments) {
double samplerate = s->samplerate();
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)
-{
- (void)state;
-
- viewport_->update();
-}
-
-void View::enable_show_analog_minor_grid(bool state)
-{
- (void)state;
-
- viewport_->update();
-}
-
-void View::enable_colored_bg(bool state)
-{
- colored_bg_ = state;
- viewport_->update();
-}
-
bool View::colored_bg() const
{
return colored_bg_;
void View::show_cursors(bool show)
{
- show_cursors_ = show;
- cursor_state_changed(show);
+ if (show_cursors_ != show) {
+ show_cursors_ = show;
+
+ cursor_state_changed(show);
+ ruler_->update();
+ viewport_->update();
+ }
+}
+
+void View::set_cursors(pv::util::Timestamp& first, pv::util::Timestamp& second)
+{
+ assert(cursors_);
+
+ cursors_->first()->set_time(first);
+ cursors_->second()->set_time(second);
+
ruler_->update();
viewport_->update();
}
-void View::centre_cursors()
+void View::center_cursors()
{
- if (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);
+ assert(cursors_);
- ruler_->update();
- viewport_->update();
- }
+ 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();
}
shared_ptr<CursorPair> View::cursors() const
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)
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) {
- GlobalSettings settings;
+ 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)
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<TriggerMarker>(*this, location));
}
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_) {
set_scroll_default();
void View::update_layout()
{
update_scroll();
+
+ update_view_range_metaobject();
}
TraceTreeItemOwner* View::find_prevalent_trace_group(
const shared_ptr<sigrok::ChannelGroup> &group,
- const unordered_map<shared_ptr<data::SignalBase>, shared_ptr<Signal> >
- &signal_map)
+ const map<shared_ptr<data::SignalBase>, shared_ptr<Signal> > &signal_map)
{
assert(group);
- unordered_set<TraceTreeItemOwner*> owners;
+ set<TraceTreeItemOwner*> owners;
vector<TraceTreeItemOwner*> owner_list;
// Make a set and a list of all the owners
vector< shared_ptr<Trace> > View::extract_new_traces_for_channels(
const vector< shared_ptr<sigrok::Channel> > &channels,
- const unordered_map<shared_ptr<data::SignalBase>, shared_ptr<Signal> >
- &signal_map,
+ const map<shared_ptr<data::SignalBase>, shared_ptr<Signal> > &signal_map,
set< shared_ptr<Trace> > &add_list)
{
vector< shared_ptr<Trace> > filtered_traces;
bool View::eventFilter(QObject *object, QEvent *event)
{
const QEvent::Type type = event->type();
+
if (type == QEvent::MouseMove) {
if (object)
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();
// resized to their final sizes.
update_layout();
- if (settings_restored_)
+ if (restoring_state_)
determine_if_header_was_shrunk();
else
resize_header_to_fit();
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);
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<int64_t>();
+ const int64_t end_sample = (offset_ * samplerate).convert_to<int64_t>() +
+ (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
for (const shared_ptr<TraceTreeItem>& r : trace_tree_items)
r->hover_point_changed(hover_point_);
- // Notify any other listeners
+ // 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<int64_t>();
+
+ 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)
(horz ? TraceTreeItemHExtentsChanged : 0) |
(vert ? TraceTreeItemVExtentsChanged : 0);
- lazy_event_handler_.stop();
- 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;
+ lock_guard<mutex> lock(signal_mutex_);
+
vector< shared_ptr<Channel> > channels;
shared_ptr<sigrok::Device> sr_dev;
bool signals_added_or_removed = false;
vector< shared_ptr<TraceTreeItem> > 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<shared_ptr<Trace>> prev_trace_list = list_by_type<Trace>();
const set<shared_ptr<Trace>> prev_traces(
prev_trace_list.begin(), prev_trace_list.end());
#ifdef ENABLE_DECODE
traces.insert(decode_traces_.begin(), decode_traces_.end());
#endif
-
set< shared_ptr<Trace> > add_traces;
set_difference(traces.begin(), traces.end(),
prev_traces.begin(), prev_traces.end(),
inserter(remove_traces, remove_traces.begin()));
// Make a look-up table of sigrok Channels to pulseview Signals
- unordered_map<shared_ptr<data::SignalBase>, shared_ptr<Signal> >
- signal_map;
+ map<shared_ptr<data::SignalBase>, shared_ptr<Signal> > signal_map;
for (const shared_ptr<Signal>& sig : signals_)
signal_map[sig->base()] = sig;
// Add and position the pending top levels items
int offset = v_extents().second;
- for (auto item : new_top_level_items) {
+ for (shared_ptr<TraceTreeItem> 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
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_;
// 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;
// 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;
}
}
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<util::Timestamp> 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();
}
projects / pulseview.git / blobdiff