X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fview%2Fview.cpp;h=540b90e14cffb17021e698549b780475e689f280;hp=1aa7b7292da842b660865c821d6a884b929c18c9;hb=af503b104d890a357c736c678bb00296d889c090;hpb=f32905530347e1020d5ce7959123cf797c9a4829

diff --git a/pv/view/view.cpp b/pv/view/view.cpp
index 1aa7b729..540b90e1 100644
--- a/pv/view/view.cpp
+++ b/pv/view/view.cpp
@@ -60,7 +60,8 @@ using boost::shared_mutex;
 
 using pv::data::SignalData;
 using pv::data::Segment;
-using pv::util::format_time;
+using pv::util::TimeUnit;
+using pv::util::Timestamp;
 
 using std::deque;
 using std::dynamic_pointer_cast;
@@ -82,8 +83,8 @@ using std::weak_ptr;
 namespace pv {
 namespace view {
 
-const double View::MaxScale = 1e9;
-const double View::MinScale = 1e-15;
+const Timestamp View::MaxScale("1e9");
+const Timestamp View::MinScale("1e-12");
 
 const int View::MaxScrollValue = INT_MAX / 2;
 const int View::MaxViewAutoUpdateRate = 25; // No more than 25 Hz with sticky scrolling
@@ -101,8 +102,10 @@ View::View(Session &session, QWidget *parent) :
 	updating_scroll_(false),
 	sticky_scrolling_(false), // Default setting is set in MainWindow::setup_ui()
 	always_zoom_to_fit_(false),
-	tick_period_(0.0),
-	tick_prefix_(0),
+	tick_period_(0),
+	tick_prefix_(pv::util::SIPrefix::yocto),
+	tick_precision_(0),
+	time_unit_(util::TimeUnit::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()),
@@ -207,11 +210,27 @@ double View::scale() const
 	return scale_;
 }
 
-double View::offset() const
+void View::set_scale(double scale)
+{
+	if (scale_ != scale) {
+		scale_ = scale;
+		Q_EMIT scale_changed();
+	}
+}
+
+const Timestamp& View::offset() const
 {
 	return offset_;
 }
 
+void View::set_offset(const pv::util::Timestamp& offset)
+{
+	if (offset_ != offset) {
+		offset_ = offset;
+		Q_EMIT offset_changed();
+	}
+}
+
 int View::owner_visual_v_offset() const
 {
 	return -verticalScrollBar()->sliderPosition();
@@ -229,16 +248,58 @@ unsigned int View::depth() const
 	return 0;
 }
 
-unsigned int View::tick_prefix() const
+pv::util::SIPrefix View::tick_prefix() const
 {
 	return tick_prefix_;
 }
 
-double View::tick_period() const
+void View::set_tick_prefix(pv::util::SIPrefix tick_prefix)
+{
+	if (tick_prefix_ != tick_prefix) {
+		tick_prefix_ = tick_prefix;
+		Q_EMIT tick_prefix_changed();
+	}
+}
+
+unsigned int View::tick_precision() const
+{
+	return tick_precision_;
+}
+
+void View::set_tick_precision(unsigned tick_precision)
+{
+	if (tick_precision_ != tick_precision) {
+		tick_precision_ = tick_precision;
+		Q_EMIT tick_precision_changed();
+	}
+}
+
+const pv::util::Timestamp& View::tick_period() const
 {
 	return tick_period_;
 }
 
+void View::set_tick_period(const pv::util::Timestamp& tick_period)
+{
+	if (tick_period_ != tick_period) {
+		tick_period_ = tick_period;
+		Q_EMIT tick_period_changed();
+	}
+}
+
+TimeUnit View::time_unit() const
+{
+	return time_unit_;
+}
+
+void View::set_time_unit(pv::util::TimeUnit time_unit)
+{
+	if (time_unit_ != time_unit) {
+		time_unit_ = time_unit;
+		Q_EMIT time_unit_changed();
+	}
+}
+
 void View::zoom(double steps)
 {
 	zoom(steps, viewport_->width() / 2);
@@ -260,9 +321,9 @@ void View::zoom_fit(bool gui_state)
 		always_zoom_to_fit_changed(gui_state);
 	}
 
-	const pair<double, double> extents = get_time_extents();
-	const double delta = extents.second - extents.first;
-	if (delta < 1e-12)
+	const pair<Timestamp, Timestamp> extents = get_time_extents();
+	const Timestamp delta = extents.second - extents.first;
+	if (delta < Timestamp("1e-12"))
 		return;
 
 	assert(viewport_);
@@ -270,8 +331,8 @@ void View::zoom_fit(bool gui_state)
 	if (w <= 0)
 		return;
 
-	const double scale = max(min(delta / w, MaxScale), MinScale);
-	set_scale_offset(scale, extents.first);
+	const Timestamp scale = max(min(delta / w, MaxScale), MinScale);
+	set_scale_offset(scale.convert_to<double>(), extents.first);
 }
 
 void View::zoom_one_to_one()
