DecoderStack: Emancipate from SignalData

[pulseview.git] / pv / view / decodetrace.cpp

diff --git a/pv/view/decodetrace.cpp b/pv/view/decodetrace.cpp
index 01bf934c47095003e3265420622344a6235dc92a..bdae3952ee33cf33b57f7377f9d526f8fa805b61 100644 (file)
--- a/pv/view/decodetrace.cpp
+++ b/pv/view/decodetrace.cpp
@@ -41,7 +41,7 @@ extern "C" {
 
 #include "decodetrace.hpp"
 
-#include <pv/sigsession.hpp>
+#include <pv/session.hpp>
 #include <pv/data/decoderstack.hpp>
 #include <pv/data/decode/decoder.hpp>
 #include <pv/data/logic.hpp>
@@ -123,7 +123,7 @@ const QColor DecodeTrace::OutlineColours[16] = {
        QColor(0x6B, 0x23, 0x37)
 };
 
-DecodeTrace::DecodeTrace(pv::SigSession &session,
+DecodeTrace::DecodeTrace(pv::Session &session,
        std::shared_ptr<pv::data::DecoderStack> decoder_stack, int index) :
        Trace(QString::fromUtf8(
                decoder_stack->stack().front()->decoder()->name)),
@@ -160,24 +160,21 @@ pair<int, int> DecodeTrace::v_extents() const
 {
        /// @todo Replace this with an implementation that knows the true
        /// height of the trace
-       QFontMetrics m(QApplication::font());
-       const int text_height =  m.boundingRect(QRect(), 0, "Tg").height();
-       const int row_height = (text_height * 6) / 4;
+       const int row_height = (RowItemPaintParams::text_height() * 6) / 4;
        return make_pair(-row_height / 2, row_height * 7 / 2);
 }
 
-void DecodeTrace::paint_back(QPainter &p, int left, int right)
+void DecodeTrace::paint_back(QPainter &p, const RowItemPaintParams &pp)
 {
-       Trace::paint_back(p, left, right);
-       paint_axis(p, get_visual_y(), left, right);
+       Trace::paint_back(p, pp);
+       paint_axis(p, pp, get_visual_y());
 }
 
-void DecodeTrace::paint_mid(QPainter &p, int left, int right)
+void DecodeTrace::paint_mid(QPainter &p, const RowItemPaintParams &pp)
 {
        using namespace pv::data::decode;
 
-       QFontMetrics m(QApplication::font());
-       text_height_ = m.boundingRect(QRect(), 0, "Tg").height();
+       text_height_ = RowItemPaintParams::text_height();
        row_height_ = (text_height_ * 6) / 4;
        const int annotation_height = (text_height_ * 5) / 4;
 
@@ -185,14 +182,16 @@ void DecodeTrace::paint_mid(QPainter &p, int left, int right)
        const QString err = decoder_stack_->error_message();
        if (!err.isEmpty())
        {
-               draw_unresolved_period(p, annotation_height, left, right);
-               draw_error(p, err, left, right);
+               draw_unresolved_period(
+                       p, annotation_height, pp.left(), pp.right());
+               draw_error(p, err, pp);
                return;
        }
 
        // Iterate through the rows
        int y = get_visual_y();
-       pair<uint64_t, uint64_t> sample_range = get_sample_range(left, right);
+       pair<uint64_t, uint64_t> sample_range = get_sample_range(
+               pp.left(), pp.right());
 
        assert(decoder_stack_);
        const vector<Row> rows(decoder_stack_->get_visible_rows());
@@ -214,8 +213,7 @@ void DecodeTrace::paint_mid(QPainter &p, int left, int right)
                if (!annotations.empty()) {
                        for (const Annotation &a : annotations)
                                draw_annotation(a, p, get_text_colour(),
-                                       annotation_height, left, right, y,
-                                       base_colour);
+                                       annotation_height, pp, y, base_colour);
                        y += row_height_;
 
                        visible_rows_.push_back(rows[i]);
@@ -223,15 +221,13 @@ void DecodeTrace::paint_mid(QPainter &p, int left, int right)
        }
 
        // Draw the hatching
-       draw_unresolved_period(p, annotation_height, left, right);
+       draw_unresolved_period(p, annotation_height, pp.left(), pp.right());
 }
 
-void DecodeTrace::paint_fore(QPainter &p, int left, int right)
+void DecodeTrace::paint_fore(QPainter &p, const RowItemPaintParams &pp)
 {
        using namespace pv::data::decode;
 
-       (void)right;
-
        assert(row_height_);
 
        for (size_t i = 0; i < visible_rows_.size(); i++)
@@ -244,15 +240,15 @@ void DecodeTrace::paint_fore(QPainter &p, int left, int right)
                if (i != 0)
                {
                        const QPointF points[] = {
-                               QPointF(left, y - ArrowSize),
-                               QPointF(left + ArrowSize, y),
-                               QPointF(left, y + ArrowSize)
+                               QPointF(pp.left(), y - ArrowSize),
+                               QPointF(pp.left() + ArrowSize, y),
+                               QPointF(pp.left(), y + ArrowSize)
                        };
                        p.drawPolygon(points, countof(points));
                }
 
-               const QRect r(left + ArrowSize * 2, y - row_height_ / 2,
-                       right - left, row_height_);
+               const QRect r(pp.left() + ArrowSize * 2, y - row_height_ / 2,
+                       pp.right() - pp.left(), row_height_);
                const QString h(visible_rows_[i].title());
                const int f = Qt::AlignLeft | Qt::AlignVCenter |
                        Qt::TextDontClip;
@@ -337,7 +333,7 @@ QMenu* DecodeTrace::create_context_menu(QWidget *parent)
 }
 
 void DecodeTrace::draw_annotation(const pv::data::decode::Annotation &a,
-       QPainter &p, QColor text_color, int h, int left, int right, int y,
+       QPainter &p, QColor text_color, int h, const RowItemPaintParams &pp, int y,
        size_t base_colour) const
 {
        double samples_per_pixel, pixels_offset;
@@ -353,7 +349,7 @@ void DecodeTrace::draw_annotation(const pv::data::decode::Annotation &a,
        const QColor &fill = Colours[colour];
        const QColor &outline = OutlineColours[colour];
 
-       if (start > right + DrawPadding || end < left - DrawPadding)
+       if (start > pp.right() + DrawPadding || end < pp.left() - DrawPadding)
                return;
 
        if (a.start_sample() == a.end_sample())
@@ -441,7 +437,7 @@ void DecodeTrace::draw_range(const pv::data::decode::Annotation &a, QPainter &p,
 }
 
 void DecodeTrace::draw_error(QPainter &p, const QString &message,
-       int left, int right)
+       const RowItemPaintParams &pp)
 {
        const int y = get_visual_y();
 
@@ -449,7 +445,7 @@ void DecodeTrace::draw_error(QPainter &p, const QString &message,
        p.setBrush(ErrorBgColour);
 
        const QRectF bounding_rect =
-               QRectF(left, INT_MIN / 2 + y, right - left, INT_MAX);
+               QRectF(pp.width(), INT_MIN / 2 + y, pp.width(), INT_MAX);
        const QRectF text_rect = p.boundingRect(bounding_rect,
                Qt::AlignCenter, message);
        const float r = text_rect.height() / 4;
@@ -485,11 +481,11 @@ void DecodeTrace::draw_unresolved_period(QPainter &p, int h, int left,
                        ((data = logic_signal->logic_data())))
                        break;
 
-       if (!data || data->get_snapshots().empty())
+       if (!data || data->logic_snapshots().empty())
                return;
 
        const shared_ptr<LogicSnapshot> snapshot =
-               data->get_snapshots().front();
+               data->logic_snapshots().front();
        assert(snapshot);
        const int64_t sample_count = (int64_t)snapshot->get_sample_count();
        if (sample_count == 0)
@@ -531,7 +527,7 @@ pair<double, double> DecodeTrace::get_pixels_offset_samples_per_pixel() const
        assert(scale > 0);
 
        const double pixels_offset =
-               (view->offset() - decoder_stack_->get_start_time()) / scale;
+               (view->offset() - decoder_stack_->start_time()) / scale;
 
        double samplerate = decoder_stack_->samplerate();
 
@@ -609,9 +605,8 @@ void DecodeTrace::hover_point_changed()
        QString ann = get_annotation_at_point(hp);
 
        assert(view);
-       assert(row_height_);
 
-       if (ann.isEmpty()) {
+       if (!row_height_ || ann.isEmpty()) {
                hide_hover_annotation();
                return;
        }