Add generic "Create marker here" context menu entry

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

diff --git a/pv/views/trace/analogsignal.cpp b/pv/views/trace/analogsignal.cpp
index 0419b03b698eb208496e15b75957c2eb8b6d9663..5b3241d2d35beb1aa4a552743aff00705d5319ac 100644 (file)
--- a/pv/views/trace/analogsignal.cpp
+++ b/pv/views/trace/analogsignal.cpp
@@ -537,6 +537,7 @@ void AnalogSignal::paint_logic_mid(QPainter &p, ViewItemPaintParams &pp)
        const int nh = min(neg_vdivs_, 1) * div_height_;
        const float high_offset = y - ph + signal_margin + 0.5f;
        const float low_offset = y + nh - signal_margin - 0.5f;
+       const float signal_height = low_offset - high_offset;
 
        shared_ptr<pv::data::LogicSegment> segment = get_logic_segment_to_paint();
        if (!segment || (segment->get_sample_count() == 0))
@@ -565,6 +566,11 @@ void AnalogSignal::paint_logic_mid(QPainter &p, ViewItemPaintParams &pp)
                samples_per_pixel / LogicSignal::Oversampling, 0);
        assert(edges.size() >= 2);
 
+       const float first_sample_x =
+               pp.left() + (edges.front().first / samples_per_pixel - pixels_offset);
+       const float last_sample_x =
+               pp.left() + (edges.back().first / samples_per_pixel - pixels_offset);
+
        // Check whether we need to paint the sampling points
        GlobalSettings settings;
        const bool show_sampling_points =
@@ -572,25 +578,56 @@ void AnalogSignal::paint_logic_mid(QPainter &p, ViewItemPaintParams &pp)
                (samples_per_pixel < 0.25);
 
        vector<QRectF> sampling_points;
-       float sampling_point_x = 0.0f;
+       float sampling_point_x = first_sample_x;
        int64_t sampling_point_sample = start_sample;
        const int w = 2;
 
-       if (show_sampling_points) {
+       if (show_sampling_points)
                sampling_points.reserve(end_sample - start_sample + 1);
-               sampling_point_x = (edges.cbegin()->first / samples_per_pixel - pixels_offset) + pp.left();
-       }
+
+       // Check whether we need to fill the high areas
+       const bool fill_high_areas =
+               settings.value(GlobalSettings::Key_View_FillSignalHighAreas).toBool();
+       vector<QRectF> high_rects;
+       float rising_edge_x;
+       bool rising_edge_seen = false;
 
        // Paint the edges
        const unsigned int edge_count = edges.size() - 2;
        QLineF *const edge_lines = new QLineF[edge_count];
        line = edge_lines;
 
+       if (edges.front().second) {
+               // Beginning of trace is high
+               rising_edge_x = first_sample_x;
+               rising_edge_seen = true;
+       }
+
        for (auto i = edges.cbegin() + 1; i != edges.cend() - 1; i++) {
-               const float x = ((*i).first / samples_per_pixel -
-                       pixels_offset) + pp.left();
+               // Note: multiple edges occupying a single pixel are represented by an edge
+               // with undefined logic level. This means that only the first falling edge
+               // after a rising edge corresponds to said rising edge - and vice versa. If
+               // more edges with the same logic level follow, they denote multiple edges.
+
+               const float x = pp.left() + ((*i).first / samples_per_pixel - pixels_offset);
                *line++ = QLineF(x, high_offset, x, low_offset);
 
+               if (fill_high_areas) {
+                       // Any edge terminates a high area
+                       const int width = x - rising_edge_x;
+                       if (rising_edge_seen && (width > 0)) {
+                               high_rects.emplace_back(rising_edge_x, high_offset,
+                                       width, signal_height);
+                               rising_edge_seen = false;
+                       }
+
+                       // Only rising edges start high areas
+                       if ((*i).second) {
+                               rising_edge_x = x;
+                               rising_edge_seen = true;
+                       }
+               }
+
                if (show_sampling_points)
                        while (sampling_point_sample < (*i).first) {
                                const float y = (*i).second ? low_offset : high_offset;
@@ -612,6 +649,19 @@ void AnalogSignal::paint_logic_mid(QPainter &p, ViewItemPaintParams &pp)
                        sampling_point_x += pixels_per_sample;
                };
 
+       if (fill_high_areas) {
+               // Add last high rectangle if the signal is still high at the end of the trace
+               if (rising_edge_seen && (edges.cend() - 1)->second)
+                       high_rects.emplace_back(rising_edge_x, high_offset,
+                               last_sample_x - rising_edge_x, signal_height);
+
+               const QColor fill_color = QColor::fromRgba(settings.value(
+                       GlobalSettings::Key_View_FillSignalHighAreaColor).value<uint32_t>());
+               p.setPen(fill_color);
+               p.setBrush(fill_color);
+               p.drawRects((const QRectF*)(high_rects.data()), high_rects.size());
+       }
+
        p.setPen(LogicSignal::EdgeColor);
        p.drawLines(edge_lines, edge_count);
        delete[] edge_lines;