@@ -303,7 +364,7 @@ void View::zoom_one_to_one()
 	set_zoom(1.0 / samplerate, w / 2);
 }
 
-void View::set_scale_offset(double scale, double offset)
+void View::set_scale_offset(double scale, const Timestamp& offset)
 {
 	// Disable sticky scrolling / always zoom to fit when acquisition runs
 	// and user drags the viewport
@@ -321,15 +382,14 @@ void View::set_scale_offset(double scale, double offset)
 		}
 	}
 
-	scale_ = scale;
-	offset_ = offset;
+	set_scale(scale);
+	set_offset(offset);
 
 	calculate_tick_spacing();
 
 	update_scroll();
 	ruler_->update();
 	viewport_->update();
-	scale_offset_changed();
 }
 
 set< shared_ptr<SignalData> > View::get_visible_data() const
@@ -346,9 +406,9 @@ set< shared_ptr<SignalData> > View::get_visible_data() const
 	return visible_data;
 }
 
-pair<double, double> View::get_time_extents() const
+pair<Timestamp, Timestamp> View::get_time_extents() const
 {
-	double left_time = DBL_MAX, right_time = DBL_MIN;
+	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)
 	{
@@ -358,18 +418,21 @@ pair<double, double> View::get_time_extents() const
 			double samplerate = s->samplerate();
 			samplerate = (samplerate <= 0.0) ? 1.0 : samplerate;
 
-			const double start_time = s->start_time();
-			left_time = min(left_time, start_time);
-			right_time = max(right_time, start_time +
-				d->max_sample_count() / samplerate);
+			const Timestamp start_time = s->start_time();
+			left_time = left_time ?
+				min(*left_time, start_time) :
+				                start_time;
+			right_time = right_time ?
+				max(*right_time, start_time + d->max_sample_count() / samplerate) :
+				                 start_time + d->max_sample_count() / samplerate;
 		}
 	}
 
-	if (left_time == DBL_MAX && right_time == DBL_MIN)
-		return make_pair(0.0, 0.0);
+	if (!left_time || !right_time)
+		return make_pair(0, 0);
 
-	assert(left_time < right_time);
-	return make_pair(left_time, right_time);
+	assert(*left_time < *right_time);
+	return make_pair(*left_time, *right_time);
 }
 
 void View::enable_sticky_scrolling(bool state)
@@ -403,7 +466,7 @@ std::shared_ptr<CursorPair> View::cursors() const
 	return cursors_;
 }
 
-void View::add_flag(double time)
+void View::add_flag(const Timestamp& time)
 {
 	flags_.push_back(shared_ptr<Flag>(new Flag(*this, time,
 		QString("%1").arg(next_flag_text_))));
@@ -441,13 +504,13 @@ void View::update_viewport()
 	header_->update();
 }
 
