#include "viewport.hpp"
#include "pv/session.hpp"
+#include "pv/globalsettings.hpp"
#include "pv/devices/device.hpp"
#include "pv/data/logic.hpp"
#include "pv/data/logicsegment.hpp"
using std::back_inserter;
using std::copy_if;
+using std::count_if;
using std::deque;
using std::dynamic_pointer_cast;
using std::inserter;
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;
}
}
-View::View(Session &session, QWidget *parent) :
- ViewBase(session, parent),
+View::View(Session &session, bool is_main_view, QWidget *parent) :
+ ViewBase(session, is_main_view, parent),
viewport_(new Viewport(*this)),
ruler_(new Ruler(*this)),
header_(new Header(*this)),
saved_v_offset_(0),
size_finalized_(false)
{
+ GlobalSettings settings;
+ coloured_bg_ = settings.value(GlobalSettings::Key_View_ColouredBG).toBool();
+
connect(scrollarea_.horizontalScrollBar(), SIGNAL(valueChanged(int)),
this, SLOT(h_scroll_value_changed(int)));
connect(scrollarea_.verticalScrollBar(), SIGNAL(valueChanged(int)),
return session_;
}
-std::unordered_set< std::shared_ptr<Signal> > View::signals() const
+unordered_set< shared_ptr<Signal> > View::signals() const
{
return signals_;
}
settings.setValue("v_offset",
scrollarea_.verticalScrollBar()->sliderPosition());
- std::stringstream ss;
+ stringstream ss;
boost::archive::text_oarchive oa(ss);
oa << boost::serialization::make_nvp("offset", offset_);
settings.setValue("offset", QString::fromStdString(ss.str()));
if (settings.contains("offset")) {
util::Timestamp offset;
- std::stringstream ss;
+ stringstream ss;
ss << settings.value("offset").toString().toStdString();
boost::archive::text_iarchive ia(ss);
return make_pair(*left_time, *right_time);
}
-void View::enable_sticky_scrolling(bool state)
+void View::enable_show_sampling_points(bool state)
{
- sticky_scrolling_ = state;
+ (void)state;
+
+ viewport_->update();
}
void View::enable_coloured_bg(bool state)
viewport_->update();
}
-std::shared_ptr<CursorPair> View::cursors() const
+shared_ptr<CursorPair> View::cursors() const
{
return cursors_;
}
void View::add_flag(const Timestamp& time)
{
- flags_.push_back(shared_ptr<Flag>(new Flag(*this, time,
- QString("%1").arg(next_flag_text_))));
+ flags_.push_back(make_shared<Flag>(*this, time,
+ QString("%1").arg(next_flag_text_)));
next_flag_text_ = (next_flag_text_ >= 'Z') ? 'A' :
(next_flag_text_ + 1);
time_item_appearance_changed(true, true);
}
-void View::remove_flag(std::shared_ptr<Flag> flag)
+void View::remove_flag(shared_ptr<Flag> flag)
{
flags_.remove(flag);
time_item_appearance_changed(true, true);
}
-vector< std::shared_ptr<Flag> > View::flags() const
+vector< shared_ptr<Flag> > View::flags() const
{
- vector< std::shared_ptr<Flag> > flags(flags_.begin(), flags_.end());
+ vector< shared_ptr<Flag> > flags(flags_.begin(), flags_.end());
stable_sort(flags.begin(), flags.end(),
[](const shared_ptr<Flag> &a, const shared_ptr<Flag> &b) {
return a->time() < b->time();
o->restack_items();
// Re-assign background colors
- bool next_bgcolour_state = 0;
+ bool next_bgcolour_state = false;
for (auto &o : sorted_owners)
next_bgcolour_state = o->reassign_bgcolour_states(next_bgcolour_state);
void View::trigger_event(util::Timestamp location)
{
- trigger_markers_.push_back(shared_ptr<TriggerMarker>(
- new TriggerMarker(*this, location)));
+ trigger_markers_.push_back(make_shared<TriggerMarker>(*this, location));
}
void View::get_scroll_layout(double &length, Timestamp &offset) const
// Precision is the number of fractional digits required, not
// taking the prefix into account (and it must never be negative)
- tick_precision = std::max(ceil(log10(1 / tick_period)).convert_to<int>(), 0);
+ tick_precision = max(ceil(log10(1 / tick_period)).convert_to<int>(), 0);
tick_period_width = (tick_period / scale_).convert_to<double>();
size_t max_prevalence = 0;
TraceTreeItemOwner *prevalent_owner = nullptr;
for (TraceTreeItemOwner *owner : owners) {
- const size_t prevalence = std::count_if(
+ const size_t prevalence = count_if(
owner_list.begin(), owner_list.end(),
[&](TraceTreeItemOwner *o) { return o == owner; });
if (prevalence > max_prevalence) {
set_time_unit(util::TimeUnit::Samples);
trigger_markers_.clear();
+
+ // Activate "always zoom to fit" if the setting is enabled and we're
+ // the main view of this session (other trace views may be used for
+ // zooming and we don't want to mess them up)
+ GlobalSettings settings;
+ bool state = settings.value(GlobalSettings::Key_View_AlwaysZoomToFit).toBool();
+ if (is_main_view_ && 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();
}
if (state == Session::Stopped) {
// Reset "always zoom to fit", the acquisition has stopped
if (always_zoom_to_fit_) {
+ // Perform a final zoom-to-fit before disabling
+ zoom_fit(always_zoom_to_fit_);
always_zoom_to_fit_ = false;
- always_zoom_to_fit_changed(false);
+ always_zoom_to_fit_changed(always_zoom_to_fit_);
}
}
}
void View::perform_delayed_view_update()
{
- if (always_zoom_to_fit_)
+ if (always_zoom_to_fit_) {
zoom_fit(true);
-
- if (sticky_scrolling_) {
+ } else if (sticky_scrolling_) {
// Make right side of the view sticky
double length = 0;
Timestamp offset;