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