-void View::restack_all_row_items()
+void View::restack_all_trace_tree_items()
 {
 	// Make a list of owners that is sorted from deepest first
 	const auto owners = list_row_item_owners();
-	vector< RowItemOwner* > sorted_owners(owners.begin(), owners.end());
+	vector< TraceTreeItemOwner* > sorted_owners(owners.begin(), owners.end());
 	sort(sorted_owners.begin(), sorted_owners.end(),
-		[](const RowItemOwner* a, const RowItemOwner *b) {
+		[](const TraceTreeItemOwner* a, const TraceTreeItemOwner *b) {
 			return a->depth() > b->depth(); });
 
 	// Restack the items recursively
@@ -459,10 +522,10 @@ void View::restack_all_row_items()
 		r->animate_to_layout_v_offset();
 }
 
-void View::get_scroll_layout(double &length, double &offset) const
+void View::get_scroll_layout(double &length, Timestamp &offset) const
 {
-	const pair<double, double> extents = get_time_extents();
-	length = (extents.second - extents.first) / scale_;
+	const pair<Timestamp, Timestamp> extents = get_time_extents();
+	length = ((extents.second - extents.first) / scale_).convert_to<double>();
 	offset = offset_ / scale_;
 }
 
@@ -472,44 +535,77 @@ void View::set_zoom(double scale, int offset)
 	always_zoom_to_fit_ = false;
 	always_zoom_to_fit_changed(false);
 
-	const double cursor_offset = offset_ + scale_ * offset;
-	const double new_scale = max(min(scale, MaxScale), MinScale);
-	const double new_offset = cursor_offset - new_scale * offset;
-	set_scale_offset(new_scale, new_offset);
+	const Timestamp cursor_offset = offset_ + scale_ * offset;
+	const Timestamp new_scale = max(min(Timestamp(scale), MaxScale), MinScale);
+	const Timestamp new_offset = cursor_offset - new_scale * offset;
+	set_scale_offset(new_scale.convert_to<double>(), new_offset);
 }
 
 void View::calculate_tick_spacing()
 {
-	const double SpacingIncrement = 32.0f;
-	const double MinValueSpacing = 32.0f;
+	const double SpacingIncrement = 10.0f;
+	const double MinValueSpacing = 40.0f;
 
-	double min_width = SpacingIncrement, typical_width;
+	// Figure out the highest numeric value visible on a label
+	const QSize areaSize = viewport_->size();
+	const Timestamp max_time = max(fabs(offset_),
+		fabs(offset_ + scale_ * areaSize.width()));
+
+	double min_width = SpacingIncrement;
+	double label_width, tick_period_width;
 
 	QFontMetrics m(QApplication::font());
 
+	// Copies of the member variables with the same name, used in the calculation
+	// and written back afterwards, so that we don't emit signals all the time
+	// during the calculation.
+	pv::util::Timestamp tick_period = tick_period_;
+	pv::util::SIPrefix tick_prefix = tick_prefix_;
+	unsigned tick_precision = tick_precision_;
+
 	do {
 		const double min_period = scale_ * min_width;
 
 		const int order = (int)floorf(log10f(min_period));
-		const double order_decimal = pow(10.0, order);
-
+		const pv::util::Timestamp order_decimal =
+			pow(pv::util::Timestamp(10), 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.convert_to<double>() *
+				(ScaleUnits[unit++] + tp_margin);
+		} while (tp_with_margin < min_period && unit < countof(ScaleUnits));
 
-		tick_prefix_ = (order - pv::util::FirstSIPrefixPower) / 3;
+		tick_period = order_decimal * ScaleUnits[unit - 1];
+		tick_prefix = static_cast<pv::util::SIPrefix>(
+			(order - pv::util::exponent(pv::util::SIPrefix::yocto)) / 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(ceil(log10(1 / tick_period)).convert_to<int>(), 0);
+
+		tick_period_width = (tick_period / scale_).convert_to<double>();
+
+		const QString label_text = Ruler::format_time_with_distance(
+			tick_period, 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 (tick_period_width < label_width);
 
-	} while (typical_width > tick_period_ / scale_);
+	set_tick_period(tick_period);
+	set_tick_prefix(tick_prefix);
+	set_tick_precision(tick_precision);
 }
 
 void View::update_scroll()
@@ -519,11 +615,12 @@ void View::update_scroll()
 	const QSize areaSize = viewport_->size();
 
 	// Set the horizontal scroll bar
-	double length = 0, offset = 0;
+	double length = 0;
+	Timestamp offset;
 	get_scroll_layout(length, offset);
 	length = max(length - areaSize.width(), 0.0);
 
-	int major_tick_distance = tick_period_ / scale_;
+	int major_tick_distance = (tick_period_ / scale_).convert_to<int>();
 
 	horizontalScrollBar()->setPageStep(areaSize.width() / 2);
 	horizontalScrollBar()->setSingleStep(major_tick_distance);
@@ -532,11 +629,11 @@ void View::update_scroll()
 
 	if (length < MaxScrollValue) {
 		horizontalScrollBar()->setRange(0, length);
-		horizontalScrollBar()->setSliderPosition(offset);
+		horizontalScrollBar()->setSliderPosition(offset.convert_to<double>());
 	} else {
 		horizontalScrollBar()->setRange(0, MaxScrollValue);
 		horizontalScrollBar()->setSliderPosition(
-			offset_ * MaxScrollValue / (scale_ * length));
+			(offset_ * MaxScrollValue / (scale_ * length)).convert_to<double>());
 	}
 
 	updating_scroll_ = false;
@@ -575,15 +672,15 @@ QRectF View::label_rect(const QRectF &rect)
 	return QRectF();
 }
 
