X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fview%2Fdecodetrace.cpp;h=f2aadd1b18ff3c7e4b8904a53aeef1b8f7c8d0a9;hp=28443673498419bd6a2d3d2de18ed5f1e741162f;hb=eee89ff865c28854eebdcecbe344f225b9ee366f;hpb=b93295580db08d9008b9c9e49a3a3a86ef562f14

diff --git a/pv/view/decodetrace.cpp b/pv/view/decodetrace.cpp
index 28443673..f2aadd1b 100644
--- a/pv/view/decodetrace.cpp
+++ b/pv/view/decodetrace.cpp
@@ -22,26 +22,54 @@ extern "C" {
 #include <libsigrokdecode/libsigrokdecode.h>
 }
 
+#include <mutex>
+
 #include <extdef.h>
 
-#include <boost/foreach.hpp>
+#include <tuple>
+
+#include <boost/functional/hash.hpp>
+#include <boost/thread/locks.hpp>
+#include <boost/thread/shared_mutex.hpp>
 
 #include <QAction>
+#include <QApplication>
 #include <QComboBox>
 #include <QFormLayout>
 #include <QLabel>
 #include <QMenu>
-
-#include "decodetrace.h"
-
-#include <pv/sigsession.h>
-#include <pv/data/decoder.h>
-#include <pv/view/logicsignal.h>
-#include <pv/view/view.h>
-#include <pv/view/decode/annotation.h>
-
-using namespace boost;
-using namespace std;
+#include <QPushButton>
+#include <QToolTip>
+
+#include "decodetrace.hpp"
+
+#include <pv/session.hpp>
+#include <pv/data/decoderstack.hpp>
+#include <pv/data/decode/decoder.hpp>
+#include <pv/data/logic.hpp>
+#include <pv/data/logicsegment.hpp>
+#include <pv/data/decode/annotation.hpp>
+#include <pv/view/logicsignal.hpp>
+#include <pv/view/view.hpp>
+#include <pv/view/viewport.hpp>
+#include <pv/widgets/decodergroupbox.hpp>
+#include <pv/widgets/decodermenu.hpp>
+
+using boost::shared_lock;
+using boost::shared_mutex;
+using std::dynamic_pointer_cast;
+using std::list;
+using std::lock_guard;
+using std::make_pair;
+using std::max;
+using std::make_pair;
+using std::map;
+using std::min;
+using std::pair;
+using std::shared_ptr;
+using std::tie;
+using std::unordered_set;
+using std::vector;
 
 namespace pv {
 namespace view {
@@ -54,19 +82,71 @@ const QColor DecodeTrace::DecodeColours[4] = {
 };
 
 const QColor DecodeTrace::ErrorBgColour = QColor(0xEF, 0x29, 0x29);
+const QColor DecodeTrace::NoDecodeColour = QColor(0x88, 0x8A, 0x85);
+
+const int DecodeTrace::ArrowSize = 4;
+const double DecodeTrace::EndCapWidth = 5;
+const int DecodeTrace::DrawPadding = 100;
+
+const QColor DecodeTrace::Colours[16] = {
+	QColor(0xEF, 0x29, 0x29),
+	QColor(0xF6, 0x6A, 0x32),
+	QColor(0xFC, 0xAE, 0x3E),
+	QColor(0xFB, 0xCA, 0x47),
+	QColor(0xFC, 0xE9, 0x4F),
+	QColor(0xCD, 0xF0, 0x40),
+	QColor(0x8A, 0xE2, 0x34),
+	QColor(0x4E, 0xDC, 0x44),
+	QColor(0x55, 0xD7, 0x95),
+	QColor(0x64, 0xD1, 0xD2),
+	QColor(0x72, 0x9F, 0xCF),
+	QColor(0xD4, 0x76, 0xC4),
+	QColor(0x9D, 0x79, 0xB9),
+	QColor(0xAD, 0x7F, 0xA8),
+	QColor(0xC2, 0x62, 0x9B),
+	QColor(0xD7, 0x47, 0x6F)
+};
+
+const QColor DecodeTrace::OutlineColours[16] = {
+	QColor(0x77, 0x14, 0x14),
+	QColor(0x7B, 0x35, 0x19),
+	QColor(0x7E, 0x57, 0x1F),
+	QColor(0x7D, 0x65, 0x23),
+	QColor(0x7E, 0x74, 0x27),
+	QColor(0x66, 0x78, 0x20),
+	QColor(0x45, 0x71, 0x1A),
+	QColor(0x27, 0x6E, 0x22),
+	QColor(0x2A, 0x6B, 0x4A),
+	QColor(0x32, 0x68, 0x69),
+	QColor(0x39, 0x4F, 0x67),
+	QColor(0x6A, 0x3B, 0x62),
+	QColor(0x4E, 0x3C, 0x5C),
+	QColor(0x56, 0x3F, 0x54),
+	QColor(0x61, 0x31, 0x4D),
+	QColor(0x6B, 0x23, 0x37)
+};
 
-DecodeTrace::DecodeTrace(pv::SigSession &session,
-	boost::shared_ptr<pv::data::Decoder> decoder, int index) :
-	Trace(session, QString(decoder->decoder()->name)),
-	_decoder(decoder),
-	_binding(decoder)
+DecodeTrace::DecodeTrace(pv::Session &session,
+	std::shared_ptr<pv::data::DecoderStack> decoder_stack, int index) :
+	Trace(QString::fromUtf8(
+		decoder_stack->stack().front()->decoder()->name)),
+	session_(session),
+	decoder_stack_(decoder_stack),
+	row_height_(0),
+	max_visible_rows_(0),
+	delete_mapper_(this),
+	show_hide_mapper_(this)
 {
-	assert(_decoder);
+	assert(decoder_stack_);
 
-	_colour = DecodeColours[index % countof(DecodeColours)];
+	set_colour(DecodeColours[index % countof(DecodeColours)]);
 
-	connect(_decoder.get(), SIGNAL(new_decode_data()),
+	connect(decoder_stack_.get(), SIGNAL(new_decode_data()),
 		this, SLOT(on_new_decode_data()));
+	connect(&delete_mapper_, SIGNAL(mapped(int)),
+		this, SLOT(on_delete_decoder(int)));
+	connect(&show_hide_mapper_, SIGNAL(mapped(int)),
+		this, SLOT(on_show_hide_decoder(int)));
 }
 
 bool DecodeTrace::enabled() const
@@ -74,111 +154,166 @@ bool DecodeTrace::enabled() const
 	return true;
 }
 
-const boost::shared_ptr<pv::data::Decoder>& DecodeTrace::decoder() const
+const std::shared_ptr<pv::data::DecoderStack>& DecodeTrace::decoder() const
 {
-	return _decoder;
+	return decoder_stack_;
 }
 
-void DecodeTrace::set_view(pv::view::View *view)
+pair<int, int> DecodeTrace::v_extents() const
 {
-	assert(view);
-	Trace::set_view(view);
+	const int row_height = (ViewItemPaintParams::text_height() * 6) / 4;
+
+	return make_pair(-row_height, row_height * max_visible_rows_);
 }
 
-void DecodeTrace::paint_back(QPainter &p, int left, int right)
+void DecodeTrace::paint_back(QPainter &p, const ViewItemPaintParams &pp)
 {
-	paint_axis(p, get_y(), left, right);
+	Trace::paint_back(p, pp);
+	paint_axis(p, pp, get_visual_y());
 }
 
-void DecodeTrace::paint_mid(QPainter &p, int left, int right)
+void DecodeTrace::paint_mid(QPainter &p, const ViewItemPaintParams &pp)
 {
-	using namespace pv::view::decode;
+	using namespace pv::data::decode;
+
+	const int text_height = ViewItemPaintParams::text_height();
+	row_height_ = (text_height * 6) / 4;
+	const int annotation_height = (text_height * 5) / 4;
 
-	assert(_decoder);
-	const QString err = _decoder->error_message();
+	assert(decoder_stack_);
+	const QString err = decoder_stack_->error_message();
 	if (!err.isEmpty()) {
-		draw_error(p, err, left, right);
+		draw_unresolved_period(
+			p, annotation_height, pp.left(), pp.right());
+		draw_error(p, err, pp);
 		return;
 	}
 
-	assert(_view);
-	const int y = get_y();
+	// Iterate through the rows
+	int y = get_visual_y();
+	pair<uint64_t, uint64_t> sample_range = get_sample_range(
+		pp.left(), pp.right());
 
-	const double scale = _view->scale();
-	assert(scale > 0);
+	assert(decoder_stack_);
+	const vector<Row> rows(decoder_stack_->get_visible_rows());
 
-	double samplerate = _decoder->get_samplerate();
+	visible_rows_.clear();
+	for (size_t i = 0; i < rows.size(); i++) {
+		const Row &row = rows[i];
 
-	// Show sample rate as 1Hz when it is unknown
-	if (samplerate == 0.0)
-		samplerate = 1.0;
+		size_t base_colour = 0x13579BDF;
+		boost::hash_combine(base_colour, this);
+		boost::hash_combine(base_colour, row.decoder());
+		boost::hash_combine(base_colour, row.row());
+		base_colour >>= 16;
+
+		vector<Annotation> annotations;
+		decoder_stack_->get_annotation_subset(annotations, row,
+			sample_range.first, sample_range.second);
+		if (!annotations.empty()) {
+			draw_annotations(annotations, p, annotation_height, pp, y,
+				base_colour);
 
-	const double pixels_offset = (_view->offset() -
-		_decoder->get_start_time()) / scale;
-	const double samples_per_pixel = samplerate * scale;
+			y += row_height_;
 
-	assert(_decoder);
-	vector< shared_ptr<Annotation> > annotations(_decoder->annotations());
-	BOOST_FOREACH(shared_ptr<Annotation> a, annotations) {
-		assert(a);
-		a->paint(p, get_text_colour(), _text_size.height(),
-			left, right, samples_per_pixel, pixels_offset, y);
+			visible_rows_.push_back(rows[i]);
+		}
 	}
+
+	// Draw the hatching
+	draw_unresolved_period(p, annotation_height, pp.left(), pp.right());
+
+	// Update the maximum row count if needed
+	max_visible_rows_ = std::max(max_visible_rows_, (int)visible_rows_.size());
 }
 
-void DecodeTrace::populate_popup_form(QWidget *parent, QFormLayout *form)
+void DecodeTrace::paint_fore(QPainter &p, const ViewItemPaintParams &pp)
 {
-	const GSList *probe;
+	using namespace pv::data::decode;
 
-	assert(form);
-	assert(parent);
-	assert(_decoder);
+	assert(row_height_);
 
-	const srd_decoder *const decoder = _decoder->decoder();
+	for (size_t i = 0; i < visible_rows_.size(); i++) {
+		const int y = i * row_height_ + get_visual_y();
 
-	assert(decoder);
+		p.setPen(QPen(Qt::NoPen));
+		p.setBrush(QApplication::palette().brush(QPalette::WindowText));
 
-	Trace::populate_popup_form(parent, form);
+		if (i != 0) {
+			const QPointF points[] = {
+				QPointF(pp.left(), y - ArrowSize),
+				QPointF(pp.left() + ArrowSize, y),
+				QPointF(pp.left(), y + ArrowSize)
+			};
+			p.drawPolygon(points, countof(points));
+		}
 
-	form->addRow(new QLabel(tr("<h3>Probes</h3>"), parent));
+		const QRect r(pp.left() + ArrowSize * 2, y - row_height_ / 2,
+			pp.right() - pp.left(), row_height_);
+		const QString h(visible_rows_[i].title());
+		const int f = Qt::AlignLeft | Qt::AlignVCenter |
+			Qt::TextDontClip;
+
+		// Draw the outline
+		p.setPen(QApplication::palette().color(QPalette::Base));
+		for (int dx = -1; dx <= 1; dx++)
+			for (int dy = -1; dy <= 1; dy++)
+				if (dx != 0 && dy != 0)
+					p.drawText(r.translated(dx, dy), f, h);
+
+		// Draw the text
+		p.setPen(QApplication::palette().color(QPalette::WindowText));
+		p.drawText(r, f, h);
+	}
+}
 
-	_probe_selector_map.clear();
+void DecodeTrace::populate_popup_form(QWidget *parent, QFormLayout *form)
+{
+	using pv::data::decode::Decoder;
 
-	// Add the mandatory probes
-	for(probe = decoder->probes; probe; probe = probe->next) {
-		const struct srd_probe *const p =
-			(struct srd_probe *)probe->data;
-		QComboBox *const combo = create_probe_selector(parent, p);
-		connect(combo, SIGNAL(currentIndexChanged(int)),
-			this, SLOT(on_probe_selected(int)));
-		form->addRow(tr("<b>%1</b> (%2) *")
-			.arg(p->name).arg(p->desc), combo);
+	assert(form);
+	assert(parent);
+	assert(decoder_stack_);
 
-		_probe_selector_map[p] = combo;
-	}
+	// Add the standard options
+	Trace::populate_popup_form(parent, form);
 
-	// Add the optional probes
-	for(probe = decoder->opt_probes; probe; probe = probe->next) {
-		const struct srd_probe *const p =
-			(struct srd_probe *)probe->data;
-		QComboBox *const combo = create_probe_selector(parent, p);
-		connect(combo, SIGNAL(currentIndexChanged(int)),
-			this, SLOT(on_probe_selected(int)));
-		form->addRow(tr("<b>%1</b> (%2)")
-			.arg(p->name).arg(p->desc), combo);
+	// Add the decoder options
+	bindings_.clear();
+	channel_selectors_.clear();
+	decoder_forms_.clear();
+
+	const list< shared_ptr<Decoder> >& stack = decoder_stack_->stack();
+
+	if (stack.empty()) {
+		QLabel *const l = new QLabel(
+			tr("<p><i>No decoders in the stack</i></p>"));
+		l->setAlignment(Qt::AlignCenter);
+		form->addRow(l);
+	} else {
+		auto iter = stack.cbegin();
+		for (int i = 0; i < (int)stack.size(); i++, iter++) {
+			shared_ptr<Decoder> dec(*iter);
+			create_decoder_form(i, dec, parent, form);
+		}
 
-		_probe_selector_map[p] = combo;
+		form->addRow(new QLabel(
+			tr("<i>* Required channels</i>"), parent));
 	}
 
-	form->addRow(new QLabel(
-		tr("<i>* Required Probes</i>"), parent));
+	// Add stacking button
+	pv::widgets::DecoderMenu *const decoder_menu =
+		new pv::widgets::DecoderMenu(parent);
+	connect(decoder_menu, SIGNAL(decoder_selected(srd_decoder*)),
+		this, SLOT(on_stack_decoder(srd_decoder*)));
 
-	// Add the options
-	if (!_binding.properties().empty()) {
-		form->addRow(new QLabel(tr("<h3>Options</h3>"),
-			parent));
-		_binding.add_properties_to_form(form, true);
-	}
+	QPushButton *const stack_button =
+		new QPushButton(tr("Stack Decoder"), parent);
+	stack_button->setMenu(decoder_menu);
+
+	QHBoxLayout *stack_button_box = new QHBoxLayout;
+	stack_button_box->addWidget(stack_button, 0, Qt::AlignRight);
+	form->addRow(stack_button_box);
 }
 
 QMenu* DecodeTrace::create_context_menu(QWidget *parent)
@@ -195,16 +330,208 @@ QMenu* DecodeTrace::create_context_menu(QWidget *parent)
 	return menu;
 }
 
+void DecodeTrace::draw_annotations(vector<pv::data::decode::Annotation> annotations,
+		QPainter &p, int h, const ViewItemPaintParams &pp, int y,
+		size_t base_colour)
+{
+	using namespace pv::data::decode;
+
+	vector<Annotation> a_block;
+	int prev_ann_pos = INT_MIN;
+
+	double samples_per_pixel, pixels_offset;
+	tie(pixels_offset, samples_per_pixel) =
+		get_pixels_offset_samples_per_pixel();
+
+	// Gather all annotations that form a visual "block" and draw them as such
+	for (const Annotation &a : annotations) {
+
+		const int end = a.end_sample() / samples_per_pixel - pixels_offset;
+		const int delta = end - prev_ann_pos;
+
+		// Some annotations are in reverse order, so we cannot
+		// simply check for delta > 1
+		if (abs(delta) > 1) {
+			// Block was broken, draw it
+			if (a_block.size() == 1)
+				draw_annotation(a_block.front(), p, h, pp, y, base_colour);
+			else
+				if (a_block.size() > 0)
+					draw_annotation_block(a_block, p, h, y, base_colour);
+
+			a_block.clear();
+		}
+
+		a_block.push_back(a);
+		prev_ann_pos = end;
+	}
+
+	if (a_block.size() == 1)
+		draw_annotation(a_block.front(), p, h, pp, y, base_colour);
+	else
+		draw_annotation_block(a_block, p, h, y, base_colour);
+}
+
+void DecodeTrace::draw_annotation(const pv::data::decode::Annotation &a,
+	QPainter &p, int h, const ViewItemPaintParams &pp, int y,
+	size_t base_colour) const
+{
+	double samples_per_pixel, pixels_offset;
+	tie(pixels_offset, samples_per_pixel) =
+		get_pixels_offset_samples_per_pixel();
+
+	const double start = a.start_sample() / samples_per_pixel -
+		pixels_offset;
+	const double end = a.end_sample() / samples_per_pixel -
+		pixels_offset;
+
+	const size_t colour = (base_colour + a.format()) % countof(Colours);
+	const QColor &fill = Colours[colour];
+	const QColor &outline = OutlineColours[colour];
+
+	if (start > pp.right() + DrawPadding || end < pp.left() - DrawPadding)
+		return;
+
+	if (a.start_sample() == a.end_sample())
+		draw_instant(a, p, fill, outline, h, start, y);
+	else
+		draw_range(a, p, fill, outline, h, start, end, y);
+}
+
+void DecodeTrace::draw_annotation_block(
+	vector<pv::data::decode::Annotation> annotations, QPainter &p, int h,
+	int y, size_t base_colour) const
+{
+	using namespace pv::data::decode;
+
+	double samples_per_pixel, pixels_offset;
+	tie(pixels_offset, samples_per_pixel) =
+		get_pixels_offset_samples_per_pixel();
+
+	const double start = annotations.front().start_sample() /
+		samples_per_pixel - pixels_offset;
+	const double end = annotations.back().end_sample() /
+		samples_per_pixel - pixels_offset;
+
+	const double top = y + .5 - h / 2;
+	const double bottom = y + .5 + h / 2;
+	const double cap_width = min((end - start) / 4, EndCapWidth);
+
+	QPointF pts[] = {
+		QPointF(start, y + .5f),
+		QPointF(start + cap_width, top),
+		QPointF(end - cap_width, top),
+		QPointF(end, y + .5f),
+		QPointF(end - cap_width, bottom),
+		QPointF(start + cap_width, bottom)
+	};
+
+	const size_t colour = (base_colour + annotations.front().format()) %
+		countof(Colours);
+
+	// Check if all annotations are of the same type (i.e. we can use one color)
+	// or if we should use a neutral color (i.e. gray)
+	bool single_format = true;
+	int format = annotations.front().format();
+
+	for (const Annotation &a : annotations)
+		if (a.format() != format) {
+			single_format = false;
+			break;
+		}
+
+	p.setPen((single_format ? OutlineColours[colour] : Qt::gray));
+	p.setBrush(QBrush((single_format ? Colours[colour] : Qt::gray),
+		Qt::Dense4Pattern));
+
+	p.drawConvexPolygon(pts, countof(pts));
+}
+
+void DecodeTrace::draw_instant(const pv::data::decode::Annotation &a, QPainter &p,
+	QColor fill, QColor outline, int h, double x, int y) const
+{
+	const QString text = a.annotations().empty() ?
+		QString() : a.annotations().back();
+	const double w = min((double)p.boundingRect(QRectF(), 0, text).width(),
+		0.0) + h;
+	const QRectF rect(x - w / 2, y - h / 2, w, h);
+
+	p.setPen(outline);
+	p.setBrush(fill);
+	p.drawRoundedRect(rect, h / 2, h / 2);
+
+	p.setPen(Qt::black);
+	p.drawText(rect, Qt::AlignCenter | Qt::AlignVCenter, text);
+}
+
+void DecodeTrace::draw_range(const pv::data::decode::Annotation &a, QPainter &p,
+	QColor fill, QColor outline, int h, double start,
+	double end, int y) const
+{
+	const double top = y + .5 - h / 2;
+	const double bottom = y + .5 + h / 2;
+	const vector<QString> annotations = a.annotations();
+
+	p.setPen(outline);
+	p.setBrush(fill);
+
+	// If the two ends are within 1 pixel, draw a vertical line
+	if (start + 1.0 > end) {
+		p.drawLine(QPointF(start, top), QPointF(start, bottom));
+		return;
+	}
+
+	const double cap_width = min((end - start) / 4, EndCapWidth);
+
+	QPointF pts[] = {
+		QPointF(start, y + .5f),
+		QPointF(start + cap_width, top),
+		QPointF(end - cap_width, top),
+		QPointF(end, y + .5f),
+		QPointF(end - cap_width, bottom),
+		QPointF(start + cap_width, bottom)
+	};
+
+	p.drawConvexPolygon(pts, countof(pts));
+
+	if (annotations.empty())
+		return;
+
+	QRectF rect(start + cap_width, y - h / 2,
+		end - start - cap_width * 2, h);
+	if (rect.width() <= 4)
+		return;
+
+	p.setPen(Qt::black);
+
+	// Try to find an annotation that will fit
+	QString best_annotation;
+	int best_width = 0;
+
+	for (const QString &a : annotations) {
+		const int w = p.boundingRect(QRectF(), 0, a).width();
+		if (w <= rect.width() && w > best_width)
+			best_annotation = a, best_width = w;
+	}
+
+	if (best_annotation.isEmpty())
+		best_annotation = annotations.back();
+
+	// If not ellide the last in the list
+	p.drawText(rect, Qt::AlignCenter, p.fontMetrics().elidedText(
+		best_annotation, Qt::ElideRight, rect.width()));
+}
+
 void DecodeTrace::draw_error(QPainter &p, const QString &message,
-	int left, int right)
+	const ViewItemPaintParams &pp)
 {
-	const int y = get_y();
+	const int y = get_visual_y();
 
 	p.setPen(ErrorBgColour.darker());
 	p.setBrush(ErrorBgColour);
 
 	const QRectF bounding_rect =
-		QRectF(left, INT_MIN / 2 + y, right - left, INT_MAX);
+		QRectF(pp.width(), INT_MIN / 2 + y, pp.width(), INT_MAX);
 	const QRectF text_rect = p.boundingRect(bounding_rect,
 		Qt::AlignCenter, message);
 	const float r = text_rect.height() / 4;
@@ -212,74 +539,336 @@ void DecodeTrace::draw_error(QPainter &p, const QString &message,
 	p.drawRoundedRect(text_rect.adjusted(-r, -r, r, r), r, r,
 		Qt::AbsoluteSize);
 
-	p.setPen(get_text_colour());
+	p.setPen(Qt::black);
 	p.drawText(text_rect, message);
 }
 
-QComboBox* DecodeTrace::create_probe_selector(
-	QWidget *parent, const srd_probe *const probe)
+void DecodeTrace::draw_unresolved_period(QPainter &p, int h, int left,
+	int right) const
+{
+	using namespace pv::data;
+	using pv::data::decode::Decoder;
+
+	double samples_per_pixel, pixels_offset;
+
+	assert(decoder_stack_);	
+
+	shared_ptr<Logic> data;
+	shared_ptr<LogicSignal> logic_signal;
+
+	const list< shared_ptr<Decoder> > &stack = decoder_stack_->stack();
+
+	// We get the logic data of the first channel in the list.
+	// This works because we are currently assuming all
+	// LogicSignals have the same data/segment
+	for (const shared_ptr<Decoder> &dec : stack)
+		if (dec && !dec->channels().empty() &&
+			((logic_signal = (*dec->channels().begin()).second)) &&
+			((data = logic_signal->logic_data())))
+			break;
+
+	if (!data || data->logic_segments().empty())
+		return;
+
+	const shared_ptr<LogicSegment> segment =
+		data->logic_segments().front();
+	assert(segment);
+	const int64_t sample_count = (int64_t)segment->get_sample_count();
+	if (sample_count == 0)
+		return;
+
+	const int64_t samples_decoded = decoder_stack_->samples_decoded();
+	if (sample_count == samples_decoded)
+		return;
+
+	const int y = get_visual_y();
+
+	tie(pixels_offset, samples_per_pixel) =
+		get_pixels_offset_samples_per_pixel();
+
+	const double start = max(samples_decoded /
+		samples_per_pixel - pixels_offset, left - 1.0);
+	const double end = min(sample_count / samples_per_pixel -
+		pixels_offset, right + 1.0);
+	const QRectF no_decode_rect(start, y - h/2 + 0.5, end - start, h);
+
+	p.setPen(QPen(Qt::NoPen));
+	p.setBrush(Qt::white);
+	p.drawRect(no_decode_rect);
+
+	p.setPen(NoDecodeColour);
+	p.setBrush(QBrush(NoDecodeColour, Qt::Dense6Pattern));
+	p.drawRect(no_decode_rect);
+}
+
+pair<double, double> DecodeTrace::get_pixels_offset_samples_per_pixel() const
+{
+	assert(owner_);
+	assert(decoder_stack_);
+
+	const View *view = owner_->view();
+	assert(view);
+
+	const double scale = view->scale();
+	assert(scale > 0);
+
+	const double pixels_offset =
+		((view->offset() - decoder_stack_->start_time()) / scale).convert_to<double>();
+
+	double samplerate = decoder_stack_->samplerate();
+
+	// Show sample rate as 1Hz when it is unknown
+	if (samplerate == 0.0)
+		samplerate = 1.0;
+
+	return make_pair(pixels_offset, samplerate * scale);
+}
+
+pair<uint64_t, uint64_t> DecodeTrace::get_sample_range(
+	int x_start, int x_end) const
+{
+	double samples_per_pixel, pixels_offset;
+	tie(pixels_offset, samples_per_pixel) =
+		get_pixels_offset_samples_per_pixel();
+
+	const uint64_t start = (uint64_t)max(
+		(x_start + pixels_offset) * samples_per_pixel, 0.0);
+	const uint64_t end = (uint64_t)max(
+		(x_end + pixels_offset) * samples_per_pixel, 0.0);
+
+	return make_pair(start, end);
+}
+
+int DecodeTrace::get_row_at_point(const QPoint &point)
+{
+	if (!row_height_)
+		return -1;
+
+	const int y = (point.y() - get_visual_y() + row_height_ / 2);
+
+	/* Integer divison of (x-1)/x would yield 0, so we check for this. */
+	if (y < 0)
+		return -1;
+
+	const int row = y / row_height_;
+
+	if (row >= (int)visible_rows_.size())
+		return -1;
+
+	return row;
+}
+
+const QString DecodeTrace::get_annotation_at_point(const QPoint &point)
+{
+	using namespace pv::data::decode;
+
+	if (!enabled())
+		return QString();
+
+	const pair<uint64_t, uint64_t> sample_range =
+		get_sample_range(point.x(), point.x() + 1);
+	const int row = get_row_at_point(point);
+	if (row < 0)
+		return QString();
+
+	vector<pv::data::decode::Annotation> annotations;
+
+	assert(decoder_stack_);
+	decoder_stack_->get_annotation_subset(annotations, visible_rows_[row],
+		sample_range.first, sample_range.second);
+
+	return (annotations.empty()) ?
+		QString() : annotations[0].annotations().front();
+}
+
+void DecodeTrace::hover_point_changed()
+{
+	assert(owner_);
+
+	const View *const view = owner_->view();
+	assert(view);
+
+	QPoint hp = view->hover_point();
+	QString ann = get_annotation_at_point(hp);
+
+	assert(view);
+
+	if (!row_height_ || ann.isEmpty()) {
+		QToolTip::hideText();
+		return;
+	}
+
+	const int hover_row = get_row_at_point(hp);
+
+	QFontMetrics m(QToolTip::font());
+	const QRect text_size = m.boundingRect(QRect(), 0, ann);
+
+	// This is OS-specific and unfortunately we can't query it, so
+	// use an approximation to at least try to minimize the error.
+	const int padding = 8;
+
+	// Make sure the tool tip doesn't overlap with the mouse cursor.
+	// If it did, the tool tip would constantly hide and re-appear.
+	// We also push it up by one row so that it appears above the
+	// decode trace, not below.
+	hp.setX(hp.x() - (text_size.width() / 2) - padding);
+
+	hp.setY(get_visual_y() - (row_height_ / 2) +
+		(hover_row * row_height_) -
+		row_height_ - text_size.height() - padding);
+
+	QToolTip::showText(view->viewport()->mapToGlobal(hp), ann);
+}
+
+void DecodeTrace::create_decoder_form(int index,
+	shared_ptr<data::decode::Decoder> &dec, QWidget *parent,
+	QFormLayout *form)
 {
-	const vector< shared_ptr<Signal> > sigs = _session.get_signals();
+	const GSList *l;
+
+	assert(dec);
+	const srd_decoder *const decoder = dec->decoder();
+	assert(decoder);
+
+	const bool decoder_deletable = index > 0;
+
+	pv::widgets::DecoderGroupBox *const group =
+		new pv::widgets::DecoderGroupBox(
+			QString::fromUtf8(decoder->name), nullptr, decoder_deletable);
+	group->set_decoder_visible(dec->shown());
+
+	if (decoder_deletable) {
+		delete_mapper_.setMapping(group, index);
+		connect(group, SIGNAL(delete_decoder()), &delete_mapper_, SLOT(map()));
+	}
 
-	assert(_decoder);
-	const map<const srd_probe*,
-		shared_ptr<LogicSignal> >::const_iterator probe_iter =
-		_decoder->probes().find(probe);
+	show_hide_mapper_.setMapping(group, index);
+	connect(group, SIGNAL(show_hide_decoder()),
+		&show_hide_mapper_, SLOT(map()));
+
+	QFormLayout *const decoder_form = new QFormLayout;
+	group->add_layout(decoder_form);
+
+	// Add the mandatory channels
+	for (l = decoder->channels; l; l = l->next) {
+		const struct srd_channel *const pdch =
+			(struct srd_channel *)l->data;
+		QComboBox *const combo = create_channel_selector(parent, dec, pdch);
+		connect(combo, SIGNAL(currentIndexChanged(int)),
+			this, SLOT(on_channel_selected(int)));
+		decoder_form->addRow(tr("<b>%1</b> (%2) *")
+			.arg(QString::fromUtf8(pdch->name))
+			.arg(QString::fromUtf8(pdch->desc)), combo);
+
+		const ChannelSelector s = {combo, dec, pdch};
+		channel_selectors_.push_back(s);
+	}
+
+	// Add the optional channels
+	for (l = decoder->opt_channels; l; l = l->next) {
+		const struct srd_channel *const pdch =
+			(struct srd_channel *)l->data;
+		QComboBox *const combo = create_channel_selector(parent, dec, pdch);
+		connect(combo, SIGNAL(currentIndexChanged(int)),
+			this, SLOT(on_channel_selected(int)));
+		decoder_form->addRow(tr("<b>%1</b> (%2)")
+			.arg(QString::fromUtf8(pdch->name))
+			.arg(QString::fromUtf8(pdch->desc)), combo);
+
+		const ChannelSelector s = {combo, dec, pdch};
+		channel_selectors_.push_back(s);
+	}
+
+	// Add the options
+	shared_ptr<binding::Decoder> binding(
+		new binding::Decoder(decoder_stack_, dec));
+	binding->add_properties_to_form(decoder_form, true);
+
+	bindings_.push_back(binding);
+
+	form->addRow(group);
+	decoder_forms_.push_back(group);
+}
+
+QComboBox* DecodeTrace::create_channel_selector(
+	QWidget *parent, const shared_ptr<data::decode::Decoder> &dec,
+	const srd_channel *const pdch)
+{
+	assert(dec);
+
+	const auto sigs(session_.signals());
+
+	vector< shared_ptr<Signal> > sig_list(sigs.begin(), sigs.end());
+	std::sort(sig_list.begin(), sig_list.end(),
+		[](const shared_ptr<Signal> &a, const shared_ptr<Signal> b) {
+			return a->name().compare(b->name()) < 0; });
+
+	assert(decoder_stack_);
+	const auto channel_iter = dec->channels().find(pdch);
 
 	QComboBox *selector = new QComboBox(parent);
 
-	selector->addItem("-", qVariantFromValue((void*)NULL));
+	selector->addItem("-", qVariantFromValue((void*)nullptr));
 
-	if (probe_iter == _decoder->probes().end())
+	if (channel_iter == dec->channels().end())
 		selector->setCurrentIndex(0);
 
-	for(size_t i = 0; i < sigs.size(); i++) {
-		const shared_ptr<view::Signal> s(sigs[i]);
+	for (const shared_ptr<view::Signal> &s : sig_list) {
 		assert(s);
-
-		if (dynamic_pointer_cast<LogicSignal>(s) && s->enabled())
-		{
-			selector->addItem(s->get_name(),
+		if (dynamic_pointer_cast<LogicSignal>(s) && s->enabled()) {
+			selector->addItem(s->name(),
 				qVariantFromValue((void*)s.get()));
-			if ((*probe_iter).second == s)
-				selector->setCurrentIndex(i + 1);
+
+			if (channel_iter != dec->channels().end() &&
+				(*channel_iter).second == s)
+				selector->setCurrentIndex(
+					selector->count() - 1);
 		}
 	}
 
 	return selector;
 }
 
-void DecodeTrace::commit_probes()
+void DecodeTrace::commit_decoder_channels(shared_ptr<data::decode::Decoder> &dec)
 {
-	assert(_decoder);
+	assert(dec);
+
+	map<const srd_channel*, shared_ptr<LogicSignal> > channel_map;
 
-	map<const srd_probe*, shared_ptr<LogicSignal> > probe_map;
-	const vector< shared_ptr<Signal> > sigs = _session.get_signals();
+	const unordered_set< shared_ptr<Signal> > sigs(session_.signals());
+
+	for (const ChannelSelector &s : channel_selectors_) {
+		if (s.decoder_ != dec)
+			break;
 
-	for(map<const srd_probe*, QComboBox*>::const_iterator i =
-		_probe_selector_map.begin();
-		i != _probe_selector_map.end(); i++)
-	{
-		const QComboBox *const combo = (*i).second;
 		const LogicSignal *const selection =
-			(LogicSignal*)combo->itemData(combo->currentIndex()).
-			value<void*>();
+			(LogicSignal*)s.combo_->itemData(
+				s.combo_->currentIndex()).value<void*>();
 
-		BOOST_FOREACH(shared_ptr<Signal> s, sigs)
-			if(s.get() == selection) {
-				probe_map[(*i).first] =
-					dynamic_pointer_cast<LogicSignal>(s);
+		for (shared_ptr<Signal> sig : sigs)
+			if (sig.get() == selection) {
+				channel_map[s.pdch_] =
+					dynamic_pointer_cast<LogicSignal>(sig);
 				break;
 			}
 	}
 
-	_decoder->set_probes(probe_map);
+	dec->set_channels(channel_map);
+}
+
+void DecodeTrace::commit_channels()
+{
+	assert(decoder_stack_);
+	for (shared_ptr<data::decode::Decoder> dec : decoder_stack_->stack())
+		commit_decoder_channels(dec);
+
+	decoder_stack_->begin_decode();
 }
 
 void DecodeTrace::on_new_decode_data()
 {
-	if (_view)
-		_view->update_viewport();
+	if (owner_)
+		owner_->row_item_appearance_changed(false, true);
 }
 
 void DecodeTrace::delete_pressed()
@@ -289,12 +878,57 @@ void DecodeTrace::delete_pressed()
 
 void DecodeTrace::on_delete()
 {
-	_session.remove_decode_signal(this);
+	session_.remove_decode_signal(this);
+}
+
+void DecodeTrace::on_channel_selected(int)
+{
+	commit_channels();
+}
+
+void DecodeTrace::on_stack_decoder(srd_decoder *decoder)
+{
+	assert(decoder);
+	assert(decoder_stack_);
+	decoder_stack_->push(shared_ptr<data::decode::Decoder>(
+		new data::decode::Decoder(decoder)));
+	decoder_stack_->begin_decode();
+
+	create_popup_form();
+}
+
+void DecodeTrace::on_delete_decoder(int index)
+{
+	decoder_stack_->remove(index);
+
+	// Update the popup
+	create_popup_form();	
+
+	decoder_stack_->begin_decode();
 }
 
-void DecodeTrace::on_probe_selected(int)
+void DecodeTrace::on_show_hide_decoder(int index)
 {
-	commit_probes();
+	using pv::data::decode::Decoder;
+
+	const list< shared_ptr<Decoder> > stack(decoder_stack_->stack());
+
+	// Find the decoder in the stack
+	auto iter = stack.cbegin();
+	for (int i = 0; i < index; i++, iter++)
+		assert(iter != stack.end());
+
+	shared_ptr<Decoder> dec = *iter;
+	assert(dec);
+
+	const bool show = !dec->shown();
+	dec->show(show);
+
+	assert(index < (int)decoder_forms_.size());
+	decoder_forms_[index]->set_decoder_visible(show);
+
+	if (owner_)
+		owner_->row_item_appearance_changed(false, true);
 }
 
 } // namespace view