#include <QApplication>
#include <QCheckBox>
#include <QComboBox>
+#include <QDebug>
#include <QFormLayout>
#include <QGridLayout>
#include <QLabel>
#include <libsigrokcxx/libsigrokcxx.hpp>
-using std::bind;
using std::deque;
using std::div;
using std::div_t;
using std::make_pair;
using std::min;
using std::numeric_limits;
+using std::out_of_range;
using std::pair;
-using std::placeholders::_1;
using std::shared_ptr;
using std::vector;
namespace views {
namespace trace {
-const QColor AnalogSignal::SignalColours[4] = {
+const QColor AnalogSignal::SignalColors[4] = {
QColor(0xC4, 0xA0, 0x00), // Yellow
QColor(0x87, 0x20, 0x7A), // Magenta
QColor(0x20, 0x4A, 0x87), // Blue
const QColor AnalogSignal::GridMajorColor = QColor(0, 0, 0, 40 * 256 / 100);
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::SamplingPointColor(0x77, 0x77, 0x77);
+const QColor AnalogSignal::SamplingPointColorLo = QColor(200, 0, 0, 80 * 256 / 100);
+const QColor AnalogSignal::SamplingPointColorNe = QColor(0, 0, 0, 80 * 256 / 100);
+const QColor AnalogSignal::SamplingPointColorHi = 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);
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)]);
+ base_->set_color(SignalColors[base_->index() % countof(SignalColors)]);
update_scale();
}
+AnalogSignal::~AnalogSignal()
+{
+ GlobalSettings::remove_change_handler(this);
+}
+
shared_ptr<pv::data::SignalData> AnalogSignal::data() const
{
return base_->analog_data();
update_scale();
}
+void AnalogSignal::on_setting_changed(const QString &key, const QVariant &value)
+{
+ Signal::on_setting_changed(key, value);
+
+ if (key == GlobalSettings::Key_View_ConversionThresholdDispMode)
+ on_settingViewConversionThresholdDispMode_changed(value);
+}
+
void AnalogSignal::paint_back(QPainter &p, ViewItemPaintParams &pp)
{
if (!base_->enabled())
// 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_;
+ int thr_lo = visual_y - thresholds[0] * scale_;
+ int thr_hi = visual_y - thresholds[1] * scale_;
+ thr_lo = min(max(thr_lo, top), btm);
+ thr_hi = min(max(thr_hi, top), btm);
p.fillRect(QRectF(pp.left(), top, pp.width(), thr_hi - top),
QBrush(ThresholdColorHi));
p.fillRect(QRectF(pp.left(), thr_lo, pp.width(), btm - thr_lo),
QBrush(ThresholdColorLo));
} else {
- const double thr = visual_y - thresholds[0] * scale_;
+ int thr = visual_y - thresholds[0] * scale_;
+ thr = min(max(thr, top), btm);
p.fillRect(QRectF(pp.left(), top, pp.width(), thr - top),
QBrush(ThresholdColorHi));
if ((display_type_ == DisplayAnalog) || (display_type_ == DisplayBoth)) {
paint_grid(p, y, pp.left(), pp.right());
- const deque< shared_ptr<pv::data::AnalogSegment> > &segments =
- base_->analog_data()->analog_segments();
- if (segments.empty())
+ shared_ptr<pv::data::AnalogSegment> segment = get_analog_segment_to_paint();
+ if (!segment || (segment->get_sample_count() == 0))
return;
- const shared_ptr<pv::data::AnalogSegment> &segment =
- segments.front();
-
const double pixels_offset = pp.pixels_offset();
const double samplerate = max(1.0, segment->samplerate());
const pv::util::Timestamp& start_time = segment->start_time();
- const int64_t last_sample = segment->get_sample_count() - 1;
+ const int64_t last_sample = (int64_t)segment->get_sample_count() - 1;
const double samples_per_pixel = samplerate * pp.scale();
const pv::util::Timestamp start = samplerate * (pp.offset() - start_time);
const pv::util::Timestamp end = start + samples_per_pixel * pp.width();
// Show the info section on the right side of the trace
const QString infotext = QString("%1 V/div").arg(resolution_);
- p.setPen(base_->colour());
+ p.setPen(base_->color());
p.setFont(QApplication::font());
const QRectF bounding_rect = QRectF(pp.left(),
p.drawText(bounding_rect, Qt::AlignRight | Qt::AlignBottom, infotext);
}
+
+ if (show_hover_marker_)
+ paint_hover_marker(p);
}
void AnalogSignal::paint_grid(QPainter &p, int y, int left, int right)
(settings.value(GlobalSettings::Key_View_ShowSamplingPoints).toBool() ||
paint_thr_dots) && (samples_per_pixel < 0.25);
- p.setPen(base_->colour());
+ p.setPen(base_->color());
- const int64_t points_count = end - start;
+ const int64_t points_count = end - start + 1;
QPointF *points = new QPointF[points_count];
QPointF *point = points;
segment->get_samples(start, start + sample_count, sample_block);
const int w = 2;
- for (int64_t sample = start; sample != end; sample++, block_sample++) {
+ for (int64_t sample = start; sample <= end; sample++, block_sample++) {
if (block_sample == TracePaintBlockSize) {
block_sample = 0;
segment->get_samples(sample, sample + sample_count, sample_block);
}
- const float x = (sample / samples_per_pixel -
- pixels_offset) + left;
+ const float x = left + (sample / samples_per_pixel - pixels_offset);
*point++ = QPointF(x, y - sample_block[block_sample] * scale_);
}
}
- sampling_points[idx].push_back(
- QRectF(x - (w / 2), y - sample_block[block_sample] * scale_ - (w / 2), w, w));
+ sampling_points[idx].emplace_back(x - (w / 2), y - sample_block[block_sample] * scale_ - (w / 2), w, w);
}
}
delete[] sample_block;
if (show_sampling_points) {
if (paint_thr_dots) {
- p.setPen(SamplingPointColourNe);
+ p.setPen(SamplingPointColorNe);
p.drawRects(sampling_points[0].data(), sampling_points[0].size());
- p.setPen(SamplingPointColourLo);
+ p.setPen(SamplingPointColorLo);
p.drawRects(sampling_points[1].data(), sampling_points[1].size());
- p.setPen(SamplingPointColourHi);
+ p.setPen(SamplingPointColorHi);
p.drawRects(sampling_points[2].data(), sampling_points[2].size());
} else {
- p.setPen(SamplingPointColour);
+ p.setPen(SamplingPointColor);
p.drawRects(sampling_points[0].data(), sampling_points[0].size());
}
}
return;
p.setPen(QPen(Qt::NoPen));
- p.setBrush(base_->colour());
+ p.setBrush(base_->color());
QRectF *const rects = new QRectF[e.length];
QRectF *rect = rects;
const float high_offset = y - ph + signal_margin + 0.5f;
const float low_offset = y + nh - signal_margin - 0.5f;
- const deque< shared_ptr<pv::data::LogicSegment> > &segments =
- base_->logic_data()->logic_segments();
-
- if (segments.empty())
+ shared_ptr<pv::data::LogicSegment> segment = get_logic_segment_to_paint();
+ if (!segment || (segment->get_sample_count() == 0))
return;
- const shared_ptr<pv::data::LogicSegment> &segment =
- segments.front();
-
double samplerate = segment->samplerate();
// Show sample rate as 1Hz when it is unknown
const double pixels_offset = pp.pixels_offset();
const pv::util::Timestamp& start_time = segment->start_time();
- const int64_t last_sample = segment->get_sample_count() - 1;
+ const int64_t last_sample = (int64_t)segment->get_sample_count() - 1;
const double samples_per_pixel = samplerate * pp.scale();
const double pixels_per_sample = 1 / samples_per_pixel;
const pv::util::Timestamp start = samplerate * (pp.offset() - start_time);
sampling_point_x += pixels_per_sample;
};
- p.setPen(LogicSignal::EdgeColour);
+ p.setPen(LogicSignal::EdgeColor);
p.drawLines(edge_lines, edge_count);
delete[] edge_lines;
const unsigned int max_cap_line_count = edges.size();
QLineF *const cap_lines = new QLineF[max_cap_line_count];
- p.setPen(LogicSignal::HighColour);
+ p.setPen(LogicSignal::HighColor);
paint_logic_caps(p, cap_lines, edges, true, samples_per_pixel,
pixels_offset, pp.left(), high_offset);
- p.setPen(LogicSignal::LowColour);
+ p.setPen(LogicSignal::LowColor);
paint_logic_caps(p, cap_lines, edges, false, samples_per_pixel,
pixels_offset, pp.left(), low_offset);
// Paint the sampling points
if (show_sampling_points) {
- p.setPen(SamplingPointColour);
+ p.setPen(SamplingPointColor);
p.drawRects(sampling_points.data(), sampling_points.size());
}
}
p.drawLines(lines, line - lines);
}
+shared_ptr<pv::data::AnalogSegment> AnalogSignal::get_analog_segment_to_paint() const
+{
+ shared_ptr<pv::data::AnalogSegment> segment;
+
+ const deque< shared_ptr<pv::data::AnalogSegment> > &segments =
+ base_->analog_data()->analog_segments();
+
+ if (!segments.empty()) {
+ if (segment_display_mode_ == ShowLastSegmentOnly)
+ segment = segments.back();
+
+ if ((segment_display_mode_ == ShowSingleSegmentOnly) ||
+ (segment_display_mode_ == ShowLastCompleteSegmentOnly)) {
+ try {
+ segment = segments.at(current_segment_);
+ } catch (out_of_range&) {
+ qDebug() << "Current analog segment out of range for signal" << base_->name() << ":" << current_segment_;
+ }
+ }
+ }
+
+ return segment;
+}
+
+shared_ptr<pv::data::LogicSegment> AnalogSignal::get_logic_segment_to_paint() const
+{
+ shared_ptr<pv::data::LogicSegment> segment;
+
+ const deque< shared_ptr<pv::data::LogicSegment> > &segments =
+ base_->logic_data()->logic_segments();
+
+ if (!segments.empty()) {
+ if (segment_display_mode_ == ShowLastSegmentOnly)
+ segment = segments.back();
+
+ if ((segment_display_mode_ == ShowSingleSegmentOnly) ||
+ (segment_display_mode_ == ShowLastCompleteSegmentOnly)) {
+ try {
+ segment = segments.at(current_segment_);
+ } catch (out_of_range&) {
+ qDebug() << "Current logic segment out of range for signal" << base_->name() << ":" << current_segment_;
+ }
+ }
+ }
+
+ return segment;
+}
+
float AnalogSignal::get_resolution(int scale_index)
{
const float seq[] = {1.0f, 2.0f, 5.0f};
projects / pulseview.git / blobdiff