#include <cmath>
#include <iostream>
#include <iterator>
-#include <unordered_set>
#include <QApplication>
#include <QDebug>
#include "view.hpp"
#include "viewport.hpp"
+#include "pv/metadata_obj.hpp"
#include "pv/data/logic.hpp"
#include "pv/data/logicsegment.hpp"
#include "pv/devices/device.hpp"
using std::set;
using std::set_difference;
using std::shared_ptr;
-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)
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,
return session_;
}
-unordered_set< shared_ptr<Signal> > View::signals() const
+vector< shared_ptr<Signal> > View::signals() const
{
return signals_;
}
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_);
if ((offset_ != offset) || force_update) {
offset_ = offset;
ruler_offset_ = offset_ + zero_offset_;
+
+ 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
+ int64_t start_sample = (offset_ * samplerate).convert_to<int64_t>();
+ 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);
+ md_obj->set_value(MetadataValueStartSample, QVariant((qlonglong)start_sample));
+ md_obj->set_value(MetadataValueEndSample, QVariant((qlonglong)end_sample));
+ }
+
offset_changed();
}
}
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 int w = viewport_->width();
+ if (w <= 0)
+ return;
+
+ 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)
{
// Disable sticky scrolling / always zoom to fit when acquisition runs
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);
+
+ 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) {
double samplerate = s->samplerate();
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();
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;
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()
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) {
add_child_item(item);
// Position the item after the last item or at the top if there is none