DecodeTrace: Use qreal instead of int for annotation drawing

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

diff --git a/pv/views/trace/decodetrace.cpp b/pv/views/trace/decodetrace.cpp
index 8dea88321a7c642cf25dc447843fad403856ab60..c2f3cebe5b7b40c14b23ca8e922a2faebdcb1a0c 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,6 +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::abs;

 using std::all_of;
 using std::make_pair;
 using std::max;
 using std::all_of;
 using std::make_pair;
 using std::max;


@@ -327,8 +327,15 @@ void DecodeTrace::draw_annotations(vector<pv::data::decode::Annotation> annotati
 {
        using namespace pv::data::decode;
 
 {
        using namespace pv::data::decode;
 

-       vector<Annotation> a_block;
-       int p_end = INT_MIN;
+       Annotation::Class block_class = 0;
+       bool block_class_uniform = true;
+       qreal block_start = 0;
+       int block_ann_count = 0;
+
+       const Annotation *prev_ann;
+       qreal prev_end = INT_MIN;
+
+       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) =


@@ -343,18 +350,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 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 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;

 
 

-               const int delta = a_end - p_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;


@@ -366,32 +376,44 @@ void DecodeTrace::draw_annotations(vector<pv::data::decode::Annotation> annotati
                // 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
                // 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, row_color,
+                       if (block_ann_count == 1)
+                               draw_annotation(*prev_ann, p, h, pp, y, row_color,

                                        row_title_width);
                                        row_title_width);

-                       }
-                       else
-                               draw_annotation_block(a_block, p, h, y, row_color);
+                       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, row_color, row_title_width);
                        // Next annotation must start a new block. delta will be > 1
                }
 
                if (a_is_separate) {
                        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;
+                       block_ann_count = 0;

                } else {
                } 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, row_color, row_title_width);
-       else
-               draw_annotation_block(a_block, p, h, y, row_color);
+       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,
 }
 
 void DecodeTrace::draw_annotation(const pv::data::decode::Annotation &a,


@@ -406,7 +428,7 @@ void DecodeTrace::draw_annotation(const pv::data::decode::Annotation &a,
                pixels_offset;
        const double end = a.end_sample() / samples_per_pixel - pixels_offset;
 
                pixels_offset;
        const double end = a.end_sample() / samples_per_pixel - pixels_offset;
 

-       QColor color = get_annotation_color(row_color, a.format());
+       QColor color = get_annotation_color(row_color, a.ann_class());

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


@@ -419,36 +441,13 @@ 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(
-       vector<pv::data::decode::Annotation> annotations, QPainter &p, int h,
+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
 {
        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 double top = y + .5 - h / 2;
        const double bottom = y + .5 + h / 2;
 

-       QColor color = get_annotation_color(row_color, annotations.front().format());
-
-       // 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;
 
        const QRectF rect(start, top, end - start, bottom - top);
        const int r = h / 4;
 


@@ -456,17 +455,27 @@ void DecodeTrace::draw_annotation_block(
        p.setBrush(Qt::white);
        p.drawRoundedRect(rect, r, r);
 
        p.setBrush(Qt::white);
        p.drawRoundedRect(rect, r, r);
 

-       p.setPen((single_format ? color.darker() : Qt::gray));
-       p.setBrush(QBrush((single_format ? color : 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);
 }
 
 void DecodeTrace::draw_instant(const pv::data::decode::Annotation &a, QPainter &p,
        p.drawRoundedRect(rect, r, r);
 }
 
 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);
 


@@ -477,11 +486,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


@@ -490,7 +499,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),


@@ -549,7 +558,7 @@ void DecodeTrace::draw_error(QPainter &p, const QString &message,
                QRectF(pp.left(), INT_MIN / 2 + y, pp.right(), INT_MAX);
        const QRectF text_rect = p.boundingRect(bounding_rect,
                Qt::AlignCenter, message);
                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 qreal r = text_rect.height() / 4;

 
        p.drawRoundedRect(text_rect.adjusted(-r, -r, r, r), r, r,
                Qt::AbsoluteSize);
 
        p.drawRoundedRect(text_rect.adjusted(-r, -r, r, r), r, r,
                Qt::AbsoluteSize);


@@ -581,7 +590,7 @@ void DecodeTrace::draw_unresolved_period(QPainter &p, int h, int left, int right
                samples_per_pixel - pixels_offset, left - 1.0);
        const double end = min(sample_count / samples_per_pixel -
                pixels_offset, right + 1.0);
                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.setPen(QPen(Qt::NoPen));
        p.setBrush(Qt::white);