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