#include <QFormLayout>
#include <QGridLayout>
#include <QLabel>
-#include <QSpinBox>
#include <QString>
#include "analogsignal.hpp"
#include "pv/data/logic.hpp"
#include "pv/data/logicsegment.hpp"
#include "pv/data/signalbase.hpp"
-#include "pv/view/view.hpp"
-#include "pv/view/logicsignal.hpp"
#include "pv/globalsettings.hpp"
+#include "pv/view/logicsignal.hpp"
+#include "pv/view/view.hpp"
#include <libsigrokcxx/libsigrokcxx.hpp>
QColor(0x4E, 0x9A, 0x06) // Green
};
-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::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 float AnalogSignal::EnvelopeThreshold = 256.0f;
+const int64_t AnalogSignal::TracePaintBlockSize = 1024 * 1024; // 4 MiB (due to float)
+const float AnalogSignal::EnvelopeThreshold = 64.0f;
const int AnalogSignal::MaximumVDivs = 10;
const int AnalogSignal::MinScaleIndex = -6;
{
const int h = (pos_vdivs_ + neg_vdivs_) * div_height_;
- return ((scale_index_drag_offset_ - scale_index_) *
- h / 4) - h / 2;
+ return ((scale_index_drag_offset_ - scale_index_) * h / 4) - h / 2;
}
void AnalogSignal::scale_handle_dragged(int offset)
{
const int h = (pos_vdivs_ + neg_vdivs_) * div_height_;
- scale_index_ = scale_index_drag_offset_ -
- (offset + h / 2) / (h / 4);
+ scale_index_ = scale_index_drag_offset_ - (offset + h / 2) / (h / 4);
update_scale();
}
update_scale();
}
-void AnalogSignal::paint_back(QPainter &p, const ViewItemPaintParams &pp)
+void AnalogSignal::paint_back(QPainter &p, ViewItemPaintParams &pp)
{
if (base_->enabled()) {
Trace::paint_back(p, pp);
}
}
-void AnalogSignal::paint_mid(QPainter &p, const ViewItemPaintParams &pp)
+void AnalogSignal::paint_mid(QPainter &p, ViewItemPaintParams &pp)
{
assert(base_->analog_data());
assert(owner_);
}
}
-void AnalogSignal::paint_fore(QPainter &p, const ViewItemPaintParams &pp)
+void AnalogSignal::paint_fore(QPainter &p, ViewItemPaintParams &pp)
{
if (!enabled())
return;
- const int y = get_visual_y();
+ if ((display_type_ == DisplayAnalog) || (display_type_ == DisplayBoth)) {
+ const int y = get_visual_y();
- // Show the info section on the right side of the trace
- const QString infotext = QString("%1 V/div").arg(resolution_);
+ // 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.setFont(QApplication::font());
+ p.setPen(base_->colour());
+ p.setFont(QApplication::font());
- const QRectF bounding_rect = QRectF(pp.left(),
- y + v_extents().first,
- pp.width() - InfoTextMarginRight,
- v_extents().second - v_extents().first - InfoTextMarginBottom);
+ const QRectF bounding_rect = QRectF(pp.left(),
+ y + v_extents().first,
+ pp.width() - InfoTextMarginRight,
+ v_extents().second - v_extents().first - InfoTextMarginBottom);
- p.drawText(bounding_rect, Qt::AlignRight | Qt::AlignBottom, infotext);
+ p.drawText(bounding_rect, Qt::AlignRight | Qt::AlignBottom, infotext);
+ }
}
void AnalogSignal::paint_grid(QPainter &p, int y, int left, int right)
{
p.setRenderHint(QPainter::Antialiasing, false);
+ GlobalSettings settings;
+ const bool show_analog_minor_grid =
+ settings.value(GlobalSettings::Key_View_ShowAnalogMinorGrid).toBool();
+
if (pos_vdivs_ > 0) {
p.setPen(QPen(GridMajorColor, 1, Qt::DashLine));
for (int i = 1; i <= pos_vdivs_; i++) {
const float dy = i * div_height_;
p.drawLine(QLineF(left, y - dy, right, y - dy));
}
+ }
+ if ((pos_vdivs_ > 0) && show_analog_minor_grid) {
p.setPen(QPen(GridMinorColor, 1, Qt::DashLine));
for (int i = 0; i < pos_vdivs_; i++) {
const float dy = i * div_height_;
const float dy = i * div_height_;
p.drawLine(QLineF(left, y + dy, right, y + dy));
}
+ }
+ if ((pos_vdivs_ > 0) && show_analog_minor_grid) {
p.setPen(QPen(GridMinorColor, 1, Qt::DashLine));
for (int i = 0; i < neg_vdivs_; i++) {
const float dy = i * div_height_;
int y, int left, const int64_t start, const int64_t end,
const double pixels_offset, const double samples_per_pixel)
{
+ if (end <= start)
+ return;
+
+ // 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);
+
p.setPen(base_->colour());
const int64_t points_count = end - start;
QPointF *points = new QPointF[points_count];
QPointF *point = points;
- QRectF *const sampling_points = new QRectF[points_count];
+ QRectF *sampling_points = nullptr;
+ if (show_sampling_points)
+ sampling_points = new QRectF[points_count];
QRectF *sampling_point = sampling_points;
- pv::data::SegmentAnalogDataIterator* it =
- segment->begin_sample_iteration(start);
+ int64_t sample_count = min(points_count, TracePaintBlockSize);
+ int64_t block_sample = 0;
+ const float *sample_block = segment->get_samples(start, start + sample_count);
const int w = 2;
- for (int64_t sample = start; sample != end; sample++) {
+ for (int64_t sample = start; sample != end; sample++, block_sample++) {
+
+ if (block_sample == TracePaintBlockSize) {
+ block_sample = 0;
+ delete[] sample_block;
+ sample_count = min(points_count - sample, TracePaintBlockSize);
+ sample_block = segment->get_samples(sample, sample + sample_count);
+ }
+
const float x = (sample / samples_per_pixel -
pixels_offset) + left;
- *point++ = QPointF(x, y - *((float*)it->value) * scale_);
- *sampling_point++ = QRectF(x - (w / 2), y - *((float*)it->value) * scale_ - (w / 2), w, w);
+ *point++ = QPointF(x, y - sample_block[block_sample] * scale_);
- segment->continue_sample_iteration(it, 1);
+ if (show_sampling_points)
+ *sampling_point++ =
+ QRectF(x - (w / 2), y - sample_block[block_sample] * scale_ - (w / 2), w, w);
}
- segment->end_sample_iteration(it);
+ delete[] sample_block;
p.drawPolyline(points, points_count);
- // Paint the sampling points if enabled
- GlobalSettings settings;
- const bool show_sampling_points =
- settings.value(GlobalSettings::Key_View_ShowSamplingPoints).toBool();
-
- if (show_sampling_points && (samples_per_pixel < 0.25)) {
+ if (show_sampling_points) {
p.setPen(SamplingPointColour);
p.drawRects(sampling_points, points_count);
+ delete[] sampling_points;
}
delete[] points;
- delete[] sampling_points;
}
void AnalogSignal::paint_envelope(QPainter &p,
QRectF *const rects = new QRectF[e.length];
QRectF *rect = rects;
- for (uint64_t sample = 0; sample < e.length-1; sample++) {
+ for (uint64_t sample = 0; sample < e.length - 1; sample++) {
const float x = ((e.scale * sample + e.start) /
samples_per_pixel - pixels_offset) + left;
const AnalogSegment::EnvelopeSample *const s =
// We overlap this sample with the next so that vertical
// gaps do not appear during steep rising or falling edges
- const float b = y - max(s->max, (s+1)->min) * scale_;
- const float t = y - min(s->min, (s+1)->max) * scale_;
+ const float b = y - max(s->max, (s + 1)->min) * scale_;
+ const float t = y - min(s->min, (s + 1)->max) * scale_;
float h = b - t;
if (h >= 0.0f && h <= 1.0f)
delete[] e.samples;
}
-void AnalogSignal::paint_logic_mid(QPainter &p, const ViewItemPaintParams &pp)
+void AnalogSignal::paint_logic_mid(QPainter &p, ViewItemPaintParams &pp)
{
QLineF *line;
const int y = get_visual_y();
- if (!base_->enabled())
+ if (!base_->enabled() || !base_->logic_data())
return;
const int signal_margin =
const deque< shared_ptr<pv::data::LogicSegment> > &segments =
base_->logic_data()->logic_segments();
+
if (segments.empty())
return;
owner_->row_item_appearance_changed(false, true);
}
-void AnalogSignal::perform_autoranging(bool force_update)
+void AnalogSignal::perform_autoranging(bool keep_divs, bool force_update)
{
const deque< shared_ptr<pv::data::AnalogSegment> > &segments =
base_->analog_data()->analog_segments();
prev_min = min;
prev_max = max;
- // Use all divs for the positive range if there are no negative values
- if ((min == 0) && (neg_vdivs_ > 0)) {
- pos_vdivs_ += neg_vdivs_;
- neg_vdivs_ = 0;
+ // If we're allowed to alter the div assignment...
+ if (!keep_divs) {
+ // Use all divs for the positive range if there are no negative values
+ if ((min == 0) && (neg_vdivs_ > 0)) {
+ pos_vdivs_ += neg_vdivs_;
+ neg_vdivs_ = 0;
+ }
+
+ // Split up the divs if there are negative values but no negative divs
+ if ((min < 0) && (neg_vdivs_ == 0)) {
+ neg_vdivs_ = pos_vdivs_ / 2;
+ pos_vdivs_ -= neg_vdivs_;
+ }
}
- // Split up the divs if there are negative values but no negative divs
+ // If there is still no positive div when we need it, add one
+ // (this can happen when pos_vdivs==neg_vdivs==0)
+ if ((max > 0) && (pos_vdivs_ == 0)) {
+ pos_vdivs_ = 1;
+ owner_->extents_changed(false, true);
+ }
+
+ // If there is still no negative div when we need it, add one
+ // (this can happen when pos_vdivs was 0 or 1 when trying to split)
if ((min < 0) && (neg_vdivs_ == 0)) {
- neg_vdivs_ = pos_vdivs_ / 2;
- pos_vdivs_ -= neg_vdivs_;
+ neg_vdivs_ = 1;
+ owner_->extents_changed(false, true);
}
double min_value_per_div;
QFormLayout *const layout = new QFormLayout;
// Add the number of vdivs
- QSpinBox *pvdiv_sb = new QSpinBox(parent);
- pvdiv_sb->setRange(0, MaximumVDivs);
- pvdiv_sb->setValue(pos_vdivs_);
- connect(pvdiv_sb, SIGNAL(valueChanged(int)),
+ pvdiv_sb_ = new QSpinBox(parent);
+ pvdiv_sb_->setRange(0, MaximumVDivs);
+ pvdiv_sb_->setValue(pos_vdivs_);
+ connect(pvdiv_sb_, SIGNAL(valueChanged(int)),
this, SLOT(on_pos_vdivs_changed(int)));
- layout->addRow(tr("Number of pos vertical divs"), pvdiv_sb);
+ layout->addRow(tr("Number of pos vertical divs"), pvdiv_sb_);
- QSpinBox *nvdiv_sb = new QSpinBox(parent);
- nvdiv_sb->setRange(0, MaximumVDivs);
- nvdiv_sb->setValue(neg_vdivs_);
- connect(nvdiv_sb, SIGNAL(valueChanged(int)),
+ nvdiv_sb_ = new QSpinBox(parent);
+ nvdiv_sb_->setRange(0, MaximumVDivs);
+ nvdiv_sb_->setValue(neg_vdivs_);
+ connect(nvdiv_sb_, SIGNAL(valueChanged(int)),
this, SLOT(on_neg_vdivs_changed(int)));
- layout->addRow(tr("Number of neg vertical divs"), nvdiv_sb);
+ layout->addRow(tr("Number of neg vertical divs"), nvdiv_sb_);
// Add the vertical resolution
resolution_cb_ = new QComboBox(parent);
cur_idx = conversion_cb_->findData(QVariant(conversion_type_));
conversion_cb_->setCurrentIndex(cur_idx);
- layout->addRow(tr("Conversion"), conversion_cb_);
+// layout->addRow(tr("Conversion"), conversion_cb_);
connect(conversion_cb_, SIGNAL(currentIndexChanged(int)),
this, SLOT(on_conversion_changed(int)));
cur_idx = display_type_cb_->findData(QVariant(display_type_));
display_type_cb_->setCurrentIndex(cur_idx);
- layout->addRow(tr("Traces to show:"), display_type_cb_);
+// layout->addRow(tr("Traces to show:"), display_type_cb_);
+
+ connect(display_type_cb_, SIGNAL(currentIndexChanged(int)),
+ this, SLOT(on_display_type_changed(int)));
form->addRow(layout);
}
void AnalogSignal::on_samples_added()
{
- perform_autoranging();
-
- if (owner_) {
- // Call order is important, otherwise the lazy event handler won't work
- owner_->extents_changed(false, true);
- owner_->row_item_appearance_changed(false, true);
- }
+ perform_autoranging(false, false);
}
void AnalogSignal::on_pos_vdivs_changed(int vdivs)
{
+ if (vdivs == pos_vdivs_)
+ return;
+
pos_vdivs_ = vdivs;
- if (autoranging_)
- perform_autoranging(true);
+ // There has to be at least one div, positive or negative
+ if ((neg_vdivs_ == 0) && (pos_vdivs_ == 0)) {
+ pos_vdivs_ = 1;
+ if (pvdiv_sb_)
+ pvdiv_sb_->setValue(pos_vdivs_);
+ }
+
+ if (autoranging_) {
+ perform_autoranging(true, true);
+
+ // It could be that a positive or negative div was added, so update
+ if (pvdiv_sb_) {
+ pvdiv_sb_->setValue(pos_vdivs_);
+ nvdiv_sb_->setValue(neg_vdivs_);
+ }
+ }
if (owner_) {
// Call order is important, otherwise the lazy event handler won't work
void AnalogSignal::on_neg_vdivs_changed(int vdivs)
{
+ if (vdivs == neg_vdivs_)
+ return;
+
neg_vdivs_ = vdivs;
- if (autoranging_)
- perform_autoranging(true);
+ // There has to be at least one div, positive or negative
+ if ((neg_vdivs_ == 0) && (pos_vdivs_ == 0)) {
+ pos_vdivs_ = 1;
+ if (pvdiv_sb_)
+ pvdiv_sb_->setValue(pos_vdivs_);
+ }
+
+ if (autoranging_) {
+ perform_autoranging(true, true);
+
+ // It could be that a positive or negative div was added, so update
+ if (pvdiv_sb_) {
+ pvdiv_sb_->setValue(pos_vdivs_);
+ nvdiv_sb_->setValue(neg_vdivs_);
+ }
+ }
if (owner_) {
// Call order is important, otherwise the lazy event handler won't work
autoranging_ = (state == Qt::Checked);
if (autoranging_)
- perform_autoranging(true);
+ perform_autoranging(false, true);
if (owner_) {
// Call order is important, otherwise the lazy event handler won't work
}
}
+void AnalogSignal::on_display_type_changed(int index)
+{
+ display_type_ = (DisplayType)(display_type_cb_->itemData(index).toInt());
+
+ if (owner_)
+ owner_->row_item_appearance_changed(false, true);
+}
+
} // namespace TraceView
} // namespace views
} // namespace pv