#include <QClipboard>
#include <QCheckBox>
#include <QComboBox>
+#include <QDebug>
#include <QFileDialog>
#include <QFormLayout>
#include <QLabel>
namespace views {
namespace trace {
-
#define DECODETRACE_COLOR_SATURATION (180) /* 0-255 */
#define DECODETRACE_COLOR_VALUE (170) /* 0-255 */
{
lock_guard<mutex> lock(row_modification_mutex_);
+#if DECODETRACE_SHOW_RENDER_TIME
+ render_time_.restart();
+#endif
+
// Set default pen to allow for text width calculation
p.setPen(Qt::black);
// If the row is hidden, we don't want to fetch annotations
assert(r.decode_row);
assert(r.decode_row->decoder());
- if ((!r.decode_row->decoder()->shown()) || (!r.decode_row->visible())) {
+ if ((!r.decode_row->decoder()->visible()) || (!r.decode_row->visible())) {
r.currently_visible = false;
continue;
}
- vector<Annotation> annotations;
+ vector<const Annotation*> annotations;
decode_signal_->get_annotation_subset(annotations, r.decode_row,
current_segment_, sample_range.first, sample_range.second);
- // Show row if there are visible annotations or when user wants to see
+ // Show row if there are visible annotations, when user wants to see
// all rows that have annotations somewhere and this one is one of them
+ // or when the row has at least one hidden annotation class
r.currently_visible = !annotations.empty();
if (!r.currently_visible) {
size_t ann_count = decode_signal_->get_annotation_count(r.decode_row, current_segment_);
- r.currently_visible = always_show_all_rows_ && (ann_count > 0);
+ r.currently_visible = (always_show_all_rows_ || r.has_hidden_classes) &&
+ (ann_count > 0);
}
if (r.currently_visible) {
- draw_annotations(annotations, p, annotation_height_, pp, y,
- get_row_color(r.decode_row->index()), r.title_width);
+ draw_annotations(annotations, p, pp, y, r);
y += r.height;
visible_rows_++;
}
}
- draw_unresolved_period(p, annotation_height_, pp.left(), pp.right());
+ draw_unresolved_period(p, pp.left(), pp.right());
if (visible_rows_ > max_visible_rows_) {
max_visible_rows_ = visible_rows_;
const QString err = decode_signal_->error_message();
if (!err.isEmpty())
draw_error(p, err, pp);
+
+#if DECODETRACE_SHOW_RENDER_TIME
+ qDebug() << "Rendering" << base_->name() << "took" << render_time_.elapsed() << "ms";
+#endif
}
void DecodeTrace::paint_fore(QPainter &p, ViewItemPaintParams &pp)
{
unsigned int y = get_visual_y();
+ update_expanded_rows();
+
for (const DecodeTraceRow& r : rows_) {
if (!r.currently_visible)
continue;
void DecodeTrace::update_stack_button()
{
- const vector< shared_ptr<data::decode::Decoder> > &stack = decode_signal_->decoder_stack();
+ const vector< shared_ptr<Decoder> > &stack = decode_signal_->decoder_stack();
// Only show decoders in the menu that can be stacked onto the last one in the stack
if (!stack.empty()) {
void DecodeTrace::populate_popup_form(QWidget *parent, QFormLayout *form)
{
- using pv::data::decode::Decoder;
-
assert(form);
// Add the standard options
if (hover_row) {
int row_y = get_row_y(hover_row);
- if ((hp.x() > 0) && (hp.x() < 2 * ArrowSize) &&
+ if ((hp.x() > 0) && (hp.x() < (int)(ArrowSize + 3 + hover_row->title_width)) &&
(hp.y() > (int)(row_y - ArrowSize)) && (hp.y() < (int)(row_y + ArrowSize)))
hover_row->expand_marker_highlighted = true;
}
continue;
unsigned int y = get_row_y(&r);
- if ((event->x() > 0) && (event->x() <= (int)(ArrowSize + 3)) &&
+ if ((event->x() > 0) && (event->x() <= (int)(ArrowSize + 3 + r.title_width)) &&
(event->y() > (int)(y - (default_row_height_ / 2))) &&
(event->y() <= (int)(y + (default_row_height_ / 2)))) {
}
}
-void DecodeTrace::draw_annotations(vector<pv::data::decode::Annotation> annotations,
- QPainter &p, int h, const ViewItemPaintParams &pp, int y,
- QColor row_color, int row_title_width)
+void DecodeTrace::draw_annotations(vector<const Annotation*> annotations,
+ QPainter &p, const ViewItemPaintParams &pp, int y, const DecodeTraceRow& row)
{
- using namespace pv::data::decode;
-
Annotation::Class block_class = 0;
bool block_class_uniform = true;
qreal block_start = 0;
int block_ann_count = 0;
- const Annotation *prev_ann;
+ const Annotation* prev_ann;
qreal prev_end = INT_MIN;
qreal a_end;
tie(pixels_offset, samples_per_pixel) =
get_pixels_offset_samples_per_pixel();
- // Sort the annotations by start sample so that decoders
- // can't confuse us by creating annotations out of order
- stable_sort(annotations.begin(), annotations.end(),
- [](const Annotation &a, const Annotation &b) {
- return a.start_sample() < b.start_sample(); });
-
// Gather all annotations that form a visual "block" and draw them as such
- for (const Annotation &a : annotations) {
+ for (const Annotation* a : annotations) {
- const qreal abs_a_start = a.start_sample() / samples_per_pixel;
- const qreal abs_a_end = a.end_sample() / samples_per_pixel;
+ const qreal abs_a_start = a->start_sample() / samples_per_pixel;
+ const qreal abs_a_end = a->end_sample() / samples_per_pixel;
const qreal a_start = abs_a_start - pixels_offset;
a_end = abs_a_end - pixels_offset;
// Annotation wider than the threshold for a useful label width?
if (a_width >= min_useful_label_width_) {
- for (const QString &ann_text : a.annotations()) {
+ for (const QString &ann_text : a->annotations()) {
const qreal w = p.boundingRect(QRectF(), 0, ann_text).width();
// Annotation wide enough to fit a label? Don't put it in a block then
if (w <= a_width) {
if ((abs(delta) > 1) || a_is_separate) {
// Block was broken, draw annotations that form the current block
if (block_ann_count == 1)
- draw_annotation(*prev_ann, p, h, pp, y, row_color,
- row_title_width);
+ draw_annotation(prev_ann, p, pp, y, row);
else if (block_ann_count > 0)
draw_annotation_block(block_start, prev_end, block_class,
- block_class_uniform, p, h, y, row_color);
+ block_class_uniform, p, y, row);
block_ann_count = 0;
}
if (a_is_separate) {
- draw_annotation(a, p, h, pp, y, row_color, row_title_width);
+ draw_annotation(a, p, pp, y, row);
// Next annotation must start a new block. delta will be > 1
// because we set prev_end to INT_MIN but that's okay since
// block_ann_count will be 0 and nothing will be drawn
block_ann_count = 0;
} else {
prev_end = a_end;
- prev_ann = &a;
+ prev_ann = a;
if (block_ann_count == 0) {
block_start = a_start;
- block_class = a.ann_class();
+ block_class = a->ann_class();
block_class_uniform = true;
} else
- if (a.ann_class() != block_class)
+ if (a->ann_class() != block_class)
block_class_uniform = false;
block_ann_count++;
}
if (block_ann_count == 1)
- draw_annotation(*prev_ann, p, h, pp, y, row_color, row_title_width);
+ draw_annotation(prev_ann, p, pp, y, row);
else if (block_ann_count > 0)
draw_annotation_block(block_start, prev_end, block_class,
- block_class_uniform, p, h, y, row_color);
+ block_class_uniform, p, y, row);
}
-void DecodeTrace::draw_annotation(const pv::data::decode::Annotation &a,
- QPainter &p, int h, const ViewItemPaintParams &pp, int y,
- QColor row_color, int row_title_width) const
+void DecodeTrace::draw_annotation(const Annotation* a, QPainter &p,
+ const ViewItemPaintParams &pp, int y, const DecodeTraceRow& row) const
{
double samples_per_pixel, pixels_offset;
tie(pixels_offset, samples_per_pixel) =
get_pixels_offset_samples_per_pixel();
- const double start = a.start_sample() / samples_per_pixel -
- pixels_offset;
- const double end = a.end_sample() / samples_per_pixel - pixels_offset;
+ const double start = a->start_sample() / samples_per_pixel - pixels_offset;
+ const double end = a->end_sample() / samples_per_pixel - pixels_offset;
- QColor color = get_annotation_color(row_color, a.ann_class());
+ QColor color = row.ann_class_color.at(a->ann_class());
p.setPen(color.darker());
p.setBrush(color);
if (start > pp.right() + DrawPadding || end < pp.left() - DrawPadding)
return;
- if (a.start_sample() == a.end_sample())
- draw_instant(a, p, h, start, y);
+ if (a->start_sample() == a->end_sample())
+ draw_instant(a, p, start, y);
else
- draw_range(a, p, h, start, end, y, pp, row_title_width);
+ draw_range(a, p, start, end, y, pp, row.title_width);
}
void DecodeTrace::draw_annotation_block(qreal start, qreal end,
- Annotation::Class ann_class, bool use_ann_format, QPainter &p, int h,
- int y, QColor row_color) const
+ Annotation::Class ann_class, bool use_ann_format, QPainter &p, int y,
+ const DecodeTraceRow& row) const
{
- const double top = y + .5 - h / 2;
- const double bottom = y + .5 + h / 2;
+ const double top = y + .5 - annotation_height_ / 2;
+ const double bottom = y + .5 + annotation_height_ / 2;
const QRectF rect(start, top, end - start, bottom - top);
- const int r = h / 4;
+ const int r = annotation_height_ / 4;
p.setPen(QPen(Qt::NoPen));
p.setBrush(Qt::white);
// 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);
+ const QColor color = row.ann_class_color.at(ann_class);
p.setPen(color.darker());
p.setBrush(QBrush(color, Qt::Dense4Pattern));
} else {
p.drawRoundedRect(rect, r, r);
}
-void DecodeTrace::draw_instant(const pv::data::decode::Annotation &a, QPainter &p,
- int h, qreal x, int y) const
+void DecodeTrace::draw_instant(const Annotation* a, QPainter &p, qreal x, int y) const
{
- const QString text = a.annotations().empty() ?
- QString() : a.annotations().back();
+ const QString text = a->annotations().empty() ?
+ QString() : a->annotations().back();
const qreal w = min((qreal)p.boundingRect(QRectF(), 0, text).width(),
- 0.0) + h;
- const QRectF rect(x - w / 2, y - h / 2, w, h);
+ 0.0) + annotation_height_;
+ const QRectF rect(x - w / 2, y - annotation_height_ / 2, w, annotation_height_);
- p.drawRoundedRect(rect, h / 2, h / 2);
+ p.drawRoundedRect(rect, annotation_height_ / 2, annotation_height_ / 2);
p.setPen(Qt::black);
p.drawText(rect, Qt::AlignCenter | Qt::AlignVCenter, text);
}
-void DecodeTrace::draw_range(const pv::data::decode::Annotation &a, QPainter &p,
- int h, qreal start, qreal end, int y, const ViewItemPaintParams &pp,
+void DecodeTrace::draw_range(const Annotation* a, QPainter &p,
+ qreal start, qreal end, int y, const ViewItemPaintParams &pp,
int row_title_width) const
{
- const qreal top = y + .5 - h / 2;
- const qreal bottom = y + .5 + h / 2;
- const vector<QString> annotations = a.annotations();
+ const qreal top = y + .5 - annotation_height_ / 2;
+ const qreal bottom = y + .5 + annotation_height_ / 2;
+ const vector<QString> annotations = a->annotations();
// If the two ends are within 1 pixel, draw a vertical line
if (start + 1.0 > end) {
const int real_end = min(ann_end, pp.right());
const int real_width = real_end - real_start;
- QRectF rect(real_start, y - h / 2, real_width, h);
+ QRectF rect(real_start, y - annotation_height_ / 2, real_width, annotation_height_);
if (rect.width() <= 4)
return;
QString best_annotation;
int best_width = 0;
- for (const QString &a : annotations) {
- const int w = p.boundingRect(QRectF(), 0, a).width();
+ for (const QString &s : annotations) {
+ const int w = p.boundingRect(QRectF(), 0, s).width();
if (w <= rect.width() && w > best_width)
- best_annotation = a, best_width = w;
+ best_annotation = s, best_width = w;
}
if (best_annotation.isEmpty())
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 left, int right) const
{
- using namespace pv::data;
- using pv::data::decode::Decoder;
-
double samples_per_pixel, pixels_offset;
const int64_t sample_count = decode_signal_->get_working_sample_count(current_segment_);
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 - (annotation_height_ / 2) - 0.5,
+ end - start, annotation_height_);
p.setPen(QPen(Qt::NoPen));
p.setBrush(Qt::white);
const QString DecodeTrace::get_annotation_at_point(const QPoint &point)
{
- using namespace pv::data::decode;
-
if (!enabled())
return QString();
if (point.y() > (int)(get_row_y(r) + (annotation_height_ / 2)))
return QString();
- vector<Annotation> annotations;
+ vector<const Annotation*> annotations;
decode_signal_->get_annotation_subset(annotations, r->decode_row,
current_segment_, sample_range.first, sample_range.second);
return (annotations.empty()) ?
- QString() : annotations[0].annotations().front();
+ QString() : annotations[0]->annotations().front();
}
-void DecodeTrace::create_decoder_form(int index,
- shared_ptr<data::decode::Decoder> &dec, QWidget *parent,
- QFormLayout *form)
+void DecodeTrace::create_decoder_form(int index, shared_ptr<Decoder> &dec,
+ QWidget *parent, QFormLayout *form)
{
GlobalSettings settings;
tr("%1:\n%2").arg(QString::fromUtf8(decoder->longname),
QString::fromUtf8(decoder->desc)),
nullptr, decoder_deletable);
- group->set_decoder_visible(dec->shown());
+ group->set_decoder_visible(dec->visible());
if (decoder_deletable) {
delete_mapper_.setMapping(group, index);
return selector;
}
-void DecodeTrace::export_annotations(vector<Annotation> *annotations) const
+void DecodeTrace::export_annotations(vector<const Annotation*> *annotations) const
{
- using namespace pv::data::decode;
-
GlobalSettings settings;
const QString dir = settings.value("MainWindow/SaveDirectory").toString();
if (file.open(QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Text)) {
QTextStream out_stream(&file);
- for (Annotation &ann : *annotations) {
+ for (const Annotation* ann : *annotations) {
const QString sample_range = QString("%1-%2") \
- .arg(QString::number(ann.start_sample()), QString::number(ann.end_sample()));
+ .arg(QString::number(ann->start_sample()), QString::number(ann->end_sample()));
- const QString row_name = quote + ann.row()->description() + quote;
+ const QString row_name = quote + ann->row()->description() + quote;
QString all_ann_text;
- for (const QString &s : ann.annotations())
+ for (const QString &s : ann->annotations())
all_ann_text = all_ann_text + quote + s + quote + ",";
all_ann_text.chop(1);
- const QString first_ann_text = quote + ann.annotations().front() + quote;
+ const QString first_ann_text = quote + ann->annotations().front() + quote;
QString out_text = format;
out_text = out_text.replace("%s", sample_range);
out_text = out_text.replace("%d",
- quote + QString::fromUtf8(ann.row()->decoder()->name()) + quote);
+ quote + QString::fromUtf8(ann->row()->decoder()->name()) + quote);
out_text = out_text.replace("%r", row_name);
out_text = out_text.replace("%1", first_ann_text);
out_text = out_text.replace("%a", all_ann_text);
nr.header_container = new QWidget(nr.container);
nr.selector_container = new QWidget(nr.container);
+ nr.row_color = get_row_color(decode_row->index());
+
+ vector<AnnotationClass*> ann_classes = decode_row->ann_classes();
+ for (const AnnotationClass* ann_class : ann_classes)
+ nr.ann_class_color[ann_class->id] =
+ get_annotation_color(nr.row_color, ann_class->id);
+
rows_.push_back(nr);
r = &rows_.back();
initialize_row_widgets(r, row_id);
void DecodeTrace::update_expanded_rows()
{
for (DecodeTraceRow& r : rows_) {
-
r.container->move(2 * ArrowSize,
get_row_y(&r) + default_row_height_);
+
+ r.container->resize(owner_->view()->viewport()->width() - r.container->pos().x(),
+ r.height - 2 * default_row_height_);
}
}
void DecodeTrace::on_copy_annotation_to_clipboard()
{
- using namespace pv::data::decode;
-
if (!selected_row_)
return;
- vector<Annotation> *annotations = new vector<Annotation>();
+ vector<const Annotation*> *annotations = new vector<const Annotation*>();
decode_signal_->get_annotation_subset(*annotations, selected_row_,
current_segment_, selected_sample_range_.first, selected_sample_range_.first);
return;
QClipboard *clipboard = QApplication::clipboard();
- clipboard->setText(annotations->front().annotations().front(), QClipboard::Clipboard);
+ clipboard->setText(annotations->front()->annotations().front(), QClipboard::Clipboard);
if (clipboard->supportsSelection())
- clipboard->setText(annotations->front().annotations().front(), QClipboard::Selection);
+ clipboard->setText(annotations->front()->annotations().front(), QClipboard::Selection);
delete annotations;
}
void DecodeTrace::on_export_row_from_here()
{
- using namespace pv::data::decode;
-
if (!selected_row_)
return;
- vector<Annotation> *annotations = new vector<Annotation>();
+ vector<const Annotation*> *annotations = new vector<const Annotation*>();
decode_signal_->get_annotation_subset(*annotations, selected_row_,
current_segment_, selected_sample_range_.first, selected_sample_range_.second);
void DecodeTrace::on_export_all_rows_from_here()
{
- using namespace pv::data::decode;
-
- vector<Annotation> *annotations = new vector<Annotation>();
+ vector<const Annotation*> *annotations = new vector<const Annotation*>();
decode_signal_->get_annotation_subset(*annotations, current_segment_,
selected_sample_range_.first, selected_sample_range_.second);
projects / pulseview.git / blobdiff