Properly handle decoder errors

[pulseview.git] / pv / views / trace / decodetrace.cpp

diff --git a/pv/views/trace/decodetrace.cpp b/pv/views/trace/decodetrace.cpp
index a1db8edec12e3dfe2998c835797eb3d755e2a9cb..211d46e448a531d3313c205745ff4aaf015a1133 100644 (file)
--- a/pv/views/trace/decodetrace.cpp
+++ b/pv/views/trace/decodetrace.cpp
@@ -22,11 +22,10 @@ extern "C" {
 }
 
 #include <mutex>
 }
 
 #include <mutex>

+#include <tuple>

 
 #include <extdef.h>
 
 
 #include <extdef.h>
 

-#include <tuple>
-

 #include <boost/functional/hash.hpp>
 
 #include <QAction>
 #include <boost/functional/hash.hpp>
 
 #include <QAction>


@@ -53,7 +52,7 @@ extern "C" {
 #include <pv/widgets/decodergroupbox.hpp>
 #include <pv/widgets/decodermenu.hpp>
 
 #include <pv/widgets/decodergroupbox.hpp>
 #include <pv/widgets/decodermenu.hpp>
 

-using std::all_of;
+using std::abs;

 using std::make_pair;
 using std::max;
 using std::min;
 using std::make_pair;
 using std::max;
 using std::min;


@@ -164,21 +163,18 @@ void DecodeTrace::paint_mid(QPainter &p, ViewItemPaintParams &pp)
        row_height_ = (text_height * 6) / 4;
        const int annotation_height = (text_height * 5) / 4;
 
        row_height_ = (text_height * 6) / 4;
        const int annotation_height = (text_height * 5) / 4;
 

-       const QString err = decode_signal_->error_message();
-       if (!err.isEmpty()) {
-               draw_unresolved_period(
-                       p, annotation_height, pp.left(), pp.right());
-               draw_error(p, err, pp);
-               return;
-       }
-

        // Set default pen to allow for text width calculation
        p.setPen(Qt::black);
 
        // Iterate through the rows
        int y = get_visual_y();
        // Set default pen to allow for text width calculation
        p.setPen(Qt::black);
 
        // Iterate through the rows
        int y = get_visual_y();

-       pair<uint64_t, uint64_t> sample_range = get_sample_range(
-               pp.left(), pp.right());
+       pair<uint64_t, uint64_t> sample_range = get_sample_range(pp.left(), pp.right());
+
+       // Just because the view says we see a certain sample range it
+       // doesn't mean we have this many decoded samples, too, so crop
+       // the range to what has been decoded already
+       sample_range.second = min((int64_t)sample_range.second,
+               decode_signal_->get_decoded_sample_count(current_segment_, false));

 
        const vector<Row> rows = decode_signal_->visible_rows();
 
 
        const vector<Row> rows = decode_signal_->visible_rows();
 


@@ -203,12 +199,10 @@ void DecodeTrace::paint_mid(QPainter &p, ViewItemPaintParams &pp)
                                get_row_color(visible_rows_.size()), row_title_width);
 
                        y += row_height_;
                                get_row_color(visible_rows_.size()), row_title_width);
 
                        y += row_height_;

-

                        visible_rows_.push_back(row);
                }
        }
 
                        visible_rows_.push_back(row);
                }
        }
 

-       // Draw the hatching

        draw_unresolved_period(p, annotation_height, pp.left(), pp.right());
 
        if ((int)visible_rows_.size() > max_visible_rows_) {
        draw_unresolved_period(p, annotation_height, pp.left(), pp.right());
 
        if ((int)visible_rows_.size() > max_visible_rows_) {


@@ -218,6 +212,10 @@ void DecodeTrace::paint_mid(QPainter &p, ViewItemPaintParams &pp)
                owner_->extents_changed(false, true);
                owner_->row_item_appearance_changed(false, true);
        }
                owner_->extents_changed(false, true);
                owner_->row_item_appearance_changed(false, true);
        }

+
+       const QString err = decode_signal_->error_message();
+       if (!err.isEmpty())
+               draw_error(p, err, pp);

 }
 
 void DecodeTrace::paint_fore(QPainter &p, ViewItemPaintParams &pp)
 }
 
 void DecodeTrace::paint_fore(QPainter &p, ViewItemPaintParams &pp)


