ab9514cd4e4da34e706c522ecb4244a123a38ad9
[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 <mutex>
26
27 #include <extdef.h>
28
29 #include <tuple>
30
31 #include <boost/functional/hash.hpp>
32 #include <boost/thread/locks.hpp>
33 #include <boost/thread/shared_mutex.hpp>
34
35 #include <QAction>
36 #include <QApplication>
37 #include <QComboBox>
38 #include <QFormLayout>
39 #include <QLabel>
40 #include <QMenu>
41 #include <QPushButton>
42 #include <QToolTip>
43
44 #include "decodetrace.hpp"
45
46 #include <pv/session.hpp>
47 #include <pv/strnatcmp.hpp>
48 #include <pv/data/decoderstack.hpp>
49 #include <pv/data/decode/decoder.hpp>
50 #include <pv/data/logic.hpp>
51 #include <pv/data/logicsegment.hpp>
52 #include <pv/data/decode/annotation.hpp>
53 #include <pv/view/logicsignal.hpp>
54 #include <pv/view/view.hpp>
55 #include <pv/view/viewport.hpp>
56 #include <pv/widgets/decodergroupbox.hpp>
57 #include <pv/widgets/decodermenu.hpp>
58
59 using boost::shared_lock;
60 using boost::shared_mutex;
61 using std::dynamic_pointer_cast;
62 using std::list;
63 using std::lock_guard;
64 using std::make_pair;
65 using std::max;
66 using std::make_pair;
67 using std::map;
68 using std::min;
69 using std::pair;
70 using std::shared_ptr;
71 using std::tie;
72 using std::unordered_set;
73 using std::vector;
74
75 namespace pv {
76 namespace view {
77
78 const QColor DecodeTrace::DecodeColours[4] = {
79         QColor(0xEF, 0x29, 0x29),       // Red
80         QColor(0xFC, 0xE9, 0x4F),       // Yellow
81         QColor(0x8A, 0xE2, 0x34),       // Green
82         QColor(0x72, 0x9F, 0xCF)        // Blue
83 };
84
85 const QColor DecodeTrace::ErrorBgColour = QColor(0xEF, 0x29, 0x29);
86 const QColor DecodeTrace::NoDecodeColour = QColor(0x88, 0x8A, 0x85);
87
88 const int DecodeTrace::ArrowSize = 4;
89 const double DecodeTrace::EndCapWidth = 5;
90 const int DecodeTrace::RowTitleMargin = 10;
91 const int DecodeTrace::DrawPadding = 100;
92
93 const QColor DecodeTrace::Colours[16] = {
94         QColor(0xEF, 0x29, 0x29),
95         QColor(0xF6, 0x6A, 0x32),
96         QColor(0xFC, 0xAE, 0x3E),
97         QColor(0xFB, 0xCA, 0x47),
98         QColor(0xFC, 0xE9, 0x4F),
99         QColor(0xCD, 0xF0, 0x40),
100         QColor(0x8A, 0xE2, 0x34),
101         QColor(0x4E, 0xDC, 0x44),
102         QColor(0x55, 0xD7, 0x95),
103         QColor(0x64, 0xD1, 0xD2),
104         QColor(0x72, 0x9F, 0xCF),
105         QColor(0xD4, 0x76, 0xC4),
106         QColor(0x9D, 0x79, 0xB9),
107         QColor(0xAD, 0x7F, 0xA8),
108         QColor(0xC2, 0x62, 0x9B),
109         QColor(0xD7, 0x47, 0x6F)
110 };
111
112 const QColor DecodeTrace::OutlineColours[16] = {
113         QColor(0x77, 0x14, 0x14),
114         QColor(0x7B, 0x35, 0x19),
115         QColor(0x7E, 0x57, 0x1F),
116         QColor(0x7D, 0x65, 0x23),
117         QColor(0x7E, 0x74, 0x27),
118         QColor(0x66, 0x78, 0x20),
119         QColor(0x45, 0x71, 0x1A),
120         QColor(0x27, 0x6E, 0x22),
121         QColor(0x2A, 0x6B, 0x4A),
122         QColor(0x32, 0x68, 0x69),
123         QColor(0x39, 0x4F, 0x67),
124         QColor(0x6A, 0x3B, 0x62),
125         QColor(0x4E, 0x3C, 0x5C),
126         QColor(0x56, 0x3F, 0x54),
127         QColor(0x61, 0x31, 0x4D),
128         QColor(0x6B, 0x23, 0x37)
129 };
130
131 DecodeTrace::DecodeTrace(pv::Session &session,
132         std::shared_ptr<pv::data::DecoderStack> decoder_stack, int index) :
133         Trace(QString::fromUtf8(
134                 decoder_stack->stack().front()->decoder()->name)),
135         session_(session),
136         decoder_stack_(decoder_stack),
137         row_height_(0),
138         max_visible_rows_(0),
139         delete_mapper_(this),
140         show_hide_mapper_(this)
141 {
142         assert(decoder_stack_);
143
144         // Determine shortest string we want to see displayed in full
145         QFontMetrics m(QApplication::font());
146         min_useful_label_width_ = m.width("XX"); // e.g. two hex characters
147
148         set_colour(DecodeColours[index % countof(DecodeColours)]);
149
150         connect(decoder_stack_.get(), SIGNAL(new_decode_data()),
151                 this, SLOT(on_new_decode_data()));
152         connect(&delete_mapper_, SIGNAL(mapped(int)),
153                 this, SLOT(on_delete_decoder(int)));
154         connect(&show_hide_mapper_, SIGNAL(mapped(int)),
155                 this, SLOT(on_show_hide_decoder(int)));
156 }
157
158 bool DecodeTrace::enabled() const
159 {
160         return true;
161 }
162
163 const std::shared_ptr<pv::data::DecoderStack>& DecodeTrace::decoder() const
164 {
165         return decoder_stack_;
166 }
167
168 pair<int, int> DecodeTrace::v_extents() const
169 {
170         const int row_height = (ViewItemPaintParams::text_height() * 6) / 4;
171
172         return make_pair(-row_height, row_height * max_visible_rows_);
173 }
174
175 void DecodeTrace::paint_back(QPainter &p, const ViewItemPaintParams &pp)
176 {
177         Trace::paint_back(p, pp);
178         paint_axis(p, pp, get_visual_y());
179 }
180
181 void DecodeTrace::paint_mid(QPainter &p, const ViewItemPaintParams &pp)
182 {
183         using namespace pv::data::decode;
184
185         const int text_height = ViewItemPaintParams::text_height();
186         row_height_ = (text_height * 6) / 4;
187         const int annotation_height = (text_height * 5) / 4;
188
189         assert(decoder_stack_);
190         const QString err = decoder_stack_->error_message();
191         if (!err.isEmpty()) {
192                 draw_unresolved_period(
193                         p, annotation_height, pp.left(), pp.right());
194                 draw_error(p, err, pp);
195                 return;
196         }
197
198         // Iterate through the rows
199         int y = get_visual_y();
200         pair<uint64_t, uint64_t> sample_range = get_sample_range(
201                 pp.left(), pp.right());
202
203         assert(decoder_stack_);
204         const vector<Row> rows(decoder_stack_->get_visible_rows());
205
206         visible_rows_.clear();
207         for (const Row& row : rows) {
208                 // Cache the row title widths
209                 int row_title_width;
210                 try {
211                         row_title_width = row_title_widths_.at(row);
212                 } catch (std::out_of_range) {
213                         const int w = p.boundingRect(QRectF(), 0, row.title()).width() +
214                                 RowTitleMargin;
215                         row_title_widths_[row] = w;
216                         row_title_width = w;
217                 }
218
219                 // Determine the row's color
220                 size_t base_colour = 0x13579BDF;
221                 boost::hash_combine(base_colour, this);
222                 boost::hash_combine(base_colour, row.decoder());
223                 boost::hash_combine(base_colour, row.row());
224                 base_colour >>= 16;
225
226                 vector<Annotation> annotations;
227                 decoder_stack_->get_annotation_subset(annotations, row,
228                         sample_range.first, sample_range.second);
229                 if (!annotations.empty()) {
230                         draw_annotations(annotations, p, annotation_height, pp, y,
231                                 base_colour, row_title_width);
232
233                         y += row_height_;
234
235                         visible_rows_.push_back(row);
236                 }
237         }
238
239         // Draw the hatching
240         draw_unresolved_period(p, annotation_height, pp.left(), pp.right());
241
242         // Update the maximum row count if needed
243         max_visible_rows_ = std::max(max_visible_rows_, (int)visible_rows_.size());
244 }
245
246 void DecodeTrace::paint_fore(QPainter &p, const ViewItemPaintParams &pp)
247 {
248         using namespace pv::data::decode;
249
250         assert(row_height_);
251
252         for (size_t i = 0; i < visible_rows_.size(); i++) {
253                 const int y = i * row_height_ + get_visual_y();
254
255                 p.setPen(QPen(Qt::NoPen));
256                 p.setBrush(QApplication::palette().brush(QPalette::WindowText));
257
258                 if (i != 0) {
259                         const QPointF points[] = {
260                                 QPointF(pp.left(), y - ArrowSize),
261                                 QPointF(pp.left() + ArrowSize, y),
262                                 QPointF(pp.left(), y + ArrowSize)
263                         };
264                         p.drawPolygon(points, countof(points));
265                 }
266
267                 const QRect r(pp.left() + ArrowSize * 2, y - row_height_ / 2,
268                         pp.right() - pp.left(), row_height_);
269                 const QString h(visible_rows_[i].title());
270                 const int f = Qt::AlignLeft | Qt::AlignVCenter |
271                         Qt::TextDontClip;
272
273                 // Draw the outline
274                 p.setPen(QApplication::palette().color(QPalette::Base));
275                 for (int dx = -1; dx <= 1; dx++)
276                         for (int dy = -1; dy <= 1; dy++)
277                                 if (dx != 0 && dy != 0)
278                                         p.drawText(r.translated(dx, dy), f, h);
279
280                 // Draw the text
281                 p.setPen(QApplication::palette().color(QPalette::WindowText));
282                 p.drawText(r, f, h);
283         }
284 }
285
286 void DecodeTrace::populate_popup_form(QWidget *parent, QFormLayout *form)
287 {
288         using pv::data::decode::Decoder;
289
290         assert(form);
291         assert(parent);
292         assert(decoder_stack_);
293
294         // Add the standard options
295         Trace::populate_popup_form(parent, form);
296
297         // Add the decoder options
298         bindings_.clear();
299         channel_selectors_.clear();
300         decoder_forms_.clear();
301
302         const list< shared_ptr<Decoder> >& stack = decoder_stack_->stack();
303
304         if (stack.empty()) {
305                 QLabel *const l = new QLabel(
306                         tr("<p><i>No decoders in the stack</i></p>"));
307                 l->setAlignment(Qt::AlignCenter);
308                 form->addRow(l);
309         } else {
310                 auto iter = stack.cbegin();
311                 for (int i = 0; i < (int)stack.size(); i++, iter++) {
312                         shared_ptr<Decoder> dec(*iter);
313                         create_decoder_form(i, dec, parent, form);
314                 }
315
316                 form->addRow(new QLabel(
317                         tr("<i>* Required channels</i>"), parent));
318         }
319
320         // Add stacking button
321         pv::widgets::DecoderMenu *const decoder_menu =
322                 new pv::widgets::DecoderMenu(parent);
323         connect(decoder_menu, SIGNAL(decoder_selected(srd_decoder*)),
324                 this, SLOT(on_stack_decoder(srd_decoder*)));
325
326         QPushButton *const stack_button =
327                 new QPushButton(tr("Stack Decoder"), parent);
328         stack_button->setMenu(decoder_menu);
329
330         QHBoxLayout *stack_button_box = new QHBoxLayout;
331         stack_button_box->addWidget(stack_button, 0, Qt::AlignRight);
332         form->addRow(stack_button_box);
333 }
334
335 QMenu* DecodeTrace::create_context_menu(QWidget *parent)
336 {
337         QMenu *const menu = Trace::create_context_menu(parent);
338
339         menu->addSeparator();
340
341         QAction *const del = new QAction(tr("Delete"), this);
342         del->setShortcuts(QKeySequence::Delete);
343         connect(del, SIGNAL(triggered()), this, SLOT(on_delete()));
344         menu->addAction(del);
345
346         return menu;
347 }
348
349 void DecodeTrace::draw_annotations(vector<pv::data::decode::Annotation> annotations,
350                 QPainter &p, int h, const ViewItemPaintParams &pp, int y,
351                 size_t base_colour, int row_title_width)
352 {
353         using namespace pv::data::decode;
354
355         vector<Annotation> a_block;
356         int p_end = INT_MIN;
357
358         double samples_per_pixel, pixels_offset;
359         tie(pixels_offset, samples_per_pixel) =
360                 get_pixels_offset_samples_per_pixel();
361
362         // Sort the annotations by start sample so that decoders
363         // can't confuse us by creating annotations out of order
364         stable_sort(annotations.begin(), annotations.end(),
365                 [](const Annotation &a, const Annotation &b) {
366                         return a.start_sample() < b.start_sample(); });
367
368         // Gather all annotations that form a visual "block" and draw them as such
369         for (const Annotation &a : annotations) {
370
371                 const int a_start = a.start_sample() / samples_per_pixel - pixels_offset;
372                 const int a_end = a.end_sample() / samples_per_pixel - pixels_offset;
373                 const int a_width = a_end - a_start;
374
375                 const int delta = a_end - p_end;
376
377                 bool a_is_separate = false;
378
379                 // Annotation wider than the threshold for a useful label width?
380                 if (a_width >= min_useful_label_width_) {
381                         for (const QString &ann_text : a.annotations()) {
382                                 const int w = p.boundingRect(QRectF(), 0, ann_text).width();
383                                 // Annotation wide enough to fit a label? Don't put it in a block then
384                                 if (w <= a_width) {
385                                         a_is_separate = true;
386                                         break;
387                                 }
388                         }
389                 }
390
391                 // Were the previous and this annotation more than a pixel apart?
392                 if ((abs(delta) > 1) || a_is_separate) {
393                         // Block was broken, draw annotations that form the current block
394                         if (a_block.size() == 1) {
395                                 draw_annotation(a_block.front(), p, h, pp, y, base_colour,
396                                         row_title_width);
397                         }
398                         else
399                                 draw_annotation_block(a_block, p, h, y, base_colour);
400
401                         a_block.clear();
402                 }
403
404                 if (a_is_separate) {
405                         draw_annotation(a, p, h, pp, y, base_colour, row_title_width);
406                         // Next annotation must start a new block. delta will be > 1
407                         // because we set p_end to INT_MIN but that's okay since
408                         // a_block will be empty, so nothing will be drawn
409                         p_end = INT_MIN;
410                 } else {
411                         a_block.push_back(a);
412                         p_end = a_end;
413                 }
414         }
415
416         if (a_block.size() == 1)
417                 draw_annotation(a_block.front(), p, h, pp, y, base_colour,
418                         row_title_width);
419         else
420                 draw_annotation_block(a_block, p, h, y, base_colour);
421 }
422
423 void DecodeTrace::draw_annotation(const pv::data::decode::Annotation &a,
424         QPainter &p, int h, const ViewItemPaintParams &pp, int y,
425         size_t base_colour, int row_title_width) const
426 {
427         double samples_per_pixel, pixels_offset;
428         tie(pixels_offset, samples_per_pixel) =
429                 get_pixels_offset_samples_per_pixel();
430
431         const double start = a.start_sample() / samples_per_pixel -
432                 pixels_offset;
433         const double end = a.end_sample() / samples_per_pixel -
434                 pixels_offset;
435
436         const size_t colour = (base_colour + a.format()) % countof(Colours);
437         p.setPen(OutlineColours[colour]);
438         p.setBrush(Colours[colour]);
439
440         if (start > pp.right() + DrawPadding || end < pp.left() - DrawPadding)
441                 return;
442
443         if (a.start_sample() == a.end_sample())
444                 draw_instant(a, p, h, start, y);
445         else
446                 draw_range(a, p, h, start, end, y, pp,
447                         row_title_width);
448 }
449
450 void DecodeTrace::draw_annotation_block(
451         vector<pv::data::decode::Annotation> annotations, QPainter &p, int h,
452         int y, size_t base_colour) const
453 {
454         using namespace pv::data::decode;
455
456         if (annotations.empty())
457                 return;
458
459         double samples_per_pixel, pixels_offset;
460         tie(pixels_offset, samples_per_pixel) =
461                 get_pixels_offset_samples_per_pixel();
462
463         const double start = annotations.front().start_sample() /
464                 samples_per_pixel - pixels_offset;
465         const double end = annotations.back().end_sample() /
466                 samples_per_pixel - pixels_offset;
467
468         const double top = y + .5 - h / 2;
469         const double bottom = y + .5 + h / 2;
470
471         const size_t colour = (base_colour + annotations.front().format()) %
472                 countof(Colours);
473
474         // Check if all annotations are of the same type (i.e. we can use one color)
475         // or if we should use a neutral color (i.e. gray)
476         const int format = annotations.front().format();
477         const bool single_format = std::all_of(
478                 annotations.begin(), annotations.end(),
479                 [&](const Annotation &a) { return a.format() == format; });
480
481         p.setPen((single_format ? OutlineColours[colour] : Qt::gray));
482         p.setBrush(QBrush((single_format ? Colours[colour] : Qt::gray),
483                 Qt::Dense4Pattern));
484         p.drawRoundedRect(
485                 QRectF(start, top, end - start, bottom - top), h/4, h/4);
486 }
487
488 void DecodeTrace::draw_instant(const pv::data::decode::Annotation &a, QPainter &p,
489         int h, double x, int y) const
490 {
491         const QString text = a.annotations().empty() ?
492                 QString() : a.annotations().back();
493         const double w = min((double)p.boundingRect(QRectF(), 0, text).width(),
494                 0.0) + h;
495         const QRectF rect(x - w / 2, y - h / 2, w, h);
496
497         p.drawRoundedRect(rect, h / 2, h / 2);
498
499         p.setPen(Qt::black);
500         p.drawText(rect, Qt::AlignCenter | Qt::AlignVCenter, text);
501 }
502
503 void DecodeTrace::draw_range(const pv::data::decode::Annotation &a, QPainter &p,
504         int h, double start, double end, int y, const ViewItemPaintParams &pp,
505         int row_title_width) const
506 {
507         const double top = y + .5 - h / 2;
508         const double bottom = y + .5 + h / 2;
509         const vector<QString> annotations = a.annotations();
510
511         // If the two ends are within 1 pixel, draw a vertical line
512         if (start + 1.0 > end) {
513                 p.drawLine(QPointF(start, top), QPointF(start, bottom));
514                 return;
515         }
516
517         const double cap_width = min((end - start) / 4, EndCapWidth);
518
519         QPointF pts[] = {
520                 QPointF(start, y + .5f),
521                 QPointF(start + cap_width, top),
522                 QPointF(end - cap_width, top),
523                 QPointF(end, y + .5f),
524                 QPointF(end - cap_width, bottom),
525                 QPointF(start + cap_width, bottom)
526         };
527
528         p.drawConvexPolygon(pts, countof(pts));
529
530         if (annotations.empty())
531                 return;
532
533         const int ann_start = start + cap_width;
534         const int ann_end = end - cap_width;
535
536         const int real_start = std::max(ann_start, pp.left() + row_title_width);
537         const int real_end = std::min(ann_end, pp.right());
538         const int real_width = real_end - real_start;
539
540         QRectF rect(real_start, y - h / 2, real_width, h);
541         if (rect.width() <= 4)
542                 return;
543
544         p.setPen(Qt::black);
545
546         // Try to find an annotation that will fit
547         QString best_annotation;
548         int best_width = 0;
549
550         for (const QString &a : annotations) {
551                 const int w = p.boundingRect(QRectF(), 0, a).width();
552                 if (w <= rect.width() && w > best_width)
553                         best_annotation = a, best_width = w;
554         }
555
556         if (best_annotation.isEmpty())
557                 best_annotation = annotations.back();
558
559         // If not ellide the last in the list
560         p.drawText(rect, Qt::AlignCenter, p.fontMetrics().elidedText(
561                 best_annotation, Qt::ElideRight, rect.width()));
562 }
563
564 void DecodeTrace::draw_error(QPainter &p, const QString &message,
565         const ViewItemPaintParams &pp)
566 {
567         const int y = get_visual_y();
568
569         p.setPen(ErrorBgColour.darker());
570         p.setBrush(ErrorBgColour);
571
572         const QRectF bounding_rect =
573                 QRectF(pp.width(), INT_MIN / 2 + y, pp.width(), INT_MAX);
574         const QRectF text_rect = p.boundingRect(bounding_rect,
575                 Qt::AlignCenter, message);
576         const float r = text_rect.height() / 4;
577
578         p.drawRoundedRect(text_rect.adjusted(-r, -r, r, r), r, r,
579                 Qt::AbsoluteSize);
580
581         p.setPen(Qt::black);
582         p.drawText(text_rect, message);
583 }
584
585 void DecodeTrace::draw_unresolved_period(QPainter &p, int h, int left,
586         int right) const
587 {
588         using namespace pv::data;
589         using pv::data::decode::Decoder;
590
591         double samples_per_pixel, pixels_offset;
592
593         assert(decoder_stack_); 
594
595         shared_ptr<Logic> data;
596         shared_ptr<LogicSignal> logic_signal;
597
598         const list< shared_ptr<Decoder> > &stack = decoder_stack_->stack();
599
600         // We get the logic data of the first channel in the list.
601         // This works because we are currently assuming all
602         // LogicSignals have the same data/segment
603         for (const shared_ptr<Decoder> &dec : stack)
604                 if (dec && !dec->channels().empty() &&
605                         ((logic_signal = (*dec->channels().begin()).second)) &&
606                         ((data = logic_signal->logic_data())))
607                         break;
608
609         if (!data || data->logic_segments().empty())
610                 return;
611
612         const shared_ptr<LogicSegment> segment =
613                 data->logic_segments().front();
614         assert(segment);
615         const int64_t sample_count = (int64_t)segment->get_sample_count();
616         if (sample_count == 0)
617                 return;
618
619         const int64_t samples_decoded = decoder_stack_->samples_decoded();
620         if (sample_count == samples_decoded)
621                 return;
622
623         const int y = get_visual_y();
624
625         tie(pixels_offset, samples_per_pixel) =
626                 get_pixels_offset_samples_per_pixel();
627
628         const double start = max(samples_decoded /
629                 samples_per_pixel - pixels_offset, left - 1.0);
630         const double end = min(sample_count / samples_per_pixel -
631                 pixels_offset, right + 1.0);
632         const QRectF no_decode_rect(start, y - h/2 + 0.5, end - start, h);
633
634         p.setPen(QPen(Qt::NoPen));
635         p.setBrush(Qt::white);
636         p.drawRect(no_decode_rect);
637
638         p.setPen(NoDecodeColour);
639         p.setBrush(QBrush(NoDecodeColour, Qt::Dense6Pattern));
640         p.drawRect(no_decode_rect);
641 }
642
643 pair<double, double> DecodeTrace::get_pixels_offset_samples_per_pixel() const
644 {
645         assert(owner_);
646         assert(decoder_stack_);
647
648         const View *view = owner_->view();
649         assert(view);
650
651         const double scale = view->scale();
652         assert(scale > 0);
653
654         const double pixels_offset =
655                 ((view->offset() - decoder_stack_->start_time()) / scale).convert_to<double>();
656
657         double samplerate = decoder_stack_->samplerate();
658
659         // Show sample rate as 1Hz when it is unknown
660         if (samplerate == 0.0)
661                 samplerate = 1.0;
662
663         return make_pair(pixels_offset, samplerate * scale);
664 }
665
666 pair<uint64_t, uint64_t> DecodeTrace::get_sample_range(
667         int x_start, int x_end) const
668 {
669         double samples_per_pixel, pixels_offset;
670         tie(pixels_offset, samples_per_pixel) =
671                 get_pixels_offset_samples_per_pixel();
672
673         const uint64_t start = (uint64_t)max(
674                 (x_start + pixels_offset) * samples_per_pixel, 0.0);
675         const uint64_t end = (uint64_t)max(
676                 (x_end + pixels_offset) * samples_per_pixel, 0.0);
677
678         return make_pair(start, end);
679 }
680
681 int DecodeTrace::get_row_at_point(const QPoint &point)
682 {
683         if (!row_height_)
684                 return -1;
685
686         const int y = (point.y() - get_visual_y() + row_height_ / 2);
687
688         /* Integer divison of (x-1)/x would yield 0, so we check for this. */
689         if (y < 0)
690                 return -1;
691
692         const int row = y / row_height_;
693
694         if (row >= (int)visible_rows_.size())
695                 return -1;
696
697         return row;
698 }
699
700 const QString DecodeTrace::get_annotation_at_point(const QPoint &point)
701 {
702         using namespace pv::data::decode;
703
704         if (!enabled())
705                 return QString();
706
707         const pair<uint64_t, uint64_t> sample_range =
708                 get_sample_range(point.x(), point.x() + 1);
709         const int row = get_row_at_point(point);
710         if (row < 0)
711                 return QString();
712
713         vector<pv::data::decode::Annotation> annotations;
714
715         assert(decoder_stack_);
716         decoder_stack_->get_annotation_subset(annotations, visible_rows_[row],
717                 sample_range.first, sample_range.second);
718
719         return (annotations.empty()) ?
720                 QString() : annotations[0].annotations().front();
721 }
722
723 void DecodeTrace::hover_point_changed()
724 {
725         assert(owner_);
726
727         const View *const view = owner_->view();
728         assert(view);
729
730         QPoint hp = view->hover_point();
731         QString ann = get_annotation_at_point(hp);
732
733         assert(view);
734
735         if (!row_height_ || ann.isEmpty()) {
736                 QToolTip::hideText();
737                 return;
738         }
739
740         const int hover_row = get_row_at_point(hp);
741
742         QFontMetrics m(QToolTip::font());
743         const QRect text_size = m.boundingRect(QRect(), 0, ann);
744
745         // This is OS-specific and unfortunately we can't query it, so
746         // use an approximation to at least try to minimize the error.
747         const int padding = 8;
748
749         // Make sure the tool tip doesn't overlap with the mouse cursor.
750         // If it did, the tool tip would constantly hide and re-appear.
751         // We also push it up by one row so that it appears above the
752         // decode trace, not below.
753         hp.setX(hp.x() - (text_size.width() / 2) - padding);
754
755         hp.setY(get_visual_y() - (row_height_ / 2) +
756                 (hover_row * row_height_) -
757                 row_height_ - text_size.height() - padding);
758
759         QToolTip::showText(view->viewport()->mapToGlobal(hp), ann);
760 }
761
762 void DecodeTrace::create_decoder_form(int index,
763         shared_ptr<data::decode::Decoder> &dec, QWidget *parent,
764         QFormLayout *form)
765 {
766         const GSList *l;
767
768         assert(dec);
769         const srd_decoder *const decoder = dec->decoder();
770         assert(decoder);
771
772         const bool decoder_deletable = index > 0;
773
774         pv::widgets::DecoderGroupBox *const group =
775                 new pv::widgets::DecoderGroupBox(
776                         QString::fromUtf8(decoder->name), nullptr, decoder_deletable);
777         group->set_decoder_visible(dec->shown());
778
779         if (decoder_deletable) {
780                 delete_mapper_.setMapping(group, index);
781                 connect(group, SIGNAL(delete_decoder()), &delete_mapper_, SLOT(map()));
782         }
783
784         show_hide_mapper_.setMapping(group, index);
785         connect(group, SIGNAL(show_hide_decoder()),
786                 &show_hide_mapper_, SLOT(map()));
787
788         QFormLayout *const decoder_form = new QFormLayout;
789         group->add_layout(decoder_form);
790
791         // Add the mandatory channels
792         for (l = decoder->channels; l; l = l->next) {
793                 const struct srd_channel *const pdch =
794                         (struct srd_channel *)l->data;
795                 QComboBox *const combo = create_channel_selector(parent, dec, pdch);
796                 connect(combo, SIGNAL(currentIndexChanged(int)),
797                         this, SLOT(on_channel_selected(int)));
798                 decoder_form->addRow(tr("<b>%1</b> (%2) *")
799                         .arg(QString::fromUtf8(pdch->name),
800                              QString::fromUtf8(pdch->desc)), combo);
801
802                 const ChannelSelector s = {combo, dec, pdch};
803                 channel_selectors_.push_back(s);
804         }
805
806         // Add the optional channels
807         for (l = decoder->opt_channels; l; l = l->next) {
808                 const struct srd_channel *const pdch =
809                         (struct srd_channel *)l->data;
810                 QComboBox *const combo = create_channel_selector(parent, dec, pdch);
811                 connect(combo, SIGNAL(currentIndexChanged(int)),
812                         this, SLOT(on_channel_selected(int)));
813                 decoder_form->addRow(tr("<b>%1</b> (%2)")
814                         .arg(QString::fromUtf8(pdch->name),
815                              QString::fromUtf8(pdch->desc)), combo);
816
817                 const ChannelSelector s = {combo, dec, pdch};
818                 channel_selectors_.push_back(s);
819         }
820
821         // Add the options
822         shared_ptr<binding::Decoder> binding(
823                 new binding::Decoder(decoder_stack_, dec));
824         binding->add_properties_to_form(decoder_form, true);
825
826         bindings_.push_back(binding);
827
828         form->addRow(group);
829         decoder_forms_.push_back(group);
830 }
831
832 QComboBox* DecodeTrace::create_channel_selector(
833         QWidget *parent, const shared_ptr<data::decode::Decoder> &dec,
834         const srd_channel *const pdch)
835 {
836         assert(dec);
837
838         const auto sigs(session_.signals());
839
840         vector< shared_ptr<Signal> > sig_list(sigs.begin(), sigs.end());
841         std::sort(sig_list.begin(), sig_list.end(),
842                 [](const shared_ptr<Signal> &a, const shared_ptr<Signal> b) {
843                         return strnatcasecmp(a->name().toStdString(),
844                                 b->name().toStdString()) < 0; });
845
846         assert(decoder_stack_);
847         const auto channel_iter = dec->channels().find(pdch);
848
849         QComboBox *selector = new QComboBox(parent);
850
851         selector->addItem("-", qVariantFromValue((void*)nullptr));
852
853         if (channel_iter == dec->channels().end())
854                 selector->setCurrentIndex(0);
855
856         for (const shared_ptr<view::Signal> &s : sig_list) {
857                 assert(s);
858                 if (dynamic_pointer_cast<LogicSignal>(s) && s->enabled()) {
859                         selector->addItem(s->name(),
860                                 qVariantFromValue((void*)s.get()));
861
862                         if (channel_iter != dec->channels().end() &&
863                                 (*channel_iter).second == s)
864                                 selector->setCurrentIndex(
865                                         selector->count() - 1);
866                 }
867         }
868
869         return selector;
870 }
871
872 void DecodeTrace::commit_decoder_channels(shared_ptr<data::decode::Decoder> &dec)
873 {
874         assert(dec);
875
876         map<const srd_channel*, shared_ptr<LogicSignal> > channel_map;
877
878         const unordered_set< shared_ptr<Signal> > sigs(session_.signals());
879
880         for (const ChannelSelector &s : channel_selectors_) {
881                 if (s.decoder_ != dec)
882                         break;
883
884                 const LogicSignal *const selection =
885                         (LogicSignal*)s.combo_->itemData(
886                                 s.combo_->currentIndex()).value<void*>();
887
888                 for (shared_ptr<Signal> sig : sigs)
889                         if (sig.get() == selection) {
890                                 channel_map[s.pdch_] =
891                                         dynamic_pointer_cast<LogicSignal>(sig);
892                                 break;
893                         }
894         }
895
896         dec->set_channels(channel_map);
897 }
898
899 void DecodeTrace::commit_channels()
900 {
901         assert(decoder_stack_);
902         for (shared_ptr<data::decode::Decoder> dec : decoder_stack_->stack())
903                 commit_decoder_channels(dec);
904
905         decoder_stack_->begin_decode();
906 }
907
908 void DecodeTrace::on_new_decode_data()
909 {
910         if (owner_)
911                 owner_->row_item_appearance_changed(false, true);
912 }
913
914 void DecodeTrace::delete_pressed()
915 {
916         on_delete();
917 }
918
919 void DecodeTrace::on_delete()
920 {
921         session_.remove_decode_signal(this);
922 }
923
924 void DecodeTrace::on_channel_selected(int)
925 {
926         commit_channels();
927 }
928
929 void DecodeTrace::on_stack_decoder(srd_decoder *decoder)
930 {
931         assert(decoder);
932         assert(decoder_stack_);
933         decoder_stack_->push(shared_ptr<data::decode::Decoder>(
934                 new data::decode::Decoder(decoder)));
935         decoder_stack_->begin_decode();
936
937         create_popup_form();
938 }
939
940 void DecodeTrace::on_delete_decoder(int index)
941 {
942         decoder_stack_->remove(index);
943
944         // Update the popup
945         create_popup_form();    
946
947         decoder_stack_->begin_decode();
948 }
949
950 void DecodeTrace::on_show_hide_decoder(int index)
951 {
952         using pv::data::decode::Decoder;
953
954         const list< shared_ptr<Decoder> > stack(decoder_stack_->stack());
955
956         // Find the decoder in the stack
957         auto iter = stack.cbegin();
958         for (int i = 0; i < index; i++, iter++)
959                 assert(iter != stack.end());
960
961         shared_ptr<Decoder> dec = *iter;
962         assert(dec);
963
964         const bool show = !dec->shown();
965         dec->show(show);
966
967         assert(index < (int)decoder_forms_.size());
968         decoder_forms_[index]->set_decoder_visible(show);
969
970         if (owner_)
971                 owner_->row_item_appearance_changed(false, true);
972 }
973
974 } // namespace view
975 } // namespace pv