#include "viewport.hpp"
#include <pv/globalsettings.hpp>
+#include <pv/session.hpp>
+#include <pv/strnatcmp.hpp>
+#include <pv/data/decodesignal.hpp>
#include <pv/data/decode/annotation.hpp>
#include <pv/data/decode/decoder.hpp>
-#include <pv/data/decoderstack.hpp>
#include <pv/data/logic.hpp>
#include <pv/data/logicsegment.hpp>
-#include <pv/session.hpp>
-#include <pv/strnatcmp.hpp>
#include <pv/widgets/decodergroupbox.hpp>
#include <pv/widgets/decodermenu.hpp>
using std::all_of;
-using std::list;
using std::make_pair;
using std::max;
-using std::make_pair;
-using std::map;
using std::min;
using std::out_of_range;
using std::pair;
using std::shared_ptr;
-using std::make_shared;
using std::tie;
-using std::unordered_set;
using std::vector;
+using pv::data::decode::Annotation;
+using pv::data::decode::Row;
+using pv::data::DecodeChannel;
+using pv::data::DecodeSignal;
+
namespace pv {
namespace views {
namespace trace {
-const QColor DecodeTrace::DecodeColours[4] = {
- QColor(0xEF, 0x29, 0x29), // Red
- QColor(0xFC, 0xE9, 0x4F), // Yellow
- QColor(0x8A, 0xE2, 0x34), // Green
- QColor(0x72, 0x9F, 0xCF) // Blue
-};
-const QColor DecodeTrace::ErrorBgColour = QColor(0xEF, 0x29, 0x29);
-const QColor DecodeTrace::NoDecodeColour = QColor(0x88, 0x8A, 0x85);
+#define DECODETRACE_COLOR_SATURATION (180) /* 0-255 */
+#define DECODETRACE_COLOR_VALUE (170) /* 0-255 */
+
+const QColor DecodeTrace::ErrorBgColor = QColor(0xEF, 0x29, 0x29);
+const QColor DecodeTrace::NoDecodeColor = QColor(0x88, 0x8A, 0x85);
const int DecodeTrace::ArrowSize = 4;
const double DecodeTrace::EndCapWidth = 5;
const int DecodeTrace::RowTitleMargin = 10;
const int DecodeTrace::DrawPadding = 100;
-const QColor DecodeTrace::Colours[16] = {
- QColor(0xEF, 0x29, 0x29),
- QColor(0xF6, 0x6A, 0x32),
- QColor(0xFC, 0xAE, 0x3E),
- QColor(0xFB, 0xCA, 0x47),
- QColor(0xFC, 0xE9, 0x4F),
- QColor(0xCD, 0xF0, 0x40),
- QColor(0x8A, 0xE2, 0x34),
- QColor(0x4E, 0xDC, 0x44),
- QColor(0x55, 0xD7, 0x95),
- QColor(0x64, 0xD1, 0xD2),
- QColor(0x72, 0x9F, 0xCF),
- QColor(0xD4, 0x76, 0xC4),
- QColor(0x9D, 0x79, 0xB9),
- QColor(0xAD, 0x7F, 0xA8),
- QColor(0xC2, 0x62, 0x9B),
- QColor(0xD7, 0x47, 0x6F)
-};
-
-const QColor DecodeTrace::OutlineColours[16] = {
- QColor(0x77, 0x14, 0x14),
- QColor(0x7B, 0x35, 0x19),
- QColor(0x7E, 0x57, 0x1F),
- QColor(0x7D, 0x65, 0x23),
- QColor(0x7E, 0x74, 0x27),
- QColor(0x66, 0x78, 0x20),
- QColor(0x45, 0x71, 0x1A),
- QColor(0x27, 0x6E, 0x22),
- QColor(0x2A, 0x6B, 0x4A),
- QColor(0x32, 0x68, 0x69),
- QColor(0x39, 0x4F, 0x67),
- QColor(0x6A, 0x3B, 0x62),
- QColor(0x4E, 0x3C, 0x5C),
- QColor(0x56, 0x3F, 0x54),
- QColor(0x61, 0x31, 0x4D),
- QColor(0x6B, 0x23, 0x37)
-};
+const int DecodeTrace::MaxTraceUpdateRate = 1; // No more than 1 Hz
DecodeTrace::DecodeTrace(pv::Session &session,
shared_ptr<data::SignalBase> signalbase, int index) :
delete_mapper_(this),
show_hide_mapper_(this)
{
- shared_ptr<pv::data::DecoderStack> decoder_stack = base_->decoder_stack();
+ decode_signal_ = dynamic_pointer_cast<data::DecodeSignal>(base_);
// Determine shortest string we want to see displayed in full
QFontMetrics m(QApplication::font());
min_useful_label_width_ = m.width("XX"); // e.g. two hex characters
- base_->set_name(QString::fromUtf8(decoder_stack->stack().front()->decoder()->name));
- base_->set_colour(DecodeColours[index % countof(DecodeColours)]);
+ // For the base color, we want to start at a very different color for
+ // every decoder stack, so multiply the index with a number that is
+ // rather close to 180 degrees of the color circle but not a dividend of 360
+ // Note: The offset equals the color of the first annotation
+ QColor color;
+ const int h = (120 + 160 * index) % 360;
+ const int s = DECODETRACE_COLOR_SATURATION;
+ const int v = DECODETRACE_COLOR_VALUE;
+ color.setHsv(h, s, v);
+ base_->set_color(color);
+
+ connect(decode_signal_.get(), SIGNAL(new_annotations()),
+ this, SLOT(on_new_annotations()));
+ connect(decode_signal_.get(), SIGNAL(decode_reset()),
+ this, SLOT(on_decode_reset()));
+ connect(decode_signal_.get(), SIGNAL(decode_finished()),
+ this, SLOT(on_decode_finished()));
+ connect(decode_signal_.get(), SIGNAL(channels_updated()),
+ this, SLOT(on_channels_updated()));
- connect(decoder_stack.get(), SIGNAL(new_decode_data()),
- this, SLOT(on_new_decode_data()));
connect(&delete_mapper_, SIGNAL(mapped(int)),
this, SLOT(on_delete_decoder(int)));
connect(&show_hide_mapper_, SIGNAL(mapped(int)),
this, SLOT(on_show_hide_decoder(int)));
+
+ connect(&delayed_trace_updater_, SIGNAL(timeout()),
+ this, SLOT(on_delayed_trace_update()));
+ delayed_trace_updater_.setSingleShot(true);
+ delayed_trace_updater_.setInterval(1000 / MaxTraceUpdateRate);
}
bool DecodeTrace::enabled() const
void DecodeTrace::paint_mid(QPainter &p, ViewItemPaintParams &pp)
{
- using namespace pv::data::decode;
-
- shared_ptr<pv::data::DecoderStack> decoder_stack = base_->decoder_stack();
-
const int text_height = ViewItemPaintParams::text_height();
row_height_ = (text_height * 6) / 4;
const int annotation_height = (text_height * 5) / 4;
- assert(decoder_stack);
- const QString err = decoder_stack->error_message();
+ const QString err = decode_signal_->error_message();
if (!err.isEmpty()) {
draw_unresolved_period(
p, annotation_height, pp.left(), pp.right());
pair<uint64_t, uint64_t> sample_range = get_sample_range(
pp.left(), pp.right());
- const vector<Row> rows(decoder_stack->get_visible_rows());
+ const vector<Row> rows = decode_signal_->visible_rows();
visible_rows_.clear();
for (const Row& row : rows) {
int row_title_width;
try {
row_title_width = row_title_widths_.at(row);
- } catch (out_of_range) {
+ } catch (out_of_range&) {
const int w = p.boundingRect(QRectF(), 0, row.title()).width() +
RowTitleMargin;
row_title_widths_[row] = w;
row_title_width = w;
}
- // Determine the row's color
- size_t base_colour = 0x13579BDF;
- boost::hash_combine(base_colour, this);
- boost::hash_combine(base_colour, row.decoder());
- boost::hash_combine(base_colour, row.row());
- base_colour >>= 16;
-
vector<Annotation> annotations;
- decoder_stack->get_annotation_subset(annotations, row,
- sample_range.first, sample_range.second);
+ decode_signal_->get_annotation_subset(annotations, row,
+ current_segment_, sample_range.first, sample_range.second);
if (!annotations.empty()) {
draw_annotations(annotations, p, annotation_height, pp, y,
- base_colour, row_title_width);
+ get_row_color(visible_rows_.size()), row_title_width);
y += row_height_;
// Draw the hatching
draw_unresolved_period(p, annotation_height, pp.left(), pp.right());
- if ((int)visible_rows_.size() > max_visible_rows_)
- owner_->extents_changed(false, true);
+ if ((int)visible_rows_.size() > max_visible_rows_) {
+ max_visible_rows_ = (int)visible_rows_.size();
- // Update the maximum row count if needed
- max_visible_rows_ = max(max_visible_rows_, (int)visible_rows_.size());
+ // Call order is important, otherwise the lazy event handler won't work
+ owner_->extents_changed(false, true);
+ owner_->row_item_appearance_changed(false, true);
+ }
}
void DecodeTrace::paint_fore(QPainter &p, ViewItemPaintParams &pp)
{
- using namespace pv::data::decode;
-
assert(row_height_);
for (size_t i = 0; i < visible_rows_.size(); i++) {
{
using pv::data::decode::Decoder;
- shared_ptr<pv::data::DecoderStack> decoder_stack = base_->decoder_stack();
-
assert(form);
- assert(parent);
- assert(decoder_stack);
// Add the standard options
Trace::populate_popup_form(parent, form);
// Add the decoder options
bindings_.clear();
- channel_selectors_.clear();
+ channel_id_map_.clear();
+ init_state_map_.clear();
decoder_forms_.clear();
- const list< shared_ptr<Decoder> >& stack = decoder_stack->stack();
+ const vector< shared_ptr<Decoder> > &stack = decode_signal_->decoder_stack();
if (stack.empty()) {
QLabel *const l = new QLabel(
void DecodeTrace::draw_annotations(vector<pv::data::decode::Annotation> annotations,
QPainter &p, int h, const ViewItemPaintParams &pp, int y,
- size_t base_colour, int row_title_width)
+ QColor row_color, int row_title_width)
{
using namespace pv::data::decode;
if ((abs(delta) > 1) || a_is_separate) {
// Block was broken, draw annotations that form the current block
if (a_block.size() == 1) {
- draw_annotation(a_block.front(), p, h, pp, y, base_colour,
+ draw_annotation(a_block.front(), p, h, pp, y, row_color,
row_title_width);
}
else
- draw_annotation_block(a_block, p, h, y, base_colour);
+ draw_annotation_block(a_block, p, h, y, row_color);
a_block.clear();
}
if (a_is_separate) {
- draw_annotation(a, p, h, pp, y, base_colour, row_title_width);
+ draw_annotation(a, p, h, pp, y, row_color, row_title_width);
// Next annotation must start a new block. delta will be > 1
// because we set p_end to INT_MIN but that's okay since
// a_block will be empty, so nothing will be drawn
}
if (a_block.size() == 1)
- draw_annotation(a_block.front(), p, h, pp, y, base_colour,
- row_title_width);
+ draw_annotation(a_block.front(), p, h, pp, y, row_color, row_title_width);
else
- draw_annotation_block(a_block, p, h, y, base_colour);
+ draw_annotation_block(a_block, p, h, y, row_color);
}
void DecodeTrace::draw_annotation(const pv::data::decode::Annotation &a,
QPainter &p, int h, const ViewItemPaintParams &pp, int y,
- size_t base_colour, int row_title_width) const
+ QColor row_color, int row_title_width) const
{
double samples_per_pixel, pixels_offset;
tie(pixels_offset, samples_per_pixel) =
pixels_offset;
const double end = a.end_sample() / samples_per_pixel - pixels_offset;
- const size_t colour = (base_colour + a.format()) % countof(Colours);
- p.setPen(OutlineColours[colour]);
- p.setBrush(Colours[colour]);
+ QColor color = get_annotation_color(row_color, a.ann_class());
+ p.setPen(color.darker());
+ p.setBrush(color);
if (start > pp.right() + DrawPadding || end < pp.left() - DrawPadding)
return;
void DecodeTrace::draw_annotation_block(
vector<pv::data::decode::Annotation> annotations, QPainter &p, int h,
- int y, size_t base_colour) const
+ int y, QColor row_color) const
{
using namespace pv::data::decode;
const double top = y + .5 - h / 2;
const double bottom = y + .5 + h / 2;
- const size_t colour = (base_colour + annotations.front().format()) %
- countof(Colours);
+ QColor color = get_annotation_color(row_color, annotations.front().ann_class());
// Check if all annotations are of the same type (i.e. we can use one color)
// or if we should use a neutral color (i.e. gray)
- const int format = annotations.front().format();
- const bool single_format = all_of(
+ const Annotation::Class ann_class = annotations.front().ann_class();
+ const bool single_class = all_of(
annotations.begin(), annotations.end(),
- [&](const Annotation &a) { return a.format() == format; });
+ [&](const Annotation &a) { return a.ann_class() == ann_class; });
const QRectF rect(start, top, end - start, bottom - top);
const int r = h / 4;
p.setBrush(Qt::white);
p.drawRoundedRect(rect, r, r);
- p.setPen((single_format ? OutlineColours[colour] : Qt::gray));
- p.setBrush(QBrush((single_format ? Colours[colour] : Qt::gray),
- Qt::Dense4Pattern));
+ p.setPen((single_class ? color.darker() : Qt::gray));
+ p.setBrush(QBrush((single_class ? color : Qt::gray), Qt::Dense4Pattern));
p.drawRoundedRect(rect, r, r);
}
{
const int y = get_visual_y();
- p.setPen(ErrorBgColour.darker());
- p.setBrush(ErrorBgColour);
+ p.setPen(ErrorBgColor.darker());
+ p.setBrush(ErrorBgColor);
const QRectF bounding_rect =
QRectF(pp.left(), INT_MIN / 2 + y, pp.right(), INT_MAX);
p.drawText(text_rect, message);
}
-void DecodeTrace::draw_unresolved_period(QPainter &p, int h, int left,
- int right) const
+void DecodeTrace::draw_unresolved_period(QPainter &p, int h, int left, int right) const
{
using namespace pv::data;
using pv::data::decode::Decoder;
double samples_per_pixel, pixels_offset;
- shared_ptr<pv::data::DecoderStack> decoder_stack = base_->decoder_stack();
-
- assert(decoder_stack);
-
- shared_ptr<Logic> data;
- shared_ptr<data::SignalBase> signalbase;
-
- const list< shared_ptr<Decoder> > &stack = decoder_stack->stack();
-
- // We get the logic data of the first channel in the list.
- // This works because we are currently assuming all
- // LogicSignals have the same data/segment
- for (const shared_ptr<Decoder> &dec : stack)
- if (dec && !dec->channels().empty() &&
- ((signalbase = (*dec->channels().begin()).second)) &&
- ((data = signalbase->logic_data())))
- break;
-
- if (!data || data->logic_segments().empty())
- return;
-
- const shared_ptr<LogicSegment> segment = data->logic_segments().front();
- assert(segment);
- const int64_t sample_count = (int64_t)segment->get_sample_count();
+ const int64_t sample_count = decode_signal_->get_working_sample_count(current_segment_);
if (sample_count == 0)
return;
- const int64_t samples_decoded = decoder_stack->samples_decoded();
+ const int64_t samples_decoded = decode_signal_->get_decoded_sample_count(current_segment_);
if (sample_count == samples_decoded)
return;
const int y = get_visual_y();
- tie(pixels_offset, samples_per_pixel) =
- get_pixels_offset_samples_per_pixel();
+ tie(pixels_offset, samples_per_pixel) = get_pixels_offset_samples_per_pixel();
const double start = max(samples_decoded /
samples_per_pixel - pixels_offset, left - 1.0);
const double end = min(sample_count / samples_per_pixel -
pixels_offset, right + 1.0);
- const QRectF no_decode_rect(start, y - (h / 2) + 0.5, end - start, h);
+ const QRectF no_decode_rect(start, y - (h / 2) - 0.5, end - start, h);
p.setPen(QPen(Qt::NoPen));
p.setBrush(Qt::white);
p.drawRect(no_decode_rect);
- p.setPen(NoDecodeColour);
- p.setBrush(QBrush(NoDecodeColour, Qt::Dense6Pattern));
+ p.setPen(NoDecodeColor);
+ p.setBrush(QBrush(NoDecodeColor, Qt::Dense6Pattern));
p.drawRect(no_decode_rect);
}
pair<double, double> DecodeTrace::get_pixels_offset_samples_per_pixel() const
{
- shared_ptr<pv::data::DecoderStack> decoder_stack = base_->decoder_stack();
-
assert(owner_);
- assert(decoder_stack);
const View *view = owner_->view();
assert(view);
assert(scale > 0);
const double pixels_offset =
- ((view->offset() - decoder_stack->start_time()) / scale).convert_to<double>();
+ ((view->offset() - decode_signal_->start_time()) / scale).convert_to<double>();
- double samplerate = decoder_stack->samplerate();
+ double samplerate = decode_signal_->samplerate();
// Show sample rate as 1Hz when it is unknown
if (samplerate == 0.0)
return make_pair(start, end);
}
+QColor DecodeTrace::get_row_color(int row_index) const
+{
+ // For each row color, use the base color hue and add an offset that's
+ // not a dividend of 360
+
+ QColor color;
+ const int h = (base_->color().toHsv().hue() + 20 * row_index) % 360;
+ const int s = DECODETRACE_COLOR_SATURATION;
+ const int v = DECODETRACE_COLOR_VALUE;
+ color.setHsl(h, s, v);
+
+ return color;
+}
+
+QColor DecodeTrace::get_annotation_color(QColor row_color, int annotation_index) const
+{
+ // For each row color, use the base color hue and add an offset that's
+ // not a dividend of 360 and not a multiple of the row offset
+
+ QColor color(row_color);
+ const int h = (color.toHsv().hue() + 55 * annotation_index) % 360;
+ const int s = DECODETRACE_COLOR_SATURATION;
+ const int v = DECODETRACE_COLOR_VALUE;
+ color.setHsl(h, s, v);
+
+ return color;
+}
+
int DecodeTrace::get_row_at_point(const QPoint &point)
{
if (!row_height_)
vector<pv::data::decode::Annotation> annotations;
- shared_ptr<pv::data::DecoderStack> decoder_stack = base_->decoder_stack();
-
- assert(decoder_stack);
- decoder_stack->get_annotation_subset(annotations, visible_rows_[row],
- sample_range.first, sample_range.second);
+ decode_signal_->get_annotation_subset(annotations, visible_rows_[row],
+ current_segment_, sample_range.first, sample_range.second);
return (annotations.empty()) ?
QString() : annotations[0].annotations().front();
}
-void DecodeTrace::hover_point_changed()
+void DecodeTrace::hover_point_changed(const QPoint &hp)
{
assert(owner_);
const View *const view = owner_->view();
assert(view);
- QPoint hp = view->hover_point();
+ if (hp.x() == 0) {
+ QToolTip::hideText();
+ return;
+ }
+
QString ann = get_annotation_at_point(hp);
assert(view);
// If it did, the tool tip would constantly hide and re-appear.
// We also push it up by one row so that it appears above the
// decode trace, not below.
- hp.setX(hp.x() - (text_size.width() / 2) - padding);
+ QPoint p = hp;
+ p.setX(hp.x() - (text_size.width() / 2) - padding);
- hp.setY(get_visual_y() - (row_height_ / 2) +
+ p.setY(get_visual_y() - (row_height_ / 2) +
(hover_row * row_height_) -
row_height_ - text_size.height() - padding);
- QToolTip::showText(view->viewport()->mapToGlobal(hp), ann);
+ QToolTip::showText(view->viewport()->mapToGlobal(p), ann);
}
void DecodeTrace::create_decoder_form(int index,
shared_ptr<data::decode::Decoder> &dec, QWidget *parent,
QFormLayout *form)
{
- const GSList *l;
GlobalSettings settings;
assert(dec);
QFormLayout *const decoder_form = new QFormLayout;
group->add_layout(decoder_form);
- // Add the mandatory channels
- for (l = decoder->channels; l; l = l->next) {
- const struct srd_channel *const pdch =
- (struct srd_channel *)l->data;
+ const vector<DecodeChannel> channels = decode_signal_->get_channels();
- QComboBox *const combo = create_channel_selector(parent, dec, pdch);
- QComboBox *const combo_initial_pin = create_channel_selector_initial_pin(parent, dec, pdch);
+ // Add the channels
+ for (DecodeChannel ch : channels) {
+ // Ignore channels not part of the decoder we create the form for
+ if (ch.decoder_ != dec)
+ continue;
- connect(combo, SIGNAL(currentIndexChanged(int)),
- this, SLOT(on_channel_selected(int)));
- connect(combo_initial_pin, SIGNAL(currentIndexChanged(int)),
- this, SLOT(on_initial_pin_selected(int)));
+ QComboBox *const combo = create_channel_selector(parent, &ch);
+ QComboBox *const combo_init_state = create_channel_selector_init_state(parent, &ch);
- QHBoxLayout *const hlayout = new QHBoxLayout;
- hlayout->addWidget(combo);
- hlayout->addWidget(combo_initial_pin);
-
- if (!settings.value(GlobalSettings::Key_Dec_InitialStateConfigurable).toBool())
- combo_initial_pin->hide();
-
- decoder_form->addRow(tr("<b>%1</b> (%2) *")
- .arg(QString::fromUtf8(pdch->name),
- QString::fromUtf8(pdch->desc)), hlayout);
-
- const ChannelSelector s = {combo, combo_initial_pin, dec, pdch};
- channel_selectors_.push_back(s);
- }
-
- // Add the optional channels
- for (l = decoder->opt_channels; l; l = l->next) {
- const struct srd_channel *const pdch =
- (struct srd_channel *)l->data;
-
- QComboBox *const combo = create_channel_selector(parent, dec, pdch);
- QComboBox *const combo_initial_pin = create_channel_selector_initial_pin(parent, dec, pdch);
+ channel_id_map_[combo] = ch.id;
+ init_state_map_[combo_init_state] = ch.id;
connect(combo, SIGNAL(currentIndexChanged(int)),
this, SLOT(on_channel_selected(int)));
- connect(combo_initial_pin, SIGNAL(currentIndexChanged(int)),
- this, SLOT(on_initial_pin_selected(int)));
+ connect(combo_init_state, SIGNAL(currentIndexChanged(int)),
+ this, SLOT(on_init_state_changed(int)));
QHBoxLayout *const hlayout = new QHBoxLayout;
hlayout->addWidget(combo);
- hlayout->addWidget(combo_initial_pin);
+ hlayout->addWidget(combo_init_state);
if (!settings.value(GlobalSettings::Key_Dec_InitialStateConfigurable).toBool())
- combo_initial_pin->hide();
-
- decoder_form->addRow(tr("<b>%1</b> (%2)")
- .arg(QString::fromUtf8(pdch->name),
- QString::fromUtf8(pdch->desc)), hlayout);
+ combo_init_state->hide();
- const ChannelSelector s = {combo, combo_initial_pin, dec, pdch};
- channel_selectors_.push_back(s);
+ const QString required_flag = ch.is_optional ? QString() : QString("*");
+ decoder_form->addRow(tr("<b>%1</b> (%2) %3")
+ .arg(ch.name, ch.desc, required_flag), hlayout);
}
- shared_ptr<pv::data::DecoderStack> decoder_stack = base_->decoder_stack();
-
// Add the options
shared_ptr<binding::Decoder> binding(
- new binding::Decoder(decoder_stack, dec));
+ new binding::Decoder(decode_signal_, dec));
binding->add_properties_to_form(decoder_form, true);
bindings_.push_back(binding);
decoder_forms_.push_back(group);
}
-QComboBox* DecodeTrace::create_channel_selector(
- QWidget *parent, const shared_ptr<data::decode::Decoder> &dec,
- const srd_channel *const pdch)
+QComboBox* DecodeTrace::create_channel_selector(QWidget *parent, const DecodeChannel *ch)
{
- assert(dec);
-
const auto sigs(session_.signalbases());
+ // Sort signals in natural order
vector< shared_ptr<data::SignalBase> > sig_list(sigs.begin(), sigs.end());
sort(sig_list.begin(), sig_list.end(),
[](const shared_ptr<data::SignalBase> &a,
return strnatcasecmp(a->name().toStdString(),
b->name().toStdString()) < 0; });
- const auto channel_iter = dec->channels().find(pdch);
-
QComboBox *selector = new QComboBox(parent);
selector->addItem("-", qVariantFromValue((void*)nullptr));
- if (channel_iter == dec->channels().end())
+ if (!ch->assigned_signal)
selector->setCurrentIndex(0);
for (const shared_ptr<data::SignalBase> &b : sig_list) {
selector->addItem(b->name(),
qVariantFromValue((void*)b.get()));
- if (channel_iter != dec->channels().end() &&
- (*channel_iter).second == b)
- selector->setCurrentIndex(
- selector->count() - 1);
+ if (ch->assigned_signal == b.get())
+ selector->setCurrentIndex(selector->count() - 1);
}
}
return selector;
}
-QComboBox* DecodeTrace::create_channel_selector_initial_pin(QWidget *parent,
- const shared_ptr<data::decode::Decoder> &dec, const srd_channel *const pdch)
+QComboBox* DecodeTrace::create_channel_selector_init_state(QWidget *parent,
+ const DecodeChannel *ch)
{
QComboBox *selector = new QComboBox(parent);
selector->addItem("1", qVariantFromValue((int)SRD_INITIAL_PIN_HIGH));
selector->addItem("X", qVariantFromValue((int)SRD_INITIAL_PIN_SAME_AS_SAMPLE0));
- // Default to index 2 (SRD_INITIAL_PIN_SAME_AS_SAMPLE0).
- const int idx = (!dec->initial_pins()) ? 2 : dec->initial_pins()->data[pdch->order];
- selector->setCurrentIndex(idx);
+ selector->setCurrentIndex(ch->initial_pin_state);
selector->setToolTip("Initial (assumed) pin value before the first sample");
return selector;
}
-void DecodeTrace::commit_decoder_channels(shared_ptr<data::decode::Decoder> &dec)
+void DecodeTrace::on_new_annotations()
{
- assert(dec);
-
- map<const srd_channel*, shared_ptr<data::SignalBase> > channel_map;
-
- const unordered_set< shared_ptr<data::SignalBase> >
- sigs(session_.signalbases());
-
- GArray *const initial_pins = g_array_sized_new(FALSE, TRUE,
- sizeof(uint8_t), channel_selectors_.size());
- g_array_set_size(initial_pins, channel_selectors_.size());
-
- for (const ChannelSelector &s : channel_selectors_) {
- if (s.decoder_ != dec)
- break;
-
- const data::SignalBase *const selection =
- (data::SignalBase*)s.combo_->itemData(
- s.combo_->currentIndex()).value<void*>();
-
- for (shared_ptr<data::SignalBase> sig : sigs)
- if (sig.get() == selection) {
- channel_map[s.pdch_] = sig;
- break;
- }
-
- int selection_initial_pin = s.combo_initial_pin_->itemData(
- s.combo_initial_pin_->currentIndex()).value<int>();
-
- initial_pins->data[s.pdch_->order] = selection_initial_pin;
- }
-
- dec->set_channels(channel_map);
- dec->set_initial_pins(initial_pins);
+ if (!delayed_trace_updater_.isActive())
+ delayed_trace_updater_.start();
}
-void DecodeTrace::commit_channels()
+void DecodeTrace::on_delayed_trace_update()
{
- shared_ptr<pv::data::DecoderStack> decoder_stack = base_->decoder_stack();
+ if (owner_)
+ owner_->row_item_appearance_changed(false, true);
+}
- assert(decoder_stack);
- for (shared_ptr<data::decode::Decoder> dec : decoder_stack->stack())
- commit_decoder_channels(dec);
+void DecodeTrace::on_decode_reset()
+{
+ visible_rows_.clear();
+ max_visible_rows_ = 0;
- decoder_stack->begin_decode();
+ if (owner_)
+ owner_->row_item_appearance_changed(false, true);
}
-void DecodeTrace::on_new_decode_data()
+void DecodeTrace::on_decode_finished()
{
if (owner_)
owner_->row_item_appearance_changed(false, true);
void DecodeTrace::on_delete()
{
- session_.remove_decode_signal(base_);
+ session_.remove_decode_signal(decode_signal_);
}
void DecodeTrace::on_channel_selected(int)
{
- commit_channels();
+ QComboBox *cb = qobject_cast<QComboBox*>(QObject::sender());
+
+ // Determine signal that was selected
+ const data::SignalBase *signal =
+ (data::SignalBase*)cb->itemData(cb->currentIndex()).value<void*>();
+
+ // Determine decode channel ID this combo box is the channel selector for
+ const uint16_t id = channel_id_map_.at(cb);
+
+ decode_signal_->assign_signal(id, signal);
}
-void DecodeTrace::on_initial_pin_selected(int)
+void DecodeTrace::on_channels_updated()
{
- commit_channels();
+ if (owner_)
+ owner_->row_item_appearance_changed(false, true);
}
-void DecodeTrace::on_stack_decoder(srd_decoder *decoder)
+void DecodeTrace::on_init_state_changed(int)
{
- shared_ptr<pv::data::DecoderStack> decoder_stack = base_->decoder_stack();
+ QComboBox *cb = qobject_cast<QComboBox*>(QObject::sender());
- assert(decoder);
- assert(decoder_stack);
- decoder_stack->push(make_shared<data::decode::Decoder>(decoder));
- decoder_stack->begin_decode();
+ // Determine inital pin state that was selected
+ int init_state = cb->itemData(cb->currentIndex()).value<int>();
+
+ // Determine decode channel ID this combo box is the channel selector for
+ const uint16_t id = init_state_map_.at(cb);
+
+ decode_signal_->set_initial_pin_state(id, init_state);
+}
+
+void DecodeTrace::on_stack_decoder(srd_decoder *decoder)
+{
+ decode_signal_->stack_decoder(decoder);
create_popup_form();
}
void DecodeTrace::on_delete_decoder(int index)
{
- shared_ptr<pv::data::DecoderStack> decoder_stack = base_->decoder_stack();
+ decode_signal_->remove_decoder(index);
- decoder_stack->remove(index);
+ // Force re-calculation of the trace height, see paint_mid()
+ max_visible_rows_ = 0;
+ owner_->extents_changed(false, true);
// Update the popup
create_popup_form();
-
- decoder_stack->begin_decode();
}
void DecodeTrace::on_show_hide_decoder(int index)
{
- using pv::data::decode::Decoder;
-
- shared_ptr<pv::data::DecoderStack> decoder_stack = base_->decoder_stack();
-
- const list< shared_ptr<Decoder> > stack(decoder_stack->stack());
-
- // Find the decoder in the stack
- auto iter = stack.cbegin();
- for (int i = 0; i < index; i++, iter++)
- assert(iter != stack.end());
-
- shared_ptr<Decoder> dec = *iter;
- assert(dec);
-
- const bool show = !dec->shown();
- dec->show(show);
+ const bool state = decode_signal_->toggle_decoder_visibility(index);
assert(index < (int)decoder_forms_.size());
- decoder_forms_[index]->set_decoder_visible(show);
+ decoder_forms_[index]->set_decoder_visible(state);
+
+ if (!state) {
+ // Force re-calculation of the trace height, see paint_mid()
+ max_visible_rows_ = 0;
+ owner_->extents_changed(false, true);
+ }
if (owner_)
owner_->row_item_appearance_changed(false, true);