-RowItemOwner* View::find_prevalent_trace_group(
+TraceTreeItemOwner* View::find_prevalent_trace_group(
 	const shared_ptr<sigrok::ChannelGroup> &group,
 	const unordered_map<shared_ptr<sigrok::Channel>, shared_ptr<Signal> >
 		&signal_map)
 {
 	assert(group);
 
-	unordered_set<RowItemOwner*> owners;
-	vector<RowItemOwner*> owner_list;
+	unordered_set<TraceTreeItemOwner*> owners;
+	vector<TraceTreeItemOwner*> owner_list;
 
 	// Make a set and a list of all the owners
 	for (const auto &channel : group->channels()) {
@@ -591,18 +688,18 @@ RowItemOwner* View::find_prevalent_trace_group(
 		if (iter == signal_map.end())
 			continue;
 
-		RowItemOwner *const o = (*iter).second->owner();
+		TraceTreeItemOwner *const o = (*iter).second->owner();
 		owner_list.push_back(o);
 		owners.insert(o);
 	}
 
 	// Iterate through the list of owners, and find the most prevalent
 	size_t max_prevalence = 0;
-	RowItemOwner *prevalent_owner = nullptr;
-	for (RowItemOwner *owner : owners) {
+	TraceTreeItemOwner *prevalent_owner = nullptr;
+	for (TraceTreeItemOwner *owner : owners) {
 		const size_t prevalence = std::count_if(
 			owner_list.begin(), owner_list.end(),
-			[&](RowItemOwner *o) { return o == owner; });
+			[&](TraceTreeItemOwner *o) { return o == owner; });
 		if (prevalence > max_prevalence) {
 			max_prevalence = prevalence;
 			prevalent_owner = owner;
@@ -638,6 +735,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::TimeUnit::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()) {
+					set_time_unit(util::TimeUnit::Time);
+					break;
+				}
+		}
+	}
+}
+
 bool View::eventFilter(QObject *object, QEvent *event)
 {
 	const QEvent::Type type = event->type();
@@ -706,8 +825,8 @@ void View::time_item_appearance_changed(bool label, bool content)
 void View::extents_changed(bool horz, bool vert)
 {
 	sticky_events_ |=
-		(horz ? RowItemHExtentsChanged : 0) |
-		(vert ? RowItemVExtentsChanged : 0);
+		(horz ? TraceTreeItemHExtentsChanged : 0) |
+		(vert ? TraceTreeItemVExtentsChanged : 0);
 	lazy_event_handler_.start();
 }
 
@@ -725,11 +844,12 @@ void View::h_scroll_value_changed(int value)
 
 	const int range = horizontalScrollBar()->maximum();
 	if (range < MaxScrollValue)
-		offset_ = scale_ * value;
+		set_offset(scale_ * value);
 	else {
-		double length = 0, offset;
+		double length = 0;
+		Timestamp offset;
 		get_scroll_layout(length, offset);
-		offset_ = scale_ * length * value / MaxScrollValue;
+		set_offset(scale_ * length * value / MaxScrollValue);
 	}
 
 	ruler_->update();
@@ -744,7 +864,7 @@ void View::v_scroll_value_changed()
 
 void View::signals_changed()
 {
-	vector< shared_ptr<RowItem> > new_top_level_items;
+	vector< shared_ptr<TraceTreeItem> > new_top_level_items;
 
 	const auto device = session_.device();
 	if (!device)
@@ -793,7 +913,7 @@ void View::signals_changed()
 			continue;
 
 		// Find best trace group to add to
-		RowItemOwner *owner = find_prevalent_trace_group(
+		TraceTreeItemOwner *owner = find_prevalent_trace_group(
 			group, signal_map);
 
 		// If there is no trace group, create one
@@ -843,7 +963,7 @@ void View::signals_changed()
 
 	// Remove any removed traces
 	for (shared_ptr<Trace> trace : remove_traces) {
-		RowItemOwner *const owner = trace->owner();
+		TraceTreeItemOwner *const owner = trace->owner();
 		assert(owner);
 		owner->remove_child_item(trace);
 	}
@@ -868,18 +988,31 @@ 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)) {
-		always_zoom_to_fit_ = false;
-		always_zoom_to_fit_changed(false);
+	if (state == Session::Running)
+		set_time_unit(util::TimeUnit::Samples);
+
+	if (state == Session::Stopped) {
+		// After acquisition has stopped we need to re-calculate the ticks once
+		// as it's otherwise done when the user pans or zooms, which is too late
+		calculate_tick_spacing();
+
+		// Reset "always zoom to fit", the acquisition has stopped
+		if (always_zoom_to_fit_) {
+			always_zoom_to_fit_ = false;
+			always_zoom_to_fit_changed(false);
+		}
 	}
+}
 
+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();
@@ -893,15 +1026,17 @@ void View::perform_delayed_view_update()
 
 	if (sticky_scrolling_) {
 		// Make right side of the view sticky
-		double length = 0, offset;
+		double length = 0;
+		Timestamp offset;
 		get_scroll_layout(length, offset);
 
 		const QSize areaSize = viewport_->size();
 		length = max(length - areaSize.width(), 0.0);
 
-		offset_ = scale_ * length;
+		set_offset(scale_ * length);
 	}
 
+	determine_time_unit();
 	update_scroll();
 	ruler_->update();
 	viewport_->update();
@@ -909,10 +1044,10 @@ void View::perform_delayed_view_update()
 
 void View::process_sticky_events()
 {
-	if (sticky_events_ & RowItemHExtentsChanged)
+	if (sticky_events_ & TraceTreeItemHExtentsChanged)
 		update_layout();
-	if (sticky_events_ & RowItemVExtentsChanged) {
-		restack_all_row_items();
+	if (sticky_events_ & TraceTreeItemVExtentsChanged) {
+		restack_all_trace_tree_items();
 		update_scroll();
 	}
 
@@ -922,7 +1057,7 @@ void View::process_sticky_events()
 
 void View::on_hover_point_changed()
 {
-	for (shared_ptr<RowItem> r : *this)
+	for (shared_ptr<TraceTreeItem> r : *this)
 		r->hover_point_changed();
 }