#include <pv/data/logicsegment.hpp>
#include <pv/widgets/decodergroupbox.hpp>
#include <pv/widgets/decodermenu.hpp>
+#include <pv/widgets/flowlayout.hpp>
using std::abs;
using std::find_if;
const int DecodeTrace::MaxTraceUpdateRate = 1; // No more than 1 Hz
const unsigned int DecodeTrace::AnimationDurationInTicks = 7;
+
+/**
+ * Helper function for forceUpdate()
+ */
+void invalidateLayout(QLayout* layout)
+{
+ // Recompute the given layout and all its child layouts recursively
+ for (int i = 0; i < layout->count(); i++) {
+ QLayoutItem *item = layout->itemAt(i);
+
+ if (item->layout())
+ invalidateLayout(item->layout());
+ else
+ item->invalidate();
+ }
+
+ layout->invalidate();
+ layout->activate();
+}
+
+void forceUpdate(QWidget* widget)
+{
+ // Update all child widgets recursively
+ for (QObject* child : widget->children())
+ if (child->isWidgetType())
+ forceUpdate((QWidget*)child);
+
+ // Invalidate the layout of the widget itself
+ if (widget->layout())
+ invalidateLayout(widget->layout());
+}
+
+
+ContainerWidget::ContainerWidget(QWidget *parent) :
+ QWidget(parent)
+{
+}
+
+void ContainerWidget::resizeEvent(QResizeEvent* event)
+{
+ QWidget::resizeEvent(event);
+
+ widgetResized(this);
+}
+
+
DecodeTrace::DecodeTrace(pv::Session &session,
shared_ptr<data::SignalBase> signalbase, int index) :
Trace(signalbase),
}
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_;
void DecodeTrace::mouse_left_press_event(const QMouseEvent* event)
{
+ // Update container widths which depend on the scrollarea's current width
+ update_expanded_rows();
+
// Handle row expansion marker
for (DecodeTraceRow& r : rows_) {
if (!r.expand_marker_highlighted)
} else {
r.expanding = true;
r.anim_shape = 0;
+
+ // Force geometry update of the widget container to get
+ // an up-to-date height (which also depends on the width)
+ forceUpdate(r.container);
+
r.container->setVisible(true);
- QApplication::processEvents();
- r.expanded_height = 5 * default_row_height_ + r.container->size().height();
+ r.expanded_height = 2 * default_row_height_ + r.container->sizeHint().height();
}
r.animation_step = 0;
r.anim_height = r.height;
- update_expanded_rows();
animation_timer_.start();
}
}
}
void DecodeTrace::draw_annotations(vector<const Annotation*> annotations,
- QPainter &p, int h, const ViewItemPaintParams &pp, int y,
- QColor row_color, int row_title_width)
+ QPainter &p, const ViewItemPaintParams &pp, int y, const DecodeTraceRow& row)
{
Annotation::Class block_class = 0;
bool block_class_uniform = true;
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
}
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 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 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);
return;
if (a->start_sample() == a->end_sample())
- draw_instant(a, p, h, start, y);
+ 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 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 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 Annotation* a, QPainter &p, int h,
+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 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
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;
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
{
double samples_per_pixel, pixels_offset;
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);
void DecodeTrace::initialize_row_widgets(DecodeTraceRow* r, unsigned int row_id)
{
+ // Set colors and fixed widths
QFontMetrics m(QApplication::font());
QPalette header_palette = owner_->view()->palette();
const int w = m.boundingRect(r->decode_row->title()).width() + RowTitleMargin;
r->title_width = w;
- r->container->resize(owner_->view()->viewport()->width() - r->container->pos().x(),
- r->expanded_height - 2 * default_row_height_);
- r->container->setVisible(false);
+ // Set up top-level container
+ connect(r->container, SIGNAL(widgetResized(QWidget*)),
+ this, SLOT(on_row_container_resized(QWidget*)));
QVBoxLayout* vlayout = new QVBoxLayout();
r->container->setLayout(vlayout);
cb->setText(tr("Show this row"));
cb->setChecked(r->decode_row->visible());
+ cb->setEnabled(false);
+
row_show_hide_mapper_.setMapping(cb, row_id);
connect(cb, SIGNAL(stateChanged(int)),
&row_show_hide_mapper_, SLOT(map()));
// Add selector container
vlayout->addWidget(r->selector_container);
- r->selector_container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
- r->selector_container->setMinimumSize(0, 3 * default_row_height_); // FIXME
- r->selector_container->setLayout(new QHBoxLayout());
+ r->selector_container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+ r->selector_container->setLayout(new FlowLayout(r->selector_container));
r->selector_container->setAutoFillBackground(true);
r->selector_container->setPalette(selector_palette);
cb->setText(tr(ann_class->description));
cb->setChecked(ann_class->visible);
+ int dim = ViewItemPaintParams::text_height() - 2;
+ QPixmap pixmap(dim, dim);
+ pixmap.fill(r->ann_class_color[ann_class->id]);
+ cb->setIcon(pixmap);
+
r->selector_container->layout()->addWidget(cb);
cb->setProperty("ann_class_ptr", QVariant::fromValue((void*)ann_class));
nr.expanded = false;
nr.collapsing = false;
nr.expand_marker_shape = default_marker_shape_;
- nr.container = new QWidget(owner_->view()->scrollarea());
+ nr.container = new ContainerWidget(owner_->view()->scrollarea());
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_);
+ if (r.expanding || r.expanded)
+ r.expanded_height = 2 * default_row_height_ + r.container->sizeHint().height();
+
+ if (r.expanded)
+ r.height = r.expanded_height;
+
+ int x = 2 * ArrowSize;
+ int y = get_row_y(&r) + default_row_height_;
+ // Only update the position if it actually changes
+ if ((x != r.container->pos().x()) || (y != r.container->pos().y()))
+ r.container->move(x, y);
+
+ int w = owner_->view()->viewport()->width() - x;
+ int h = r.height - 2 * default_row_height_;
+ // Only update the dimension if they actually change
+ if ((w != r.container->sizeHint().width()) || (h != r.container->sizeHint().height()))
+ r.container->resize(w, h);
}
}
owner_->row_item_appearance_changed(false, true);
}
+void DecodeTrace::on_row_container_resized(QWidget* sender)
+{
+ sender->update();
+
+ owner_->extents_changed(false, true);
+ owner_->row_item_appearance_changed(false, true);
+}
+
void DecodeTrace::on_copy_annotation_to_clipboard()
{
if (!selected_row_)