Update #include directives to work with Qt5 as well as Qt4
[pulseview.git] / pv / view / decodetrace.cpp
1 /*
2  * This file is part of the PulseView project.
3  *
4  * Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
19  */
20
21 extern "C" {
22 #include <libsigrokdecode/libsigrokdecode.h>
23 }
24
25 #include <extdef.h>
26
27 #include <boost/functional/hash.hpp>
28
29 #include <QAction>
30 #include <QApplication>
31 #include <QComboBox>
32 #include <QFormLayout>
33 #include <QLabel>
34 #include <QMenu>
35 #include <QPushButton>
36
37 #include "decodetrace.h"
38
39 #include <pv/sigsession.h>
40 #include <pv/data/decoderstack.h>
41 #include <pv/data/decode/decoder.h>
42 #include <pv/data/logic.h>
43 #include <pv/data/logicsnapshot.h>
44 #include <pv/data/decode/annotation.h>
45 #include <pv/view/logicsignal.h>
46 #include <pv/view/view.h>
47 #include <pv/widgets/decodergroupbox.h>
48 #include <pv/widgets/decodermenu.h>
49
50 using std::dynamic_pointer_cast;
51 using std::list;
52 using std::max;
53 using std::map;
54 using std::min;
55 using std::shared_ptr;
56 using std::vector;
57
58 namespace pv {
59 namespace view {
60
61 const QColor DecodeTrace::DecodeColours[4] = {
62         QColor(0xEF, 0x29, 0x29),       // Red
63         QColor(0xFC, 0xE9, 0x4F),       // Yellow
64         QColor(0x8A, 0xE2, 0x34),       // Green
65         QColor(0x72, 0x9F, 0xCF)        // Blue
66 };
67
68 const QColor DecodeTrace::ErrorBgColour = QColor(0xEF, 0x29, 0x29);
69 const QColor DecodeTrace::NoDecodeColour = QColor(0x88, 0x8A, 0x85);
70
71 const int DecodeTrace::ArrowSize = 4;
72 const double DecodeTrace::EndCapWidth = 5;
73 const int DecodeTrace::DrawPadding = 100;
74
75 const QColor DecodeTrace::Colours[16] = {
76         QColor(0xEF, 0x29, 0x29),
77         QColor(0xF6, 0x6A, 0x32),
78         QColor(0xFC, 0xAE, 0x3E),
79         QColor(0xFB, 0xCA, 0x47),
80         QColor(0xFC, 0xE9, 0x4F),
81         QColor(0xCD, 0xF0, 0x40),
82         QColor(0x8A, 0xE2, 0x34),
83         QColor(0x4E, 0xDC, 0x44),
84         QColor(0x55, 0xD7, 0x95),
85         QColor(0x64, 0xD1, 0xD2),
86         QColor(0x72, 0x9F, 0xCF),
87         QColor(0xD4, 0x76, 0xC4),
88         QColor(0x9D, 0x79, 0xB9),
89         QColor(0xAD, 0x7F, 0xA8),
90         QColor(0xC2, 0x62, 0x9B),
91         QColor(0xD7, 0x47, 0x6F)
92 };
93
94 const QColor DecodeTrace::OutlineColours[16] = {
95         QColor(0x77, 0x14, 0x14),
96         QColor(0x7B, 0x35, 0x19),
97         QColor(0x7E, 0x57, 0x1F),
98         QColor(0x7D, 0x65, 0x23),
99         QColor(0x7E, 0x74, 0x27),
100         QColor(0x66, 0x78, 0x20),
101         QColor(0x45, 0x71, 0x1A),
102         QColor(0x27, 0x6E, 0x22),
103         QColor(0x2A, 0x6B, 0x4A),
104         QColor(0x32, 0x68, 0x69),
105         QColor(0x39, 0x4F, 0x67),
106         QColor(0x6A, 0x3B, 0x62),
107         QColor(0x4E, 0x3C, 0x5C),
108         QColor(0x56, 0x3F, 0x54),
109         QColor(0x61, 0x31, 0x4D),
110         QColor(0x6B, 0x23, 0x37)
111 };
112
113 DecodeTrace::DecodeTrace(pv::SigSession &session,
114         std::shared_ptr<pv::data::DecoderStack> decoder_stack, int index) :
115         Trace(QString::fromUtf8(
116                 decoder_stack->stack().front()->decoder()->name)),
117         _session(session),
118         _decoder_stack(decoder_stack),
119         _delete_mapper(this),
120         _show_hide_mapper(this)
121 {
122         assert(_decoder_stack);
123
124         _colour = DecodeColours[index % countof(DecodeColours)];
125
126         connect(_decoder_stack.get(), SIGNAL(new_decode_data()),
127                 this, SLOT(on_new_decode_data()));
128         connect(&_delete_mapper, SIGNAL(mapped(int)),
129                 this, SLOT(on_delete_decoder(int)));
130         connect(&_show_hide_mapper, SIGNAL(mapped(int)),
131                 this, SLOT(on_show_hide_decoder(int)));
132 }
133
134 bool DecodeTrace::enabled() const
135 {
136         return true;
137 }
138
139 const std::shared_ptr<pv::data::DecoderStack>& DecodeTrace::decoder() const
140 {
141         return _decoder_stack;
142 }
143
144 void DecodeTrace::set_view(pv::view::View *view)
145 {
146         assert(view);
147         Trace::set_view(view);
148 }
149
150 void DecodeTrace::paint_back(QPainter &p, int left, int right)
151 {
152         Trace::paint_back(p, left, right);
153         paint_axis(p, get_y(), left, right);
154 }
155
156 void DecodeTrace::paint_mid(QPainter &p, int left, int right)
157 {
158         using namespace pv::data::decode;
159
160         const double scale = _view->scale();
161         assert(scale > 0);
162
163         double samplerate = _decoder_stack->samplerate();
164
165         _cur_row_headings.clear();
166
167         // Show sample rate as 1Hz when it is unknown
168         if (samplerate == 0.0)
169                 samplerate = 1.0;
170
171         const double pixels_offset = (_view->offset() -
172                 _decoder_stack->get_start_time()) / scale;
173         const double samples_per_pixel = samplerate * scale;
174
175         const uint64_t start_sample = (uint64_t)max((left + pixels_offset) *
176                 samples_per_pixel, 0.0);
177         const uint64_t end_sample = (uint64_t)max((right + pixels_offset) *
178                 samples_per_pixel, 0.0);
179
180         QFontMetrics m(QApplication::font());
181         const int text_height =  m.boundingRect(QRect(), 0, "Tg").height();
182         const int annotation_height = (text_height * 5) / 4;
183         const int row_height = (text_height * 6) / 4;
184
185         assert(_decoder_stack);
186         const QString err = _decoder_stack->error_message();
187         if (!err.isEmpty())
188         {
189                 draw_unresolved_period(p, annotation_height, left, right,
190                         samples_per_pixel, pixels_offset);
191                 draw_error(p, err, left, right);
192                 return;
193         }
194
195         // Iterate through the rows
196         assert(_view);
197         int y = get_y();
198
199         assert(_decoder_stack);
200
201         const vector<Row> rows(_decoder_stack->get_visible_rows());
202         for (size_t i = 0; i < rows.size(); i++)
203         {
204                 const Row &row = rows[i];
205
206                 size_t base_colour = 0x13579BDF;
207                 boost::hash_combine(base_colour, this);
208                 boost::hash_combine(base_colour, row.decoder());
209                 boost::hash_combine(base_colour, row.row());
210                 base_colour >>= 16;
211
212                 vector<Annotation> annotations;
213                 _decoder_stack->get_annotation_subset(annotations, row,
214                         start_sample, end_sample);
215                 if (!annotations.empty()) {
216                         for (const Annotation &a : annotations)
217                                 draw_annotation(a, p, get_text_colour(),
218                                         annotation_height, left, right,
219                                         samples_per_pixel, pixels_offset, y,
220                                         base_colour);
221                         y += row_height;
222
223                         _cur_row_headings.push_back(row.title());
224                 }
225         }
226
227         // Draw the hatching
228         draw_unresolved_period(p, annotation_height, left, right,
229                 samples_per_pixel, pixels_offset);
230 }
231
232 void DecodeTrace::paint_fore(QPainter &p, int left, int right)
233 {
234         using namespace pv::data::decode;
235
236         (void)right;
237
238         QFontMetrics m(QApplication::font());
239         const int text_height =  m.boundingRect(QRect(), 0, "Tg").height();
240         const int row_height = (text_height * 6) / 4;
241
242         for (size_t i = 0; i < _cur_row_headings.size(); i++)
243         {
244                 const int y = i * row_height + get_y();
245
246                 p.setPen(QPen(Qt::NoPen));
247                 p.setBrush(QApplication::palette().brush(QPalette::WindowText));
248
249                 if (i != 0)
250                 {
251                         const QPointF points[] = {
252                                 QPointF(left, y - ArrowSize),
253                                 QPointF(left + ArrowSize, y),
254                                 QPointF(left, y + ArrowSize)
255                         };
256                         p.drawPolygon(points, countof(points));
257                 }
258
259                 const QRect r(left + ArrowSize * 2, y - row_height / 2,
260                         right - left, row_height);
261                 const QString h(_cur_row_headings[i]);
262                 const int f = Qt::AlignLeft | Qt::AlignVCenter |
263                         Qt::TextDontClip;
264
265                 // Draw the outline
266                 p.setPen(QApplication::palette().color(QPalette::Base));
267                 for (int dx = -1; dx <= 1; dx++)
268                         for (int dy = -1; dy <= 1; dy++)
269                                 if (dx != 0 && dy != 0)
270                                         p.drawText(r.translated(dx, dy), f, h);
271
272                 // Draw the text
273                 p.setPen(QApplication::palette().color(QPalette::WindowText));
274                 p.drawText(r, f, h);
275         }
276 }
277
278 void DecodeTrace::populate_popup_form(QWidget *parent, QFormLayout *form)
279 {
280         using pv::data::decode::Decoder;
281
282         assert(form);
283         assert(parent);
284         assert(_decoder_stack);
285
286         // Add the standard options
287         Trace::populate_popup_form(parent, form);
288
289         // Add the decoder options
290         _bindings.clear();
291         _probe_selectors.clear();
292         _decoder_forms.clear();
293
294         const list< shared_ptr<Decoder> >& stack = _decoder_stack->stack();
295
296         if (stack.empty())
297         {
298                 QLabel *const l = new QLabel(
299                         tr("<p><i>No decoders in the stack</i></p>"));
300                 l->setAlignment(Qt::AlignCenter);
301                 form->addRow(l);
302         }
303         else
304         {
305                 auto iter = stack.cbegin();
306                 for (int i = 0; i < (int)stack.size(); i++, iter++) {
307                         shared_ptr<Decoder> dec(*iter);
308                         create_decoder_form(i, dec, parent, form);
309                 }
310
311                 form->addRow(new QLabel(
312                         tr("<i>* Required channels</i>"), parent));
313         }
314
315         // Add stacking button
316         pv::widgets::DecoderMenu *const decoder_menu =
317                 new pv::widgets::DecoderMenu(parent);
318         connect(decoder_menu, SIGNAL(decoder_selected(srd_decoder*)),
319                 this, SLOT(on_stack_decoder(srd_decoder*)));
320
321         QPushButton *const stack_button =
322                 new QPushButton(tr("Stack Decoder"), parent);
323         stack_button->setMenu(decoder_menu);
324
325         QHBoxLayout *stack_button_box = new QHBoxLayout;
326         stack_button_box->addWidget(stack_button, 0, Qt::AlignRight);
327         form->addRow(stack_button_box);
328 }
329
330 QMenu* DecodeTrace::create_context_menu(QWidget *parent)
331 {
332         QMenu *const menu = Trace::create_context_menu(parent);
333
334         menu->addSeparator();
335
336         QAction *const del = new QAction(tr("Delete"), this);
337         del->setShortcuts(QKeySequence::Delete);
338         connect(del, SIGNAL(triggered()), this, SLOT(on_delete()));
339         menu->addAction(del);
340
341         return menu;
342 }
343
344 void DecodeTrace::draw_annotation(const pv::data::decode::Annotation &a,
345         QPainter &p, QColor text_color, int h, int left, int right,
346         double samples_per_pixel, double pixels_offset, int y,
347         size_t base_colour) const
348 {
349         const double start = a.start_sample() / samples_per_pixel -
350                 pixels_offset;
351         const double end = a.end_sample() / samples_per_pixel -
352                 pixels_offset;
353
354         const size_t colour = (base_colour + a.format()) % countof(Colours);
355         const QColor &fill = Colours[colour];
356         const QColor &outline = OutlineColours[colour];
357
358         if (start > right + DrawPadding || end < left - DrawPadding)
359                 return;
360
361         if (a.start_sample() == a.end_sample())
362                 draw_instant(a, p, fill, outline, text_color, h,
363                         start, y);
364         else
365                 draw_range(a, p, fill, outline, text_color, h,
366                         start, end, y);
367 }
368
369 void DecodeTrace::draw_instant(const pv::data::decode::Annotation &a, QPainter &p,
370         QColor fill, QColor outline, QColor text_color, int h, double x, int y) const
371 {
372         const QString text = a.annotations().empty() ?
373                 QString() : a.annotations().back();
374         const double w = min((double)p.boundingRect(QRectF(), 0, text).width(),
375                 0.0) + h;
376         const QRectF rect(x - w / 2, y - h / 2, w, h);
377
378         p.setPen(outline);
379         p.setBrush(fill);
380         p.drawRoundedRect(rect, h / 2, h / 2);
381
382         p.setPen(text_color);
383         p.drawText(rect, Qt::AlignCenter | Qt::AlignVCenter, text);
384 }
385
386 void DecodeTrace::draw_range(const pv::data::decode::Annotation &a, QPainter &p,
387         QColor fill, QColor outline, QColor text_color, int h, double start,
388         double end, int y) const
389 {
390         const double top = y + .5 - h / 2;
391         const double bottom = y + .5 + h / 2;
392         const vector<QString> annotations = a.annotations();
393
394         p.setPen(outline);
395         p.setBrush(fill);
396
397         // If the two ends are within 1 pixel, draw a vertical line
398         if (start + 1.0 > end)
399         {
400                 p.drawLine(QPointF(start, top), QPointF(start, bottom));
401                 return;
402         }
403
404         const double cap_width = min((end - start) / 4, EndCapWidth);
405
406         QPointF pts[] = {
407                 QPointF(start, y + .5f),
408                 QPointF(start + cap_width, top),
409                 QPointF(end - cap_width, top),
410                 QPointF(end, y + .5f),
411                 QPointF(end - cap_width, bottom),
412                 QPointF(start + cap_width, bottom)
413         };
414
415         p.drawConvexPolygon(pts, countof(pts));
416
417         if (annotations.empty())
418                 return;
419
420         QRectF rect(start + cap_width, y - h / 2,
421                 end - start - cap_width * 2, h);
422         if (rect.width() <= 4)
423                 return;
424
425         p.setPen(text_color);
426
427         // Try to find an annotation that will fit
428         QString best_annotation;
429         int best_width = 0;
430
431         for (const QString &a : annotations) {
432                 const int w = p.boundingRect(QRectF(), 0, a).width();
433                 if (w <= rect.width() && w > best_width)
434                         best_annotation = a, best_width = w;
435         }
436
437         if (best_annotation.isEmpty())
438                 best_annotation = annotations.back();
439
440         // If not ellide the last in the list
441         p.drawText(rect, Qt::AlignCenter, p.fontMetrics().elidedText(
442                 best_annotation, Qt::ElideRight, rect.width()));
443 }
444
445 void DecodeTrace::draw_error(QPainter &p, const QString &message,
446         int left, int right)
447 {
448         const int y = get_y();
449
450         p.setPen(ErrorBgColour.darker());
451         p.setBrush(ErrorBgColour);
452
453         const QRectF bounding_rect =
454                 QRectF(left, INT_MIN / 2 + y, right - left, INT_MAX);
455         const QRectF text_rect = p.boundingRect(bounding_rect,
456                 Qt::AlignCenter, message);
457         const float r = text_rect.height() / 4;
458
459         p.drawRoundedRect(text_rect.adjusted(-r, -r, r, r), r, r,
460                 Qt::AbsoluteSize);
461
462         p.setPen(get_text_colour());
463         p.drawText(text_rect, message);
464 }
465
466 void DecodeTrace::draw_unresolved_period(QPainter &p, int h, int left,
467         int right, double samples_per_pixel, double pixels_offset) 
468 {
469         using namespace pv::data;
470         using pv::data::decode::Decoder;
471
472         assert(_decoder_stack); 
473
474         shared_ptr<Logic> data;
475         shared_ptr<LogicSignal> logic_signal;
476
477         const list< shared_ptr<Decoder> > &stack = _decoder_stack->stack();
478
479         // We get the logic data of the first probe in the list.
480         // This works because we are currently assuming all
481         // LogicSignals have the same data/snapshot
482         for (const shared_ptr<Decoder> &dec : stack)
483                 if (dec && !dec->channels().empty() &&
484                         ((logic_signal = (*dec->channels().begin()).second)) &&
485                         ((data = logic_signal->logic_data())))
486                         break;
487
488         if (!data || data->get_snapshots().empty())
489                 return;
490
491         const shared_ptr<LogicSnapshot> snapshot =
492                 data->get_snapshots().front();
493         assert(snapshot);
494         const int64_t sample_count = (int64_t)snapshot->get_sample_count();
495         if (sample_count == 0)
496                 return;
497
498         const int64_t samples_decoded = _decoder_stack->samples_decoded();
499         if (sample_count == samples_decoded)
500                 return;
501
502         const int y = get_y();
503         const double start = max(samples_decoded /
504                 samples_per_pixel - pixels_offset, left - 1.0);
505         const double end = min(sample_count / samples_per_pixel -
506                 pixels_offset, right + 1.0);
507         const QRectF no_decode_rect(start, y - h/2 + 0.5, end - start, h);
508
509         p.setPen(QPen(Qt::NoPen));
510         p.setBrush(Qt::white);
511         p.drawRect(no_decode_rect);
512
513         p.setPen(NoDecodeColour);
514         p.setBrush(QBrush(NoDecodeColour, Qt::Dense6Pattern));
515         p.drawRect(no_decode_rect);
516 }
517
518 void DecodeTrace::create_decoder_form(int index,
519         shared_ptr<data::decode::Decoder> &dec, QWidget *parent,
520         QFormLayout *form)
521 {
522         const GSList *l;
523
524         assert(dec);
525         const srd_decoder *const decoder = dec->decoder();
526         assert(decoder);
527
528         pv::widgets::DecoderGroupBox *const group =
529                 new pv::widgets::DecoderGroupBox(
530                         QString::fromUtf8(decoder->name));
531         group->set_decoder_visible(dec->shown());
532
533         _delete_mapper.setMapping(group, index);
534         connect(group, SIGNAL(delete_decoder()), &_delete_mapper, SLOT(map()));
535
536         _show_hide_mapper.setMapping(group, index);
537         connect(group, SIGNAL(show_hide_decoder()),
538                 &_show_hide_mapper, SLOT(map()));
539
540         QFormLayout *const decoder_form = new QFormLayout;
541         group->add_layout(decoder_form);
542
543         // Add the mandatory channels
544         for(l = decoder->channels; l; l = l->next) {
545                 const struct srd_channel *const pdch =
546                         (struct srd_channel *)l->data;
547                 QComboBox *const combo = create_probe_selector(parent, dec, pdch);
548                 connect(combo, SIGNAL(currentIndexChanged(int)),
549                         this, SLOT(on_probe_selected(int)));
550                 decoder_form->addRow(tr("<b>%1</b> (%2) *")
551                         .arg(QString::fromUtf8(pdch->name))
552                         .arg(QString::fromUtf8(pdch->desc)), combo);
553
554                 const ProbeSelector s = {combo, dec, pdch};
555                 _probe_selectors.push_back(s);
556         }
557
558         // Add the optional channels
559         for(l = decoder->opt_channels; l; l = l->next) {
560                 const struct srd_channel *const pdch =
561                         (struct srd_channel *)l->data;
562                 QComboBox *const combo = create_probe_selector(parent, dec, pdch);
563                 connect(combo, SIGNAL(currentIndexChanged(int)),
564                         this, SLOT(on_probe_selected(int)));
565                 decoder_form->addRow(tr("<b>%1</b> (%2)")
566                         .arg(QString::fromUtf8(pdch->name))
567                         .arg(QString::fromUtf8(pdch->desc)), combo);
568
569                 const ProbeSelector s = {combo, dec, pdch};
570                 _probe_selectors.push_back(s);
571         }
572
573         // Add the options
574         shared_ptr<prop::binding::DecoderOptions> binding(
575                 new prop::binding::DecoderOptions(_decoder_stack, dec));
576         binding->add_properties_to_form(decoder_form, true);
577
578         _bindings.push_back(binding);
579
580         form->addRow(group);
581         _decoder_forms.push_back(group);
582 }
583
584 QComboBox* DecodeTrace::create_probe_selector(
585         QWidget *parent, const shared_ptr<data::decode::Decoder> &dec,
586         const srd_channel *const pdch)
587 {
588         assert(dec);
589
590         const vector< shared_ptr<Signal> > sigs = _session.get_signals();
591
592         assert(_decoder_stack);
593         const auto probe_iter = dec->channels().find(pdch);
594
595         QComboBox *selector = new QComboBox(parent);
596
597         selector->addItem("-", qVariantFromValue((void*)NULL));
598
599         if (probe_iter == dec->channels().end())
600                 selector->setCurrentIndex(0);
601
602         for(size_t i = 0; i < sigs.size(); i++) {
603                 const shared_ptr<view::Signal> s(sigs[i]);
604                 assert(s);
605
606                 if (dynamic_pointer_cast<LogicSignal>(s) && s->enabled())
607                 {
608                         selector->addItem(s->get_name(),
609                                 qVariantFromValue((void*)s.get()));
610                         if ((*probe_iter).second == s)
611                                 selector->setCurrentIndex(i + 1);
612                 }
613         }
614
615         return selector;
616 }
617
618 void DecodeTrace::commit_decoder_probes(shared_ptr<data::decode::Decoder> &dec)
619 {
620         assert(dec);
621
622         map<const srd_channel*, shared_ptr<LogicSignal> > probe_map;
623         const vector< shared_ptr<Signal> > sigs = _session.get_signals();
624
625         for (const ProbeSelector &s : _probe_selectors)
626         {
627                 if(s._decoder != dec)
628                         break;
629
630                 const LogicSignal *const selection =
631                         (LogicSignal*)s._combo->itemData(
632                                 s._combo->currentIndex()).value<void*>();
633
634                 for (shared_ptr<Signal> sig : sigs)
635                         if(sig.get() == selection) {
636                                 probe_map[s._pdch] =
637                                         dynamic_pointer_cast<LogicSignal>(sig);
638                                 break;
639                         }
640         }
641
642         dec->set_probes(probe_map);
643 }
644
645 void DecodeTrace::commit_probes()
646 {
647         assert(_decoder_stack);
648         for (shared_ptr<data::decode::Decoder> dec : _decoder_stack->stack())
649                 commit_decoder_probes(dec);
650
651         _decoder_stack->begin_decode();
652 }
653
654 void DecodeTrace::on_new_decode_data()
655 {
656         if (_view)
657                 _view->update_viewport();
658 }
659
660 void DecodeTrace::delete_pressed()
661 {
662         on_delete();
663 }
664
665 void DecodeTrace::on_delete()
666 {
667         _session.remove_decode_signal(this);
668 }
669
670 void DecodeTrace::on_probe_selected(int)
671 {
672         commit_probes();
673 }
674
675 void DecodeTrace::on_stack_decoder(srd_decoder *decoder)
676 {
677         assert(decoder);
678         assert(_decoder_stack);
679         _decoder_stack->push(shared_ptr<data::decode::Decoder>(
680                 new data::decode::Decoder(decoder)));
681         _decoder_stack->begin_decode();
682
683         create_popup_form();
684 }
685
686 void DecodeTrace::on_delete_decoder(int index)
687 {
688         _decoder_stack->remove(index);
689
690         // Update the popup
691         create_popup_form();    
692
693         _decoder_stack->begin_decode();
694 }
695
696 void DecodeTrace::on_show_hide_decoder(int index)
697 {
698         using pv::data::decode::Decoder;
699
700         const list< shared_ptr<Decoder> > stack(_decoder_stack->stack());
701
702         // Find the decoder in the stack
703         auto iter = stack.cbegin();
704         for(int i = 0; i < index; i++, iter++)
705                 assert(iter != stack.end());
706
707         shared_ptr<Decoder> dec = *iter;
708         assert(dec);
709
710         const bool show = !dec->shown();
711         dec->show(show);
712
713         assert(index < (int)_decoder_forms.size());
714         _decoder_forms[index]->set_decoder_visible(show);
715
716         _view->update_viewport();
717 }
718
719 } // namespace view
720 } // namespace pv