#include <libsigrokcxx/libsigrokcxx.hpp>
+using std::bind;
using std::deque;
using std::div;
using std::div_t;
using std::min;
using std::numeric_limits;
using std::pair;
+using std::placeholders::_1;
using std::shared_ptr;
using std::vector;
const QColor AnalogSignal::GridMinorColor = QColor(0, 0, 0, 20 * 256 / 100);
const QColor AnalogSignal::SamplingPointColour(0x77, 0x77, 0x77);
+const QColor AnalogSignal::SamplingPointColourLo = QColor(200, 0, 0, 80 * 256 / 100);
+const QColor AnalogSignal::SamplingPointColourNe = QColor(0, 0, 0, 80 * 256 / 100);
+const QColor AnalogSignal::SamplingPointColourHi = QColor(0, 200, 0, 80 * 256 / 100);
const QColor AnalogSignal::ThresholdColor = QColor(0, 0, 0, 30 * 256 / 100);
+const QColor AnalogSignal::ThresholdColorLo = QColor(255, 0, 0, 8 * 256 / 100);
+const QColor AnalogSignal::ThresholdColorNe = QColor(0, 0, 0, 10 * 256 / 100);
+const QColor AnalogSignal::ThresholdColorHi = QColor(0, 255, 0, 8 * 256 / 100);
const int64_t AnalogSignal::TracePaintBlockSize = 1024 * 1024; // 4 MiB (due to float)
const float AnalogSignal::EnvelopeThreshold = 64.0f;
connect(analog_data, SIGNAL(min_max_changed(float, float)),
this, SLOT(on_min_max_changed(float, float)));
+ GlobalSettings::register_change_handler(GlobalSettings::Key_View_ConversionThresholdDispMode,
+ bind(&AnalogSignal::on_settingViewConversionThresholdDispMode_changed, this, _1));
+
GlobalSettings gs;
+ conversion_threshold_disp_mode_ =
+ gs.value(GlobalSettings::Key_View_ConversionThresholdDispMode).toInt();
+
div_height_ = gs.value(GlobalSettings::Key_View_DefaultDivHeight).toInt();
base_->set_colour(SignalColours[base_->index() % countof(SignalColours)]);
void AnalogSignal::paint_back(QPainter &p, ViewItemPaintParams &pp)
{
- if (base_->enabled()) {
+ if (!base_->enabled())
+ return;
+
+ bool paint_thr_bg =
+ conversion_threshold_disp_mode_ == GlobalSettings::ConvThrDispMode_Background;
+
+ const vector<double> thresholds = base_->get_conversion_thresholds();
+
+ // Only display thresholds if we have some and we show analog samples
+ if ((thresholds.size() > 0) && paint_thr_bg &&
+ ((display_type_ == DisplayAnalog) || (display_type_ == DisplayBoth))) {
+
+ const int visual_y = get_visual_y();
+ const pair<int, int> extents = v_extents();
+ const int top = visual_y + extents.first;
+ const int btm = visual_y + extents.second;
+
+ // Draw high/neutral/low areas
+ if (thresholds.size() == 2) {
+ const double thr_lo = visual_y - thresholds[0] * scale_;
+ const double thr_hi = visual_y - thresholds[1] * scale_;
+
+ p.fillRect(QRectF(pp.left(), top, pp.width(), thr_hi - top),
+ QBrush(ThresholdColorHi));
+ p.fillRect(QRectF(pp.left(), thr_hi, pp.width(), thr_lo - thr_hi),
+ QBrush(ThresholdColorNe));
+ p.fillRect(QRectF(pp.left(), thr_lo, pp.width(), btm - thr_lo),
+ QBrush(ThresholdColorLo));
+ } else {
+ const double thr = visual_y - thresholds[0] * scale_;
+
+ p.fillRect(QRectF(pp.left(), top, pp.width(), thr - top),
+ QBrush(ThresholdColorHi));
+ p.fillRect(QRectF(pp.left(), thr, pp.width(), btm - thr),
+ QBrush(ThresholdColorLo));
+ }
+
+ paint_axis(p, pp, get_visual_y());
+ } else {
Trace::paint_back(p, pp);
paint_axis(p, pp, get_visual_y());
}
pixels_offset, samples_per_pixel);
}
- const SignalBase::ConversionType conv_type = base_->get_conversion_type();
-
- if (((conv_type == SignalBase::A2LConversionByThreshold) ||
- (conv_type == SignalBase::A2LConversionBySchmittTrigger))) {
-
- if ((display_type_ == DisplayAnalog) || (display_type_ == DisplayBoth))
- paint_conversion_thresholds(p, pp);
-
- if ((display_type_ == DisplayConverted) || (display_type_ == DisplayBoth))
- paint_logic_mid(p, pp);
- }
+ if ((display_type_ == DisplayConverted) || (display_type_ == DisplayBoth))
+ paint_logic_mid(p, pp);
}
void AnalogSignal::paint_fore(QPainter &p, ViewItemPaintParams &pp)
if (end <= start)
return;
+ bool paint_thr_dots =
+ (base_->get_conversion_type() != data::SignalBase::NoConversion) &&
+ (conversion_threshold_disp_mode_ == GlobalSettings::ConvThrDispMode_Dots);
+
+ vector<double> thresholds;
+ if (paint_thr_dots)
+ thresholds = base_->get_conversion_thresholds();
+
// Calculate and paint the sampling points if enabled and useful
GlobalSettings settings;
const bool show_sampling_points =
- settings.value(GlobalSettings::Key_View_ShowSamplingPoints).toBool() &&
- (samples_per_pixel < 0.25);
+ (settings.value(GlobalSettings::Key_View_ShowSamplingPoints).toBool() ||
+ paint_thr_dots) && (samples_per_pixel < 0.25);
p.setPen(base_->colour());
QPointF *points = new QPointF[points_count];
QPointF *point = points;
- QRectF *sampling_points = nullptr;
- if (show_sampling_points)
- sampling_points = new QRectF[points_count];
- QRectF *sampling_point = sampling_points;
+ vector<QRectF> sampling_points[3];
int64_t sample_count = min(points_count, TracePaintBlockSize);
int64_t block_sample = 0;
*point++ = QPointF(x, y - sample_block[block_sample] * scale_);
- if (show_sampling_points)
- *sampling_point++ =
- QRectF(x - (w / 2), y - sample_block[block_sample] * scale_ - (w / 2), w, w);
+ if (show_sampling_points) {
+ int idx = 0; // Neutral
+
+ if (paint_thr_dots) {
+ if (thresholds.size() == 1)
+ idx = (sample_block[block_sample] >= thresholds[0]) ? 2 : 1;
+ else if (thresholds.size() == 2) {
+ if (sample_block[block_sample] > thresholds[1])
+ idx = 2; // High
+ else if (sample_block[block_sample] < thresholds[0])
+ idx = 1; // Low
+ }
+ }
+
+ sampling_points[idx].push_back(
+ QRectF(x - (w / 2), y - sample_block[block_sample] * scale_ - (w / 2), w, w));
+ }
}
delete[] sample_block;
p.drawPolyline(points, points_count);
if (show_sampling_points) {
- p.setPen(SamplingPointColour);
- p.drawRects(sampling_points, points_count);
- delete[] sampling_points;
+ if (paint_thr_dots) {
+ p.setPen(SamplingPointColourNe);
+ p.drawRects(sampling_points[0].data(), sampling_points[0].size());
+ p.setPen(SamplingPointColourLo);
+ p.drawRects(sampling_points[1].data(), sampling_points[1].size());
+ p.setPen(SamplingPointColourHi);
+ p.drawRects(sampling_points[2].data(), sampling_points[2].size());
+ } else {
+ p.setPen(SamplingPointColour);
+ p.drawRects(sampling_points[0].data(), sampling_points[0].size());
+ }
}
delete[] points;
delete[] e.samples;
}
-void AnalogSignal::paint_conversion_thresholds(QPainter &p,
- ViewItemPaintParams &pp)
-{
- if (!base_->enabled() || !base_->logic_data())
- return;
-
- // TODO Register a change handler instead of querying this with every repaint
- GlobalSettings settings;
- const bool show_conversion_thresholds =
- settings.value(GlobalSettings::Key_View_ShowConversionThresholds).toBool();
-
- if (!show_conversion_thresholds)
- return;
-
- const vector<double> thresholds = base_->get_conversion_thresholds();
- const int y = get_visual_y();
-
- p.setRenderHint(QPainter::Antialiasing, false);
-
- p.setPen(ThresholdColor);
-
- if (thresholds.size() == 2) {
- // Draw as hatched block because two thresholds denote lower/upper level
- const double thr_y0 = y - thresholds[0] * scale_;
- const double thr_y1 = y - thresholds[1] * scale_;
- p.fillRect(QRect(pp.left(), thr_y0, pp.right(), thr_y1 - thr_y0),
- QBrush(ThresholdColor, Qt::BDiagPattern));
- } else {
- // Draw as individual lines
- for (const double thr : thresholds) {
- const double thr_y = y - thr * scale_;
- p.drawLine(QPointF(pp.left(), thr_y), QPointF(pp.right(), thr_y));
- }
- }
-
- p.setRenderHint(QPainter::Antialiasing, true);
-}
-
void AnalogSignal::paint_logic_mid(QPainter &p, ViewItemPaintParams &pp)
{
QLineF *line;
owner_->row_item_appearance_changed(false, true);
}
+void AnalogSignal::on_settingViewConversionThresholdDispMode_changed(const QVariant new_value)
+{
+ conversion_threshold_disp_mode_ = new_value.toInt();
+
+ if (owner_)
+ owner_->row_item_appearance_changed(false, true);
+}
+
} // namespace trace
} // namespace views
} // namespace pv
projects / pulseview.git / blobdiff