X-Git-Url: http://git.code-monkey.de/?a=blobdiff_plain;f=pv%2Fview%2Fdecodetrace.cpp;h=7e2051a4022202ff77ea496e5259c147f07475e9;hb=7491a29f33471b38e161b3254f4d8e708b05f929;hp=28443673498419bd6a2d3d2de18ed5f1e741162f;hpb=b93295580db08d9008b9c9e49a3a3a86ef562f14;p=pulseview.git

diff --git a/pv/view/decodetrace.cpp b/pv/view/decodetrace.cpp
index 2844367..7e2051a 100644
--- a/pv/view/decodetrace.cpp
+++ b/pv/view/decodetrace.cpp
@@ -31,14 +31,17 @@ extern "C" {
 #include <QFormLayout>
 #include <QLabel>
 #include <QMenu>
+#include <QPushButton>
 
 #include "decodetrace.h"
 
 #include <pv/sigsession.h>
-#include <pv/data/decoder.h>
+#include <pv/data/decoderstack.h>
+#include <pv/data/decode/decoder.h>
 #include <pv/view/logicsignal.h>
 #include <pv/view/view.h>
 #include <pv/view/decode/annotation.h>
+#include <pv/widgets/decodermenu.h>
 
 using namespace boost;
 using namespace std;
@@ -56,16 +59,15 @@ const QColor DecodeTrace::DecodeColours[4] = {
 const QColor DecodeTrace::ErrorBgColour = QColor(0xEF, 0x29, 0x29);
 
 DecodeTrace::DecodeTrace(pv::SigSession &session,
-	boost::shared_ptr<pv::data::Decoder> decoder, int index) :
-	Trace(session, QString(decoder->decoder()->name)),
-	_decoder(decoder),
-	_binding(decoder)
+	boost::shared_ptr<pv::data::DecoderStack> decoder_stack, int index) :
+	Trace(session, QString(decoder_stack->stack().front()->decoder()->name)),
+	_decoder_stack(decoder_stack)
 {
-	assert(_decoder);
+	assert(_decoder_stack);
 
 	_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()));
 }
 
@@ -74,9 +76,9 @@ bool DecodeTrace::enabled() const
 	return true;
 }
 
-const boost::shared_ptr<pv::data::Decoder>& DecodeTrace::decoder() const
+const boost::shared_ptr<pv::data::DecoderStack>& DecodeTrace::decoder() const
 {
-	return _decoder;
+	return _decoder_stack;
 }
 
 void DecodeTrace::set_view(pv::view::View *view)
@@ -94,8 +96,8 @@ void DecodeTrace::paint_mid(QPainter &p, int left, int right)
 {
 	using namespace pv::view::decode;
 
-	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);
 		return;
@@ -107,18 +109,18 @@ void DecodeTrace::paint_mid(QPainter &p, int left, int right)
 	const double scale = _view->scale();
 	assert(scale > 0);
 
-	double samplerate = _decoder->get_samplerate();
+	double samplerate = _decoder_stack->get_samplerate();
 
 	// Show sample rate as 1Hz when it is unknown
 	if (samplerate == 0.0)
 		samplerate = 1.0;
 
 	const double pixels_offset = (_view->offset() -
-		_decoder->get_start_time()) / scale;
+		_decoder_stack->get_start_time()) / scale;
 	const double samples_per_pixel = samplerate * scale;
 
-	assert(_decoder);
-	vector< shared_ptr<Annotation> > annotations(_decoder->annotations());
+	assert(_decoder_stack);
+	vector< shared_ptr<Annotation> > annotations(_decoder_stack->annotations());
 	BOOST_FOREACH(shared_ptr<Annotation> a, annotations) {
 		assert(a);
 		a->paint(p, get_text_colour(), _text_size.height(),
@@ -128,57 +130,37 @@ void DecodeTrace::paint_mid(QPainter &p, int left, int right)
 
 void DecodeTrace::populate_popup_form(QWidget *parent, QFormLayout *form)
 {
-	const GSList *probe;
-
 	assert(form);
 	assert(parent);
-	assert(_decoder);
-
-	const srd_decoder *const decoder = _decoder->decoder();
-
-	assert(decoder);
+	assert(_decoder_stack);
 
+	// Add the standard options
 	Trace::populate_popup_form(parent, form);
 
-	form->addRow(new QLabel(tr("<h3>Probes</h3>"), parent));
-
-	_probe_selector_map.clear();
-
-	// 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);
-
-		_probe_selector_map[p] = combo;
-	}
-
-	// 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();
+	_probe_selectors.clear();
 
-		_probe_selector_map[p] = combo;
-	}
+	BOOST_FOREACH(shared_ptr<data::decode::Decoder> dec,
+		_decoder_stack->stack())
+		create_decoder_form(dec, parent, form);
 
 	form->addRow(new QLabel(
 		tr("<i>* Required Probes</i>"), parent));
 
-	// Add the options
-	if (!_binding.properties().empty()) {
-		form->addRow(new QLabel(tr("<h3>Options</h3>"),
-			parent));
-		_binding.add_properties_to_form(form, true);
-	}
+	// 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*)));
+
+	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)
@@ -216,21 +198,71 @@ void DecodeTrace::draw_error(QPainter &p, const QString &message,
 	p.drawText(text_rect, message);
 }
 
