}
}
-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);
this, SLOT(process_sticky_events()));
lazy_event_handler_.setSingleShot(true);
+ // 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);
+
// 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();
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();
}
#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);
signals_changed();
return;
}
+
+ ViewBase::remove_decode_signal(signal);
}
#endif
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);
settings.setValue("offset", QString::fromStdString(ss.str()));
}
- for (shared_ptr<Signal> signal : signals_) {
+ for (const shared_ptr<Signal>& signal : signals_) {
settings.beginGroup(signal->base()->internal_name());
signal->save_settings(settings);
settings.endGroup();
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;
items.push_back(cursors_->second());
}
- for (auto trigger_marker : trigger_markers_)
+ for (auto& trigger_marker : trigger_markers_)
items.push_back(trigger_marker);
return items;
{
if ((offset_ != offset) || force_update) {
offset_ = offset;
- ruler_offset_ = offset_ + ruler_shift_;
+ ruler_offset_ = offset_ + zero_offset_;
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;
// Force an immediate update of the offsets
set_offset(offset_, true);
void View::reset_zero_position()
{
- ruler_shift_ = 0;
+ zero_offset_ = 0;
// 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;
{
current_segment_ = segment_id;
- for (shared_ptr<Signal> signal : signals_)
+ for (const shared_ptr<Signal>& signal : signals_)
signal->set_current_segment(current_segment_);
#ifdef ENABLE_DECODE
- for (shared_ptr<DecodeTrace> dt : decode_traces_)
+ for (shared_ptr<DecodeTrace>& dt : decode_traces_)
dt->set_current_segment(current_segment_);
#endif
{
segment_display_mode_ = mode;
- for (shared_ptr<Signal> signal : signals_)
+ for (const shared_ptr<Signal>& signal : signals_)
signal->set_segment_display_mode(mode);
uint32_t last_segment = session_.get_segment_count() - 1;
{
// Make a set of all the visible data objects
set< shared_ptr<SignalData> > visible_data;
- for (const shared_ptr<Signal> sig : signals_)
+ for (const shared_ptr<Signal>& sig : signals_)
if (sig->enabled())
visible_data.insert(sig->data());
{
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) {
+ for (const shared_ptr<SignalData>& d : visible_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)
-{
- (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()
{
- 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)
void View::determine_if_header_was_shrunk()
{
- const int header_pane_width = splitter_->sizes().front();
+ 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
// 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)
update_hover_point();
+ } else if (type == QEvent::MouseButtonPress) {
+ 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();
// Determine signal that the mouse cursor is hovering over
signal_under_mouse_cursor_.reset();
if (hover_widget_ == this) {
- for (shared_ptr<Signal> s : signals_) {
+ 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;
// 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_);
// Notify any other listeners
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_)
// 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();
+ set_zero_position(0);
scale_at_acq_start_ = scale_;
offset_at_acq_start_ = offset_;
projects / pulseview.git / blobdiff