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::MaxTraceUpdateRate = 1; // No more than 1 Hz
-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)
-};
-
DecodeTrace::DecodeTrace(pv::Session &session,
shared_ptr<data::SignalBase> signalbase, int index) :
Trace(signalbase),
QFontMetrics m(QApplication::font());
min_useful_label_width_ = m.width("XX"); // e.g. two hex characters
- 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()),
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;
decode_signal_->get_annotation_subset(annotations, row,
- sample_range.first, sample_range.second);
+ 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_;
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;
- vector<Annotation> a_block;
- int p_end = INT_MIN;
+ Annotation::Class block_class = 0;
+ bool block_class_uniform = true;
+ int block_start = 0;
+ int block_ann_count = 0;
+
+ const Annotation *prev_ann;
+ int prev_end = INT_MIN;
+
+ int a_end;
double samples_per_pixel, pixels_offset;
tie(pixels_offset, samples_per_pixel) =
// Gather all annotations that form a visual "block" and draw them as such
for (const Annotation &a : annotations) {
- const int a_start = a.start_sample() / samples_per_pixel - pixels_offset;
- const int a_end = a.end_sample() / samples_per_pixel - pixels_offset;
- const int a_width = a_end - a_start;
+ const int abs_a_start = a.start_sample() / samples_per_pixel;
+ const int abs_a_end = a.end_sample() / samples_per_pixel;
- const int delta = a_end - p_end;
+ const int a_start = abs_a_start - pixels_offset;
+ a_end = abs_a_end - pixels_offset;
+
+ const int a_width = a_end - a_start;
+ const int delta = a_end - prev_end;
bool a_is_separate = false;
// Were the previous and this annotation more than a pixel apart?
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,
+ if (block_ann_count == 1)
+ draw_annotation(*prev_ann, p, h, pp, y, row_color,
row_title_width);
- }
- else
- draw_annotation_block(a_block, p, h, y, base_colour);
+ else if (block_ann_count > 0)
+ draw_annotation_block(block_start, prev_end, block_class,
+ block_class_uniform, p, h, y, row_color);
- a_block.clear();
+ block_ann_count = 0;
}
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
- p_end = INT_MIN;
+ // because we set prev_end to INT_MIN but that's okay since
+ // block_ann_count will be 0 and nothing will be drawn
+ prev_end = INT_MIN;
} else {
- a_block.push_back(a);
- p_end = a_end;
+ prev_end = a_end;
+ prev_ann = &a;
+
+ if (block_ann_count == 0) {
+ block_start = a_start;
+ block_class = a.ann_class();
+ block_class_uniform = true;
+ } else
+ if (a.ann_class() != block_class)
+ block_class_uniform = false;
+
+ block_ann_count++;
}
}
- if (a_block.size() == 1)
- draw_annotation(a_block.front(), p, h, pp, y, base_colour,
- row_title_width);
- else
- draw_annotation_block(a_block, p, h, y, base_colour);
+ if (block_ann_count == 1)
+ draw_annotation(*prev_ann, p, h, pp, y, row_color, row_title_width);
+ else if (block_ann_count > 0)
+ draw_annotation_block(block_start, prev_end, block_class,
+ block_class_uniform, 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;
draw_range(a, p, h, start, end, y, pp, row_title_width);
}
-void DecodeTrace::draw_annotation_block(
- vector<pv::data::decode::Annotation> annotations, QPainter &p, int h,
- int y, size_t base_colour) const
+void DecodeTrace::draw_annotation_block(int start, int end,
+ Annotation::Class ann_class, bool use_ann_format, QPainter &p, int h,
+ int y, QColor row_color) const
{
- using namespace pv::data::decode;
-
- if (annotations.empty())
- return;
-
- double samples_per_pixel, pixels_offset;
- tie(pixels_offset, samples_per_pixel) =
- get_pixels_offset_samples_per_pixel();
-
- const double start = annotations.front().start_sample() /
- samples_per_pixel - pixels_offset;
- const double end = annotations.back().end_sample() /
- samples_per_pixel - pixels_offset;
-
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);
-
- // 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(
- annotations.begin(), annotations.end(),
- [&](const Annotation &a) { return a.format() == format; });
-
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));
+ // If all annotations in this block are of the same type, we can use the
+ // one format that all of these annotations have. Otherwise, we should use
+ // a neutral color (i.e. gray)
+ if (use_ann_format) {
+ const QColor color = get_annotation_color(row_color, ann_class);
+ p.setPen(color.darker());
+ p.setBrush(QBrush(color, Qt::Dense4Pattern));
+ } else {
+ p.setPen(Qt::gray);
+ p.setBrush(QBrush(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);
double samples_per_pixel, pixels_offset;
- const int64_t sample_count = decode_signal_->get_working_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 = decode_signal_->get_decoded_sample_count();
+ const int64_t samples_decoded = decode_signal_->get_decoded_sample_count(current_segment_);
if (sample_count == samples_decoded)
return;
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);
}
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;
decode_signal_->get_annotation_subset(annotations, visible_rows_[row],
- sample_range.first, sample_range.second);
+ current_segment_, sample_range.first, sample_range.second);
return (annotations.empty()) ?
QString() : annotations[0].annotations().front();
owner_->row_item_appearance_changed(false, true);
}
+void DecodeTrace::on_decode_reset()
+{
+ visible_rows_.clear();
+ max_visible_rows_ = 0;
+
+ if (owner_)
+ owner_->row_item_appearance_changed(false, true);
+}
+
void DecodeTrace::on_decode_finished()
{
if (owner_)