Provide short-term fix for #627 by limiting zoom range to 100 ps

[pulseview.git] / pv / view / view.cpp

diff --git a/pv/view/view.cpp b/pv/view/view.cpp
index 1aa7b7292da842b660865c821d6a884b929c18c9..fdb9354b9315cefe4c4a06d23b00a879db7bab82 100644 (file)
--- a/pv/view/view.cpp
+++ b/pv/view/view.cpp
@@ -61,6 +61,7 @@ using boost::shared_mutex;
 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;
@@ -83,7 +84,7 @@ namespace pv {
 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
@@ -103,6 +104,8 @@ View::View(Session &session, QWidget *parent) :
        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'),
@@ -116,7 +119,7 @@ View::View(Session &session, QWidget *parent) :
        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()),
@@ -234,11 +237,21 @@ unsigned int View::tick_prefix() const
        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);
@@ -480,10 +493,16 @@ void View::set_zoom(double scale, int offset)
 
 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());
 
@@ -493,23 +512,37 @@ void View::calculate_tick_spacing()
                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()
@@ -638,6 +671,28 @@ vector< shared_ptr<Trace> > View::extract_new_traces_for_channels(
        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();
@@ -868,18 +923,25 @@ void View::signals_changed()
        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();
@@ -902,6 +964,7 @@ void View::perform_delayed_view_update()
                offset_ = scale_ * length;
        }
 
+       determine_time_unit();
        update_scroll();
        ruler_->update();
        viewport_->update();