@@ -256,6 +254,9 @@ void DecodeTrace::paint_fore(QPainter &p, ViewItemPaintParams &pp)
                p.setPen(QApplication::palette().color(QPalette::WindowText));
                p.drawText(r, f, h);
        }
                p.setPen(QApplication::palette().color(QPalette::WindowText));
                p.drawText(r, f, h);
        }

+
+       if (show_hover_marker_)
+               paint_hover_marker(p);

 }
 
 void DecodeTrace::populate_popup_form(QWidget *parent, QFormLayout *form)
 }
 
 void DecodeTrace::populate_popup_form(QWidget *parent, QFormLayout *form)


@@ -329,13 +330,13 @@ void DecodeTrace::draw_annotations(vector<pv::data::decode::Annotation> annotati
 
        Annotation::Class block_class = 0;
        bool block_class_uniform = true;
 
        Annotation::Class block_class = 0;
        bool block_class_uniform = true;

-       int block_start = 0;
+       qreal block_start = 0;

        int block_ann_count = 0;
 
        const Annotation *prev_ann;
        int block_ann_count = 0;
 
        const Annotation *prev_ann;

-       int prev_end = INT_MIN;
+       qreal prev_end = INT_MIN;

 
 

-       int a_end;
+       qreal a_end;

 
        double samples_per_pixel, pixels_offset;
        tie(pixels_offset, samples_per_pixel) =
 
        double samples_per_pixel, pixels_offset;
        tie(pixels_offset, samples_per_pixel) =


@@ -350,21 +351,21 @@ void DecodeTrace::draw_annotations(vector<pv::data::decode::Annotation> annotati
        // Gather all annotations that form a visual "block" and draw them as such
        for (const Annotation &a : annotations) {
 
        // Gather all annotations that form a visual "block" and draw them as such
        for (const Annotation &a : annotations) {
 

-               const int abs_a_start = a.start_sample() / samples_per_pixel;
-               const int 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 int a_start = abs_a_start - pixels_offset;
+               const qreal a_start = abs_a_start - pixels_offset;

                a_end = abs_a_end - pixels_offset;
 
                a_end = abs_a_end - pixels_offset;
 

-               const int a_width = a_end - a_start;
-               const int delta = a_end - prev_end;
+               const qreal a_width = a_end - a_start;
+               const qreal delta = a_end - prev_end;

 
                bool a_is_separate = false;
 
                // Annotation wider than the threshold for a useful label width?
                if (a_width >= min_useful_label_width_) {
                        for (const QString &ann_text : a.annotations()) {
 
                bool a_is_separate = false;
 
                // Annotation wider than the threshold for a useful label width?
                if (a_width >= min_useful_label_width_) {
                        for (const QString &ann_text : a.annotations()) {

-                               const int w = p.boundingRect(QRectF(), 0, ann_text).width();
+                               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) {
                                        a_is_separate = true;
                                // Annotation wide enough to fit a label? Don't put it in a block then
                                if (w <= a_width) {
                                        a_is_separate = true;


@@ -392,6 +393,7 @@ void DecodeTrace::draw_annotations(vector<pv::data::decode::Annotation> annotati
                        // 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;
                        // 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;

+                       block_ann_count = 0;

                } else {
                        prev_end = a_end;
                        prev_ann = &a;
                } else {
                        prev_end = a_end;
                        prev_ann = &a;


@@ -440,7 +442,7 @@ void DecodeTrace::draw_annotation(const pv::data::decode::Annotation &a,
                draw_range(a, p, h, start, end, y, pp, row_title_width);
 }
 
                draw_range(a, p, h, start, end, y, pp, row_title_width);
 }
 

-void DecodeTrace::draw_annotation_block(int start, int end,
+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 h,
        int y, QColor row_color) const
 {


@@ -470,11 +472,11 @@ void DecodeTrace::draw_annotation_block(int start, int end,
 }
 
 void DecodeTrace::draw_instant(const pv::data::decode::Annotation &a, QPainter &p,
 }
 
 void DecodeTrace::draw_instant(const pv::data::decode::Annotation &a, QPainter &p,

-       int h, double x, int y) const
+       int h, 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 double w = min((double)p.boundingRect(QRectF(), 0, text).width(),
+       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) + h;
        const QRectF rect(x - w / 2, y - h / 2, w, h);
 


@@ -485,11 +487,11 @@ void DecodeTrace::draw_instant(const pv::data::decode::Annotation &a, QPainter &
 }
 
 void DecodeTrace::draw_range(const pv::data::decode::Annotation &a, QPainter &p,
 }
 
 void DecodeTrace::draw_range(const pv::data::decode::Annotation &a, QPainter &p,

-       int h, double start, double end, int y, const ViewItemPaintParams &pp,
+       int h, qreal start, qreal end, int y, const ViewItemPaintParams &pp,

        int row_title_width) const
 {
        int row_title_width) const
 {

-       const double top = y + .5 - h / 2;
-       const double bottom = y + .5 + h / 2;
+       const qreal top = y + .5 - h / 2;
+       const qreal bottom = y + .5 + h / 2;

        const vector<QString> annotations = a.annotations();
 
        // If the two ends are within 1 pixel, draw a vertical line
        const vector<QString> annotations = a.annotations();
 
        // If the two ends are within 1 pixel, draw a vertical line


@@ -498,7 +500,7 @@ void DecodeTrace::draw_range(const pv::data::decode::Annotation &a, QPainter &p,
                return;
        }
 
                return;
        }
 

-       const double cap_width = min((end - start) / 4, EndCapWidth);
+       const qreal cap_width = min((end - start) / 4, EndCapWidth);

 
        QPointF pts[] = {
                QPointF(start, y + .5f),
 
        QPointF pts[] = {
                QPointF(start, y + .5f),


@@ -550,17 +552,18 @@ void DecodeTrace::draw_error(QPainter &p, const QString &message,
 {
        const int y = get_visual_y();
 
 {
        const int y = get_visual_y();
 

+       double samples_per_pixel, pixels_offset;
+       tie(pixels_offset, samples_per_pixel) = get_pixels_offset_samples_per_pixel();
+

        p.setPen(ErrorBgColor.darker());
        p.setBrush(ErrorBgColor);
 
        p.setPen(ErrorBgColor.darker());
        p.setBrush(ErrorBgColor);
 

-       const QRectF bounding_rect =
-               QRectF(pp.left(), INT_MIN / 2 + y, pp.right(), INT_MAX);
-       const QRectF text_rect = p.boundingRect(bounding_rect,
-               Qt::AlignCenter, message);
-       const float r = text_rect.height() / 4;
+       const QRectF bounding_rect = QRectF(pp.left(), INT_MIN / 2 + y, pp.right(), INT_MAX);

 
 

-       p.drawRoundedRect(text_rect.adjusted(-r, -r, r, r), r, r,
-               Qt::AbsoluteSize);
+       const QRectF text_rect = p.boundingRect(bounding_rect, Qt::AlignCenter, message);
+       const qreal r = text_rect.height() / 4;
+
+       p.drawRoundedRect(text_rect.adjusted(-r, -r, r, r), r, r, Qt::AbsoluteSize);

 
        p.setPen(Qt::black);
        p.drawText(text_rect, message);
 
        p.setPen(Qt::black);
        p.drawText(text_rect, message);


@@ -577,7 +580,7 @@ void DecodeTrace::draw_unresolved_period(QPainter &p, int h, int left, int right
        if (sample_count == 0)
                return;
 
        if (sample_count == 0)
                return;
 

-       const int64_t samples_decoded = decode_signal_->get_decoded_sample_count(current_segment_);
+       const int64_t samples_decoded = decode_signal_->get_decoded_sample_count(current_segment_, true);

        if (sample_count == samples_decoded)
                return;
 
        if (sample_count == samples_decoded)
                return;
 


@@ -708,6 +711,8 @@ const QString DecodeTrace::get_annotation_at_point(const QPoint &point)
 
 void DecodeTrace::hover_point_changed(const QPoint &hp)
 {
 
 void DecodeTrace::hover_point_changed(const QPoint &hp)
 {

+       Trace::hover_point_changed(hp);
+

        assert(owner_);
 
        const View *const view = owner_->view();
        assert(owner_);
 
        const View *const view = owner_->view();