using pv::data::SignalData;
using pv::data::Segment;
using pv::util::format_time;
+using pv::util::TimeUnit;
using std::deque;
using std::dynamic_pointer_cast;
namespace view {
const double View::MaxScale = 1e9;
-const double View::MinScale = 1e-15;
+const double View::MinScale = 1e-12;
const int View::MaxScrollValue = INT_MAX / 2;
const int View::MaxViewAutoUpdateRate = 25; // No more than 25 Hz with sticky scrolling
always_zoom_to_fit_(false),
tick_period_(0.0),
tick_prefix_(0),
+ tick_precision_(0),
+ time_unit_(util::Time),
show_cursors_(false),
cursors_(new CursorPair(*this)),
next_flag_text_('A'),
connect(&session_, SIGNAL(signals_changed()),
this, SLOT(signals_changed()));
connect(&session_, SIGNAL(capture_state_changed(int)),
- this, SLOT(data_updated()));
+ this, SLOT(capture_state_updated(int)));
connect(&session_, SIGNAL(data_received()),
this, SLOT(data_updated()));
connect(&session_, SIGNAL(frame_ended()),
return tick_prefix_;
}
+unsigned int View::tick_precision() const
+{
+ return tick_precision_;
+}
+
double View::tick_period() const
{
return tick_period_;
}
+TimeUnit View::time_unit() const
+{
+ return time_unit_;
+}
+
void View::zoom(double steps)
{
zoom(steps, viewport_->width() / 2);
void View::calculate_tick_spacing()
{
- const double SpacingIncrement = 32.0f;
- const double MinValueSpacing = 32.0f;
+ const double SpacingIncrement = 10.0f;
+ const double MinValueSpacing = 25.0f;
+
+ // Figure out the highest numeric value visible on a label
+ const QSize areaSize = viewport_->size();
+ const double max_time = max(fabs(offset_),
+ fabs(offset_ + scale_ * areaSize.width()));
- double min_width = SpacingIncrement, typical_width;
+ double min_width = SpacingIncrement;
+ double label_width, tick_period_width;
QFontMetrics m(QApplication::font());
const int order = (int)floorf(log10f(min_period));
const double order_decimal = pow(10.0, order);
+ // Allow for a margin of error so that a scale unit of 1 can be used.
+ // Otherwise, for a SU of 1 the tick period will almost always be below
+ // the min_period by a small amount - and thus skipped in favor of 2.
+ // Note: margin assumes that SU[0] and SU[1] contain the smallest values
+ double tp_margin = (ScaleUnits[0] + ScaleUnits[1]) / 2.0;
+ double tp_with_margin;
unsigned int unit = 0;
do {
- tick_period_ = order_decimal * ScaleUnits[unit++];
- } while (tick_period_ < min_period &&
- unit < countof(ScaleUnits));
+ tp_with_margin = order_decimal * (ScaleUnits[unit++] + tp_margin);
+ } while (tp_with_margin < min_period && unit < countof(ScaleUnits));
+ tick_period_ = order_decimal * ScaleUnits[unit - 1];
tick_prefix_ = (order - pv::util::FirstSIPrefixPower) / 3;
- typical_width = m.boundingRect(0, 0, INT_MAX, INT_MAX,
- Qt::AlignLeft | Qt::AlignTop,
- format_time(offset_, tick_prefix_)).width() +
+ // Precision is the number of fractional digits required, not
+ // taking the prefix into account (and it must never be negative)
+ tick_precision_ = std::max((int)ceil(log10f(1 / tick_period_)), 0);
+
+ tick_period_width = tick_period_ / scale_;
+
+ const QString label_text =
+ format_time(max_time, tick_prefix_, time_unit_, tick_precision_);
+
+ label_width = m.boundingRect(0, 0, INT_MAX, INT_MAX,
+ Qt::AlignLeft | Qt::AlignTop, label_text).width() +
MinValueSpacing;
min_width += SpacingIncrement;
- } while(typical_width > tick_period_ / scale_);
+ } while (tick_period_width < label_width);
}
void View::update_scroll()
return filtered_traces;
}
+void View::determine_time_unit()
+{
+ // Check whether we know the sample rate and hence can use time as the unit
+ if (time_unit_ == util::Samples) {
+ shared_lock<shared_mutex> lock(session().signals_mutex());
+ const unordered_set< shared_ptr<Signal> > &sigs(session().signals());
+
+ // Check all signals but...
+ for (const shared_ptr<Signal> signal : sigs) {
+ const shared_ptr<SignalData> data = signal->data();
+
+ // ...only check first segment of each
+ const vector< shared_ptr<Segment> > segments = data->segments();
+ if (!segments.empty())
+ if (segments[0]->samplerate()) {
+ time_unit_ = util::Time;
+ break;
+ }
+ }
+ }
+}
+
bool View::eventFilter(QObject *object, QEvent *event)
{
const QEvent::Type type = event->type();
viewport_->update();
}
-void View::data_updated()
+void View::capture_state_updated(int state)
{
// Reset "always zoom to fit" when we change to the stopped state
- if (always_zoom_to_fit_ && (session_.get_capture_state() == Session::Stopped)) {
+ if (always_zoom_to_fit_ && (state == Session::Stopped)) {
always_zoom_to_fit_ = false;
always_zoom_to_fit_changed(false);
}
+ if (state == Session::Running)
+ time_unit_ = util::Samples;
+}
+
+void View::data_updated()
+{
if (always_zoom_to_fit_ || sticky_scrolling_) {
if (!delayed_view_updater_.isActive())
delayed_view_updater_.start();
} else {
+ determine_time_unit();
update_scroll();
ruler_->update();
viewport_->update();
offset_ = scale_ * length;
}
+ determine_time_unit();
update_scroll();
ruler_->update();
viewport_->update();