+void DecodeTrace::create_decoder_form(shared_ptr<data::decode::Decoder> &dec,
+	QWidget *parent, QFormLayout *form)
+{
+	const GSList *probe;
+
+	assert(dec);
+	const srd_decoder *const decoder = dec->decoder();
+	assert(decoder);
+
+	form->addRow(new QLabel(tr("<h3>%1</h3>").arg(decoder->name), parent));
+
+	// 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, dec, 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);
+
+		const ProbeSelector s = {combo, dec, p};
+		_probe_selectors.push_back(s);
+	}
+
+	// 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, dec, 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);
+
+		const ProbeSelector s = {combo, dec, p};
+		_probe_selectors.push_back(s);
+	}
+
+	// Add the options
+	shared_ptr<prop::binding::DecoderOptions> binding(
+		new prop::binding::DecoderOptions(_decoder_stack, dec));
+	binding->add_properties_to_form(form, true);
+
+	_bindings.push_back(binding);
+}
+
 QComboBox* DecodeTrace::create_probe_selector(
-	QWidget *parent, const srd_probe *const probe)
+	QWidget *parent, const shared_ptr<data::decode::Decoder> &dec,
+	const srd_probe *const probe)
 {
+	assert(dec);
+
 	const vector< shared_ptr<Signal> > sigs = _session.get_signals();
 
-	assert(_decoder);
+	assert(_decoder_stack);
 	const map<const srd_probe*,
 		shared_ptr<LogicSignal> >::const_iterator probe_iter =
-		_decoder->probes().find(probe);
+		dec->probes().find(probe);
 
 	QComboBox *selector = new QComboBox(parent);
 
 	selector->addItem("-", qVariantFromValue((void*)NULL));
 
-	if (probe_iter == _decoder->probes().end())
+	if (probe_iter == dec->probes().end())
 		selector->setCurrentIndex(0);
 
 	for(size_t i = 0; i < sigs.size(); i++) {
@@ -249,31 +281,41 @@ QComboBox* DecodeTrace::create_probe_selector(
 	return selector;
 }
 
-void DecodeTrace::commit_probes()
+void DecodeTrace::commit_decoder_probes(shared_ptr<data::decode::Decoder> &dec)
 {
-	assert(_decoder);
+	assert(dec);
 
 	map<const srd_probe*, shared_ptr<LogicSignal> > probe_map;
 	const vector< shared_ptr<Signal> > sigs = _session.get_signals();
 
-	for(map<const srd_probe*, QComboBox*>::const_iterator i =
-		_probe_selector_map.begin();
-		i != _probe_selector_map.end(); i++)
+	BOOST_FOREACH(const ProbeSelector &s, _probe_selectors)
 	{
-		const QComboBox *const combo = (*i).second;
+		if(s._decoder != dec)
+			break;
+
 		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);
+		BOOST_FOREACH(shared_ptr<Signal> sig, sigs)
+			if(sig.get() == selection) {
+				probe_map[s._probe] =
+					dynamic_pointer_cast<LogicSignal>(sig);
 				break;
 			}
 	}
 
-	_decoder->set_probes(probe_map);
+	dec->set_probes(probe_map);
+}
+
+void DecodeTrace::commit_probes()
+{
+	assert(_decoder_stack);
+	BOOST_FOREACH(shared_ptr<data::decode::Decoder> dec,
+		_decoder_stack->stack())
+		commit_decoder_probes(dec);
+
+	_decoder_stack->begin_decode();
 }
 
 void DecodeTrace::on_new_decode_data()
@@ -297,5 +339,14 @@ void DecodeTrace::on_probe_selected(int)
 	commit_probes();
 }
 
+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();
+}
+
 } // namespace view
 } // namespace pv