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