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